mwojcik
/
thermostat
forked from M-Labs/thermostat
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

merge into: mwojcik:shorter_main
Branches Tags
mwojcik:master
mwojcik:nixflakes
mwojcik:shorter_main
mwojcik:softspi
M-Labs:master
M-Labs:dev-gui
M-Labs:GUI
M-Labs:softspi
...
pull from: M-Labs:master
Branches Tags
M-Labs:master
M-Labs:dev-gui
M-Labs:GUI
M-Labs:softspi
mwojcik:master
mwojcik:nixflakes
mwojcik:shorter_main
mwojcik:softspi

82 Commits
shorter_ma ... master

Author SHA1 Message Date
atse 52e35d2a98 flake: Format with nixfmt-rfc-style 
Also set up formatter so that `nix fmt` formats.
 2024-11-04 18:38:08 +08:00
atse f1da910c11 pytec: Complete client 
Expose all available Thermostat commands to the pytec client, and add
disconnect functionality.
 2024-11-04 18:03:50 +08:00
atse 9848c65de5 Fix command parser failing test due to changes 2024-10-21 15:51:21 +08:00
atse 069d791802 Rename all Steinhart-Hart references to B-param 
The Steinhart-Hart equation was changed in code long ago to the
B-parameter equation. Rename references to it and the interface
accordingly. The `s-h` command is now `b-p`.

The reason the name "B-Parameter" equation was chosen over
"Beta-Parameter" was due to its easier searchability.
 2024-10-21 15:44:46 +08:00
atse bd9ae997ae PwmLimits: Use uom quantities for fields not f64s 2024-10-21 11:13:19 +08:00
atse 45eb55d36d steinhart_hart: Beta Parameter uom dimensions 
The Beta Parameter is not dimensionless, and has unit kelvin.
Incorporate that into the type system.
 2024-10-21 11:12:47 +08:00
atse eddf05cae7 channels: get_i -> get_i_set 2024-10-21 11:12:16 +08:00
atse f68ae12c8d TCP command: Rename `pwm` to `output` 
Current limit pins are driven by PWM inputs to the MAX1968 driver, but
this is an implementation detail, and should not be exposed in the form
of the command interface. Rename "pwm" to "output" in all instances.

See M-Labs/thermostat#62 (comment).
 2024-10-21 10:09:24 +08:00
atse 101a68fcfc README: Update instruction on finding Rust version 2024-10-16 11:16:23 +08:00
atse 9d1adbc7f7 README: Fixes to grammar and instructions 2024-10-16 11:15:57 +08:00
atse 47fa9f757e README: Document interval key in reports 2024-10-16 11:15:28 +08:00
atse d1df6b8e3a README: Add updated info on new hardware revision 2024-10-16 11:15:10 +08:00
atse 0ffd784e91 README: Improve description of report command 2024-10-16 11:14:40 +08:00
atse d8ec083dbc Apply clippy suggestions 2024-10-14 13:25:49 +08:00
atse 1962135e79 Apply cargo fmt 2024-10-14 13:25:49 +08:00
atse fcb5cf1d4e Add command parser test for polarity command 2024-10-14 12:46:13 +08:00
atse d517087e10 README: Purge all traces of report mode 2024-10-14 10:08:08 +08:00
atse 798b400aa5 Show and save set value for PWM limits 
Show in PwmSummary the set value, before all PWM duty calculations
instead of the machine value after the calculations. Also save the set
value into the flash store instead of the machine value.
 2024-10-07 10:41:31 +08:00
atse 93dc39e943 README: Document PWM value clamping 2024-10-07 10:41:31 +08:00
atse 5c3b759d0c PwmSummary: Don't show max PWM values 
Putting the maximum in PwmSummary has little use - the maximum never
changes throughout the runtime of the firmware and can be replaced by
documentation elsewhere.
 2024-10-07 10:41:31 +08:00
atse 6224486662 Show polarity in pwm command 2024-09-30 17:36:50 +08:00
atse 32bd49b258 Add a command to reverse the output polarity 
Effectively flips all values related to the directionality of current
through the TEC, including current maximums. The reversed status is
stored in the flash store and will be loaded on reset once saved.

The command is "pwm <ch> polarity <normal/reversed>", where the "normal"
polarity is indicated by the front panel markings.

This is needed for IDC cable connections to the Sinara 5432 DAC
"Zotino", since the TEC pins of the 10-pin connector on the Thermostat
and Zotino have opposite polarities.
 2024-09-30 17:36:47 +08:00
linuswck ad54842c43 Fix wrong current limit duty cycle calculation 
- prev commit assumed setting 3.3V -> 3A current limit which is wrong
- Please refer to the MAX1968 datasheet for the duty cycle
calculation equation
 2024-09-25 17:20:29 +08:00
atse b336c4f993 Remove report mode 
As the report mode command breaks the send-receive architecture model of
the command interface, and is deemed an anti-feature, making clients
difficult to write, remove it from the firmware entirely.
 2024-09-25 17:19:34 +08:00
linuswck 680193b34b Fix incorrect dac calibration algo 
- Fix abnormally long calibration time
 2024-09-20 21:21:14 +08:00
atse ae4bea0c8a gitignore: Ignore .bin files and __pycache__ 2024-09-19 10:08:58 +08:00
atse 1f2de942e4 flake: Add rlwrap to devShell 2024-09-19 10:06:45 +08:00
atse 1041d3ecbb Improve the VREF calibration routine 
* Fix wrong calibration of VREF on startup. Caused new v2.2.2 boards to
wrongly calibrate the zero-point to ~2.2 V instead of 1.5 V.

* Fix bootloop on some boards.

* Adjust watchdog interval accordingly.
 2024-09-16 18:14:47 +08:00
atse c6040899dd ItecPin -> ITecPin 2024-08-12 13:02:22 +08:00
atse 9d89104f50 README: Fix command to make firmware BIN (#115) 
Co-authored-by: atse <atse@m-labs.hk>
Co-committed-by: atse <atse@m-labs.hk>
 2024-08-07 18:22:48 +08:00
atse 136c7a0b52 Calculate current_abs_max_tec_i from all channels 
Instead of picking channels 0 and 1. Helps to generalise for more than 2
channels.
 2024-08-07 16:14:28 +08:00
atse 5000cae1b1 Grammar fixes 2024-08-07 16:09:30 +08:00
atse 78ec77509f flake: Install LLVM in devShell too 
So that developers can use `llvm-objcopy` in their devShells as well.
 2024-08-07 16:06:19 +08:00
atse 52aa3890c1 Update nix repos 2024-08-06 13:38:58 +08:00
atse 1ae6a6fdd4 flake: More concise devShell 
No need for C compiler in development shell + use "packages" to
explicitly refer to devShell packages
 2024-08-06 11:14:25 +08:00
atse 7333d2cea5 flake: Don't use deprecated flake output schemas 2024-08-06 11:09:51 +08:00
atse 44e9130010 Use oxalica's rust-overlay 
Follow ARTIQ, and in this project lets us include the version number
directly in flake.nix instead of linking to the toml file of a specific
release date, as we use stable Rust.

Also, from nixpkgs manual:
    both oxalica's overlay and fenix better integrate with nix and cache
    optimizations. Because of this and ergonomics, either of those
    community projects should be preferred to the Mozilla's Rust overlay
    (nixpkgs-mozilla).
 2024-06-27 12:42:00 +08:00
linuswck 5b0c6f7018 Save i_set into ChannelConfig 2024-05-18 10:50:54 +08:00
linuswck 1007982b48 clamp TEC settings to a valid & design specs range 
- Not respecting the design specs can cause hardware to get stuck in unrecoverable state
 2024-05-10 15:17:46 +08:00
linuswck 925601f4f5 rm pid setpoint change kick 2024-05-10 10:29:08 +08:00
linuswck 8c1cb3117c README: Add notes on `i_tec` & `tec_i`readouts 2024-05-02 17:48:47 +08:00
linuswck 1fcfe41a63 Add averaging filter on the pin_adc readings 
- Adapted from Kirdy Firmware
- Can reduce the i_tec readings noise dispersion
 2024-05-02 16:49:55 +08:00
linuswck 9fce19a418 Revert "Disable feedback current readout on flawed HW Revs" 
This reverts commit ae3d8b51d4.
 2024-05-02 14:38:40 +08:00
atse 00d5feaa8d Limit i_set within range of MAX1968 chip 2024-04-24 18:05:20 +08:00
atse 09be55e12a Don't load REF pin of MAX1968 chip on HWRevs < 3.0 
The REF pin of the MAX1968 on hardware revisions v2.x is missing a
buffer, loading the pin on every CPU ADC read. Avoid reading from it and
leave the pin floating on affected hardware revisions, and return the
nominal 1.5V instead.
 2024-04-03 16:32:57 +08:00
atse 76547be90a i_tec -> i_set 
i_tec is reserved for the voltage signal coming out of the MAX1968 chip
for now.
 2024-02-14 17:27:12 +08:00
atse 8b975e656e Stop i_set from fluctuating in every report 
i_set is a user-provided value that shouldn't fluctuate with every VREF
measurement. Storing i_set as channel state is the simplest way to avoid
that.
 2024-02-14 17:21:39 +08:00
atse ae3d8b51d4 Disable feedback current readout on flawed HW Revs 
Thermostats v2.2 and below have a noisy and offset feedback current
`tec_i` caused by missing hardware on 2 MAX1968 TEC driver pins:

1. A missing RC filter on the ITEC pin that would have isolated CPU
sampling pulses from the signal; and
2. Some missing buffering on the VREF pin that would have avoided
loading the VREF signal, preventing voltage drops from the nominal 1.5V.

Since the resulting signal `tec_i` derived from these two signals can
have an error of around +/- 100mA, and readback may affect the stability
performance of the Thermostat, disable current readback entirely on
affected hardware revisions for now.

See https://github.com/sinara-hw/Thermostat/issues/117 and
https://github.com/sinara-hw/Thermostat/issues/120.

On hardware revisions v3.x and above, this would be fixed.
 2024-01-31 12:12:22 +08:00
atse 17edae44fb README: Proofread fan control documentation 2024-01-30 12:43:19 +08:00
atse 03b4561142 Refactor current_abs_max_tec_i to use uom 2024-01-30 11:41:52 +08:00
atse 631a10938d README: Remove VREF 2024-01-26 17:00:27 +08:00
atse 6cd6a6a2c2 Fix warning '...not permit being left uninit..d' 
Put SocketState initialisation logic in new. This avoids using an unsafe
and unnerving MaybeUninit::uninit().assume_init() to initialise an
array, which the compiler yells at since it causes undefined behavior.
 2024-01-17 15:29:56 +08:00
atse b93e2fbb7b Update rust edition 2024-01-17 15:29:56 +08:00
atse 76b95f66e0 Use latest working stable rust 2024-01-17 15:29:41 +08:00
atse 8008870bc1 Switch panic_handler to panic_halt 
Move away from panic_abort as it uses intrinsics, which is nightly only.
 2024-01-17 15:29:15 +08:00
atse 7646ff9037 README: Avoid deprecated OpenOCD ST-Link config 
The config file interface/stlink-v2-1.cfg is deprecated, and the warning
message encourages the switch to interface/stlink.cfg. Do accordingly.
 2024-01-04 12:44:52 +08:00
atse 6f81a63d12 Remove unused LED parameters 2023-09-20 15:51:37 +08:00
atse 78012f6fdd flake: Use rust from manifest, not from pkgs 
Fix the rustPlatform deprecation warnings properly.
 2023-09-20 11:29:38 +08:00
atse bb4f43fe1c Remove stale reference to channel_state vref 2023-08-22 17:16:25 +08:00
atse 9df0fe406f Remove VREF in reports 
Since VREF is an implementation detail, there shouldn't be a need to
include it in reports.

The ChannelState vref is removed along with it as its only use was to
save VREF measurements for later reporting.
 2023-08-22 11:40:42 +08:00
topquark12 5ba74c6d9b README: Correct expected TEC polarity 
Adhere to the general convention of TECs cooling down with positive
voltages.
 2023-08-15 16:37:51 +08:00
atse 6f0acc73b8 Update LED L3 for PID status on every cycle 
Check if PID is engaged on any channel every cycle, and match the status
with LED L3.
 2023-08-10 16:43:19 +08:00
atse f29e86310d Update nix repos 2023-08-09 11:23:32 +08:00
atse b04a61c414 Turn off LED L3 only when all channels have no PID 
Change the behaviour of LED L3 to turn off only when all channels have
PID disengaged, as opposed to when any channel disengages PID.

Otherwise, when disengaging PID on a Thermostat that has had both
channels engaged in PID, the LED would turn off, even when PID is still
engaged on the other channel.

This lets the LED better reflect the status of the Thermostat as a
whole, as it would stay on as long as PID is engaged on at least one
channel.
 2023-08-07 16:09:54 +08:00
atse cd680dd6cd README: Correct unit of time in reports 2023-07-20 17:45:16 +08:00
Egor Savkin e3e3237d2f Emit warning when current/voltage limits are near zero 
Signed-off-by: Egor Savkin <es@m-labs.hk>
 2023-03-23 16:58:05 +08:00
Egor Savkin 570c0324b3 implement support for fan PWM 
Co-authored-by: Egor Savkin <es@m-labs.hk>
Co-committed-by: Egor Savkin <es@m-labs.hk>
 2023-03-22 17:15:49 +08:00
mwojcik 5688b2f1bb flake: update stm32-eth sha256 hash 2022-03-02 17:21:17 +08:00
mwojcik 1b2f2f3888 update code to use stm32f4xx-hal 0.10.1 API 2022-03-02 17:21:17 +08:00
mwojcik e6f63ec940 cargo/nix: update rustc, stm32-eth, smoltcp 2022-03-02 17:21:17 +08:00
mwojcik 67446ae99e cargo/flake: update package versions 2022-03-02 17:21:17 +08:00
topquark12 26ad2f0119 rewrite PID 
Rewrite of PID according to https://hackmd.io/IACbwcOTSt6Adj3_F9bKuw PID implementation.

To migrate:
- TEC+/- pin polarity has to be reversed.
- Some saved settings might be wiped upon flashing of new firmware, back up settings before upgrade
- Min / Max integral parameters no longer exist
- kp, ki, kd will likely need to be retuned

The software has been tested on hardware with good temperature control stability.

Reviewed-on: M-Labs/thermostat#68
Co-authored-by: topquark12 <aw@m-labs.hk>
Co-committed-by: topquark12 <aw@m-labs.hk>
 2022-02-24 20:16:47 +08:00
Alex Wong 69dabf5aa1 update hash 2022-01-24 17:20:32 +08:00
mwojcik a26cdfabb1 readme: update CI links 2022-01-19 11:37:01 +08:00
mwojcik 4d43709f76 nix flakes support (#64) 
Reviewed-on: M-Labs/thermostat#64
Co-authored-by: mwojcik <mw@m-labs.hk>
Co-committed-by: mwojcik <mw@m-labs.hk>
 2022-01-19 11:13:47 +08:00
Sebastien Bourdeauducq 1c00e732fa README: minor corrections 2022-01-05 08:22:43 +08:00
Sebastien Bourdeauducq 09082b24a5 README: update build instructions 2022-01-05 08:04:25 +08:00
Sebastien Bourdeauducq 85e8273d51 shell.nix: follow nix-scripts 2022-01-05 07:54:07 +08:00
Sebastien Bourdeauducq e81c6d1692 README: fix objcopy command 2022-01-05 07:50:53 +08:00
Sebastien Bourdeauducq 1f644fd62c README: fix nix-scripts folder 2021-07-14 08:43:59 +08:00
Sebastien Bourdeauducq 4f1d865d2b README: fix Hydra links 2021-07-14 08:42:53 +08:00
topquark12 e6a5c31db6 main.rs refactor to reduce length (#60) 
Move command handling to command_handler.rs to shorten main.rs

Reviewed-on: M-Labs/thermostat#60
Co-authored-by: topquark12 <aw@m-labs.hk>
Co-committed-by: topquark12 <aw@m-labs.hk>
 2021-06-07 10:07:05 +08:00
37 changed files with 2657 additions and 1650 deletions
Show Stats Expand all files Collapse all files

3
.gitignore vendored
View File

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

137
Cargo.lock generated
View File

@ -1,5 +1,7 @@
# This file is automatically @generated by Cargo. # This file is automatically @generated by Cargo.
# It is not intended for manual editing. # It is not intended for manual editing.
version = 3
[[package]] [[package]]
name = "aligned" name = "aligned"
version = "0.3.4" version = "0.3.4"
@ -68,12 +70,9 @@ checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
[[package]] [[package]]
name = "cast" name = "cast"
version = "0.2.3" version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4b9434b9a5aa1450faa3f9cb14ea0e8c53bb5d2b3c1bfd1ab4fc03e9f33fbfb0" checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
dependencies = [
"rustc_version",
]
[[package]] [[package]]
name = "cfg-if" name = "cfg-if"
@ -82,14 +81,37 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822" checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
[[package]] [[package]]
name = "cortex-m" name = "chrono"
version = "0.6.4" version = "0.4.19"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "88cdafeafba636c00c467ded7f1587210725a1adfab0c24028a7844b87738263" checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73"
dependencies = [
"num-integer",
"num-traits",
]
[[package]]
name = "cortex-m"
version = "0.6.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9075300b07c6a56263b9b582c214d0ff037b00d45ec9fde1cc711490c56f1bb9"
dependencies = [ dependencies = [
"aligned", "aligned",
"bare-metal 0.2.5", "bare-metal 0.2.5",
"bitfield", "bitfield",
"cortex-m 0.7.4",
"volatile-register",
]
[[package]]
name = "cortex-m"
version = "0.7.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "37ff967e867ca14eba0c34ac25cd71ea98c678e741e3915d923999bb2fe7c826"
dependencies = [
"bare-metal 0.2.5",
"bitfield",
"embedded-hal",
"volatile-register", "volatile-register",
] ]
@ -99,7 +121,7 @@ version = "0.6.2"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d63959cb1e003dd97233fee6762351540253237eadf06fcdcb98cbfa3f9be4a" checksum = "1d63959cb1e003dd97233fee6762351540253237eadf06fcdcb98cbfa3f9be4a"
dependencies = [ dependencies = [
"cortex-m", "cortex-m 0.6.7",
"cortex-m-semihosting", "cortex-m-semihosting",
"log", "log",
] ]
@ -110,10 +132,19 @@ version = "0.6.13"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "980c9d0233a909f355ed297ef122f257942de5e0a2cb1c39f60684b65bcb90fb" checksum = "980c9d0233a909f355ed297ef122f257942de5e0a2cb1c39f60684b65bcb90fb"
dependencies = [ dependencies = [
"cortex-m-rt-macros", "cortex-m-rt-macros 0.1.8",
"r0", "r0",
] ]
[[package]]
name = "cortex-m-rt"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3c433da385b720d5bb9f52362fa2782420798e68d40d67bfe4b0d992aba5dfe7"
dependencies = [
"cortex-m-rt-macros 0.7.0",
]
[[package]] [[package]]
name = "cortex-m-rt-macros" name = "cortex-m-rt-macros"
version = "0.1.8" version = "0.1.8"
@ -125,13 +156,24 @@ dependencies = [
"syn", "syn",
] ]
[[package]]
name = "cortex-m-rt-macros"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f0f6f3e36f203cfedbc78b357fb28730aa2c6dc1ab060ee5c2405e843988d3c7"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]] [[package]]
name = "cortex-m-semihosting" name = "cortex-m-semihosting"
version = "0.3.7" version = "0.3.7"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6bffa6c1454368a6aa4811ae60964c38e6996d397ff8095a8b9211b1c1f749bc" checksum = "6bffa6c1454368a6aa4811ae60964c38e6996d397ff8095a8b9211b1c1f749bc"
dependencies = [ dependencies = [
"cortex-m", "cortex-m 0.7.4",
] ]
[[package]] [[package]]
@ -154,9 +196,9 @@ dependencies = [
[[package]] [[package]]
name = "embedded-hal" name = "embedded-hal"
version = "0.2.4" version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fa998ce59ec9765d15216393af37a58961ddcefb14c753b4816ba2191d865fcb" checksum = "e36cfb62ff156596c892272f3015ef952fe1525e85261fa3a7f327bd6b384ab9"
dependencies = [ dependencies = [
"nb 0.1.3", "nb 0.1.3",
"void", "void",
@ -264,6 +306,16 @@ dependencies = [
"version_check", "version_check",
] ]
[[package]]
name = "num-integer"
version = "0.1.44"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
dependencies = [
"autocfg",
"num-traits",
]
[[package]] [[package]]
name = "num-traits" name = "num-traits"
version = "0.2.14" version = "0.2.14"
@ -275,10 +327,10 @@ dependencies = [
] ]
[[package]] [[package]]
name = "panic-abort" name = "panic-halt"
version = "0.3.2" version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4e20e6499bbbc412f280b04a42346b356c6fa0753d5fd22b7bd752ff34c778ee" checksum = "de96540e0ebde571dc55c73d60ef407c653844e6f9a1e2fdbd40c07b9252d812"
[[package]] [[package]]
name = "panic-semihosting" name = "panic-semihosting"
@ -286,7 +338,7 @@ version = "0.5.6"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c3d55dedd501dfd02514646e0af4d7016ce36bc12ae177ef52056989966a1eec" checksum = "c3d55dedd501dfd02514646e0af4d7016ce36bc12ae177ef52056989966a1eec"
dependencies = [ dependencies = [
"cortex-m", "cortex-m 0.7.4",
"cortex-m-semihosting", "cortex-m-semihosting",
] ]
@ -333,9 +385,18 @@ checksum = "e2a38df5b15c8d5c7e8654189744d8e396bddc18ad48041a500ce52d6948941f"
[[package]] [[package]]
name = "rand_core" name = "rand_core"
version = "0.5.1" version = "0.6.3"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19" checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
[[package]]
name = "rtcc"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ef35f9dcbf434a34dcc99b3ebba1c1945d49c70832958e932e83dc63a5273994"
dependencies = [
"chrono",
]
[[package]] [[package]]
name = "rustc_version" name = "rustc_version"
@ -404,9 +465,9 @@ dependencies = [
[[package]] [[package]]
name = "smoltcp" name = "smoltcp"
version = "0.6.0" version = "0.7.5"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0fe46639fd2ec79eadf8fe719f237a7a0bd4dac5d957f1ca5bbdbc1c3c39e53a" checksum = "3e4a069bef843d170df47e7c0a8bf8d037f217d9f5b325865acc3e466ffe40d3"
dependencies = [ dependencies = [
"bitflags", "bitflags",
"byteorder", "byteorder",
@ -423,10 +484,10 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
[[package]] [[package]]
name = "stm32-eth" name = "stm32-eth"
version = "0.2.0" version = "0.2.0"
source = "git+https://github.com/stm32-rs/stm32-eth.git#4d6b29bf1ecdd1f68e5bc304a3d4f170049896c8" source = "git+https://github.com/stm32-rs/stm32-eth.git?rev=3759c5c9#3759c5c99c0ab69bb71759030766bc0fba0b6cde"
dependencies = [ dependencies = [
"aligned", "aligned",
"cortex-m", "cortex-m 0.7.4",
"smoltcp", "smoltcp",
"stm32f4xx-hal", "stm32f4xx-hal",
"volatile-register", "volatile-register",
@ -434,29 +495,31 @@ dependencies = [
[[package]] [[package]]
name = "stm32f4" name = "stm32f4"
version = "0.11.0" version = "0.13.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "11460b4de3a84f072e2cf6e76306c64d27f405a0e83bace0a726f555ddf4bf33" checksum = "da3d56009c8f32e4f208dbea17df72484154d1040a8969b75d8c73eb7b18fe8f"
dependencies = [ dependencies = [
"bare-metal 0.2.5", "bare-metal 0.2.5",
"cortex-m", "cortex-m 0.7.4",
"cortex-m-rt", "cortex-m-rt 0.6.13",
"vcell", "vcell",
] ]
[[package]] [[package]]
name = "stm32f4xx-hal" name = "stm32f4xx-hal"
version = "0.8.3" version = "0.10.1"
source = "git+https://github.com/astro/stm32f4xx-hal.git?branch=flash#9171ef176a90b1177f350fe2bc1eac625769a041" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3a06fde2dd27c0ba934c9e69b62af66eb1c20dbb6d741b187a763912e9892d13"
dependencies = [ dependencies = [
"bare-metal 0.2.5", "bare-metal 1.0.0",
"cast", "cast",
"cortex-m", "cortex-m 0.7.4",
"cortex-m-rt", "cortex-m-rt 0.7.1",
"embedded-dma", "embedded-dma",
"embedded-hal", "embedded-hal",
"nb 0.1.3", "nb 1.0.0",
"rand_core", "rand_core",
"rtcc",
"stm32f4", "stm32f4",
"synopsys-usb-otg", "synopsys-usb-otg",
"void", "void",
@ -479,7 +542,7 @@ version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "461676dcf123675b3d3b02e2390e6a690cd186aacf2f439af7673c79e2561d53" checksum = "461676dcf123675b3d3b02e2390e6a690cd186aacf2f439af7673c79e2561d53"
dependencies = [ dependencies = [
"cortex-m", "cortex-m 0.6.7",
"usb-device", "usb-device",
"vcell", "vcell",
] ]
@ -491,16 +554,16 @@ dependencies = [
"bare-metal 1.0.0", "bare-metal 1.0.0",
"bit_field", "bit_field",
"byteorder", "byteorder",
"cortex-m", "cortex-m 0.6.7",
"cortex-m-log", "cortex-m-log",
"cortex-m-rt", "cortex-m-rt 0.6.13",
"eeprom24x", "eeprom24x",
"heapless", "heapless",
"log", "log",
"nb 1.0.0", "nb 1.0.0",
"nom", "nom",
"num-traits", "num-traits",
"panic-abort", "panic-halt",
"panic-semihosting", "panic-semihosting",
"serde", "serde",
"serde-json-core", "serde-json-core",

14
Cargo.toml
View File

@ -7,23 +7,23 @@ authors = ["Astro <astro@spaceboyz.net>"]
version = "0.0.0" version = "0.0.0"
keywords = ["thermostat", "laser", "physics"] keywords = ["thermostat", "laser", "physics"]
repository = "https://git.m-labs.hk/M-Labs/thermostat" repository = "https://git.m-labs.hk/M-Labs/thermostat"
edition = "2018" edition = "2021"
[package.metadata.docs.rs] [package.metadata.docs.rs]
features = [] features = []
default-target = "thumbv7em-none-eabihf" default-target = "thumbv7em-none-eabihf"
[dependencies] [dependencies]
panic-abort = "0.3" panic-halt = "0.2"
panic-semihosting = { version = "0.5", optional = true } panic-semihosting = { version = "0.5", optional = true }
log = "0.4" log = "0.4"
bare-metal = "1" bare-metal = "1"
cortex-m = "0.6" cortex-m = "0.6"
cortex-m-rt = { version = "0.6", features = ["device"] } cortex-m-rt = { version = "0.6", features = ["device"] }
cortex-m-log = { version = "0.6", features = ["log-integration"] } cortex-m-log = { version = "0.6", features = ["log-integration"] }
stm32f4xx-hal = { version = "0.8", features = ["rt", "stm32f427", "usb_fs"] } stm32f4xx-hal = { version = "=0.10.1", features = ["rt", "stm32f427", "usb_fs"] }
stm32-eth = { version = "0.2", features = ["stm32f427", "smoltcp-phy"], git = "https://github.com/stm32-rs/stm32-eth.git" } stm32-eth = { rev = "3759c5c9", features = ["stm32f427", "smoltcp-phy"], git = "https://github.com/stm32-rs/stm32-eth.git" }
smoltcp = { version = "0.6.0", default-features = false, features = ["proto-ipv4", "socket-tcp", "log"] } smoltcp = { version = "0.7.5", default-features = false, features = ["proto-ipv4", "socket-tcp", "log"] }
bit_field = "0.10" bit_field = "0.10"
byteorder = { version = "1", default-features = false } byteorder = { version = "1", default-features = false }
nom = { version = "5", default-features = false } nom = { version = "5", default-features = false }
@ -38,10 +38,6 @@ heapless = "0.5"
serde-json-core = "0.1" serde-json-core = "0.1"
sfkv = "0.1" sfkv = "0.1"
[patch.crates-io]
# TODO: pending https://github.com/stm32-rs/stm32f4xx-hal/pull/239
stm32f4xx-hal = { git = "https://github.com/astro/stm32f4xx-hal.git", branch = "flash" }
[features] [features]
semihosting = ["panic-semihosting", "cortex-m-log/semihosting"] semihosting = ["panic-semihosting", "cortex-m-log/semihosting"]

153
README.md
View File

@ -1,35 +1,35 @@
# Firmware for the Sinara 8451 Thermostat # Firmware for the Sinara 8451 Thermostat
- [x] [Continuous Integration](https://nixbld.m-labs.hk/job/stm32/stm32/thermostat) - [x] [Continuous Integration](https://nixbld.m-labs.hk/job/mcu/thermostat/thermostat)
- [x] Download latest firmware build: [ELF](https://nixbld.m-labs.hk/job/stm32/stm32/thermostat/latest/download/1) [BIN](https://nixbld.m-labs.hk/job/stm32/stm32/thermostat/latest/download/2) - [x] Download latest firmware build: [ELF](https://nixbld.m-labs.hk/job/mcu/thermostat/thermostat/latest/download/1) [BIN](https://nixbld.m-labs.hk/job/mcu/thermostat/thermostat/latest/download/2)
## Building ## Building
### Reproducible build with Nix ### Reproducible build with Nix
See the `stm32` folder of the [nix-scripts repository](https://git.m-labs.hk/M-Labs/nix-scripts). Thermostat firmware is packaged using the [Nix](https://nixos.org) Flakes system. Install Nix 2.4+ and enable flakes by adding ``experimental-features = nix-command flakes`` to ``nix.conf`` (e.g. ``~/.config/nix/nix.conf``).
### Debian-based systems (tested on Ubuntu 19.10) Once you have Flakes enabled, you can use ``nix build`` to build the firmware.
- install git, clone this repository ### Development environment
- install [rustup](https://rustup.rs/)
Clone this repository and with Nix Flakes enabled, use the following commands:
```shell ```shell
rustup toolchain install nightly nix develop
rustup update
rustup target add thumbv7em-none-eabihf --toolchain nightly
rustup default nightly
cargo build --release cargo build --release
``` ```
The resulting ELF file will be located under `target/thumbv7em-none-eabihf/release/thermostat` The resulting ELF file will be located under `target/thumbv7em-none-eabihf/release/thermostat`.
Alternatively, you can install the Rust toolchain without Nix using rustup; see the `rust` variable in `flake.nix` to determine which Rust version to use.
## Debugging ## Debugging
Connect SWDIO/SWCLK/RST/GND to a programmer such as ST-Link v2.1. Run OpenOCD: Connect SWDIO/SWCLK/RST/GND to a programmer such as ST-Link v2.1. Run OpenOCD:
```shell ```shell
openocd -f interface/stlink-v2-1.cfg -f target/stm32f4x.cfg openocd -f interface/stlink.cfg -f target/stm32f4x.cfg
``` ```
You may need to power up the programmer before powering the device. You may need to power up the programmer before powering the device.
@ -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: `arm-none-eabi-objcopy -O binary thermostat.elf thermostat.bin` (you can skip this step if using the BIN from Hydra) * Convert firmware from ELF to BIN: `llvm-objcopy -O binary target/thumbv7em-none-eabihf/release/thermostat thermostat.bin` (you can skip this step if using the BIN from Hydra)
* Connect to the Micro USB connector to Thermostat below the RJ45. * 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
@ -64,7 +64,7 @@ On a Windows machine install [st.com](https://st.com) DfuSe USB device firmware
### OpenOCD ### OpenOCD
```shell ```shell
openocd -f interface/stlink-v2-1.cfg -f target/stm32f4x.cfg -c "program target/thumbv7em-none-eabihf/release/thermostat verify reset;exit" openocd -f interface/stlink.cfg -f target/stm32f4x.cfg -c "program target/thumbv7em-none-eabihf/release/thermostat verify reset;exit"
``` ```
## Network ## Network
@ -84,9 +84,7 @@ invalidate the first line of input.
### Reading ADC input ### Reading ADC input
Set report mode to `on` for a continuous stream of input data. ADC input data is provided in reports. Query for the latest report with the command `report`. See the *Reports* section below.
The scope of this setting is per TCP session.
### TCP commands ### TCP commands
@ -94,38 +92,41 @@ The scope of this setting is per TCP session.
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 current input | | `report` | Show latest report of channel parameters (see *Reports* section) |
| `report mode` | Show current report mode | | `output` | Show current output settings |
| `report mode <off/on>` | Set report mode | | `output <0/1> max_i_pos <amp>` | Set maximum positive output current, clamped to [0, 2] |
| `pwm` | Show current PWM settings | | `output <0/1> max_i_neg <amp>` | Set maximum negative output current, clamped to [0, 2] |
| `pwm <0/1> max_i_pos <amp>` | Set PWM duty cycle for **max_i_pos** to *ampere* | | `output <0/1> max_v <volt>` | Set maximum output voltage, clamped to [0, 4] |
| `pwm <0/1> max_i_neg <amp>` | Set PWM duty cycle for **max_i_neg** to *- ampere* | | `output <0/1> i_set <amp>` | Disengage PID, set fixed output current, clamped to [-2, 2] |
| `pwm <0/1> max_v <volts>` | Set PWM duty cycle for **max_v** to *volt* | | `output <0/1> polarity <normal/reversed>` | Set output current polarity, with 'normal' being the front panel polarity |
| `pwm <0/1> i_set <amp>` | Disengage PID, set **i_set** DAC to *ampere* | | `output <0/1> pid` | Let output current to be controlled by the PID |
| `pwm <0/1> pid` | Set PWM to be controlled by PID | | `center <0/1> <volt>` | Set the MAX1968 0A-centerpoint to the specified fixed voltage |
| `center <0/1> <volts>` | Set the MAX1968 0A-centerpoint to *volts* | | `center <0/1> vref` | Set the MAX1968 0A-centerpoint to measure from VREF |
| `center <0/1> vref` | Set the MAX1968 0A-centerpoint to measure from VREF | | `pid` | Show PID configuration |
| `pid` | Show PID configuration | | `pid <0/1> target <deg_celsius>` | Set the PID controller target temperature |
| `pid <0/1> target <deg_celsius>` | Set the PID controller target temperature | | `pid <0/1> kp <value>` | Set proportional gain |
| `pid <0/1> kp <value>` | Set proportional gain | | `pid <0/1> ki <value>` | Set integral gain |
| `pid <0/1> ki <value>` | Set integral gain | | `pid <0/1> kd <value>` | Set differential gain |
| `pid <0/1> kd <value>` | Set differential gain | | `pid <0/1> output_min <amp>` | Set mininum output |
| `pid <0/1> output_min <amp>` | Set mininum output | | `pid <0/1> output_max <amp>` | Set maximum output |
| `pid <0/1> output_max <amp>` | Set maximum output | | `b-p` | Show B-Parameter equation parameters |
| `pid <0/1> integral_min <value>` | Set integral lower bound | | `b-p <0/1> <t0/b/r0> <value>` | Set B-Parameter for a channel |
| `pid <0/1> integral_max <value>` | Set integral upper bound | | `postfilter` | Show postfilter settings |
| `s-h` | Show Steinhart-Hart equation parameters | | `postfilter <0/1> off` | Disable postfilter |
| `s-h <0/1> <t0/b/r0> <value>` | Set Steinhart-Hart parameter for a channel | | `postfilter <0/1> rate <rate>` | Set postfilter output data rate |
| `postfilter` | Show postfilter settings | | `load [0/1]` | Restore configuration for channel all/0/1 from flash |
| `postfilter <0/1> off` | Disable postfilter | | `save [0/1]` | Save configuration for channel all/0/1 to flash |
| `postfilter <0/1> rate <rate>` | Set postfilter output data rate | | `reset` | Reset the device |
| `load [0/1]` | Restore configuration for channel all/0/1 from flash | | `dfu` | Reset device and enters USB device firmware update (DFU) mode |
| `save [0/1]` | Save configuration for channel all/0/1 to flash | | `ipv4 <X.X.X.X/L> [Y.Y.Y.Y]` | Configure IPv4 address, netmask length, and optional default gateway |
| `reset` | Reset the device | | `fan` | Show current fan settings and sensors' measurements |
| `dfu` | Reset device and enters USB device firmware update (DFU) mode | | `fan <value>` | Set fan power with values from 1 to 100 |
| `ipv4 <X.X.X.X/L> [Y.Y.Y.Y]` | Configure IPv4 address, netmask length, and optional default gateway | | `fan auto` | Enable automatic fan speed control |
| `fcurve <a> <b> <c>` | Set fan controller curve coefficients (see *Fan control* section) |
| `fcurve default` | Set fan controller curve coefficients to defaults (see *Fan control* section) |
| `hwrev` | Show hardware revision, and settings related to it |
## USB ## USB
@ -143,22 +144,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 Beta parameters ADC. To prepare conversion to a temperature, set the parameters
for the Steinhart-Hart equation. for the B-Parameter equation.
Set the base temperature in degrees celsius for the channel 0 thermistor: Set the base temperature in degrees celsius for the channel 0 thermistor:
``` ```
s-h 0 t0 20 b-p 0 t0 20
``` ```
Set the resistance in Ohms measured at the base temperature t0: Set the resistance in Ohms measured at the base temperature t0:
``` ```
s-h 0 r0 10000 b-p 0 r0 10000
``` ```
Set the Beta parameter: Set the Beta parameter:
``` ```
s-h 0 b 3800 b-p 0 b 3800
``` ```
### 50/60 Hz filtering ### 50/60 Hz filtering
@ -180,16 +181,18 @@ postfilter rate can be tuned with the `postfilter` command.
- Connect TEC module device 1 to TEC1- and TEC1+. - Connect TEC module device 1 to TEC1- and TEC1+.
- The GND pin is for shielding not for sinking TEC module currents. - The GND pin is for shielding not for sinking TEC module currents.
When using a TEC module with the Thermostat, the Thermostat expects the thermal load (where the thermistor is located) to heat up with a positive software current set point, and cool down 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 of the MAX1968 TEC driver has analog/PWM inputs for setting Each MAX1968 TEC driver has analog/PWM inputs for setting
output limits. output limits.
Use the `pwm` command to see current settings and maximum values. Use the `output` command to see current settings and maximum values.
| Limit | Unit | Description | | Limit | Unit | Description |
| --- | :---: | --- | | --- | :---: | --- |
@ -200,28 +203,28 @@ Use the `pwm` command to see current settings and maximum values.
Example: set the maximum voltage of channel 0 to 1.5 V. Example: set the maximum voltage of channel 0 to 1.5 V.
``` ```
pwm 0 max_v 1.5 output 0 max_v 1.5
``` ```
Example: set the maximum negative current of channel 0 to -3 A. Example: set the maximum negative current of channel 0 to -3 A.
``` ```
pwm 0 max_i_neg 3 output 0 max_i_neg 3
``` ```
Example: set the maximum positive current of channel 1 to 3 A. Example: set the maximum positive current of channel 1 to 3 A.
``` ```
pwm 0 max_i_pos 3 output 0 max_i_pos 3
``` ```
### Open-loop mode ### Open-loop mode
To manually control TEC output current, omit the limit parameter of To manually control TEC output current, set a fixed output current with
the `pwm` command. Doing so will disengage the PID control for that the `output` command. Doing so will disengage the PID control for that
channel. channel.
Example: set output current of channel 0 to 0 A. Example: set output current of channel 0 to 0 A.
``` ```
pwm 0 i_set 0 output 0 i_set 0
``` ```
## PID-stabilized temperature control ## PID-stabilized temperature control
@ -234,7 +237,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:
``` ```
pwm 0 pid output 0 pid
``` ```
## LED indicators ## LED indicators
@ -247,20 +250,19 @@ pwm 0 pid
## Reports ## Reports
Use the bare `report` command to obtain a single report. Enable Use the bare `report` command to obtain a single report. Reports are JSON objects
continuous reporting with `report mode on`. Reports are JSON objects
with the following keys. with the following keys.
| Key | Unit | Description | | Key | Unit | Description |
| --- | :---: | --- | | --- | :---: | --- |
| `channel` | Integer | Channel `0`, or `1` | | `channel` | Integer | Channel `0`, or `1` |
| `time` | Milliseconds | Temperature measurement time | | `time` | Seconds | Temperature measurement time |
| `interval` | Seconds | Time elapsed since last report update on channel |
| `adc` | Volts | AD7172 input | | `adc` | Volts | AD7172 input |
| `sens` | Ohms | Thermistor resistance derived from `adc` | | `sens` | Ohms | Thermistor resistance derived from `adc` |
| `temperature` | Degrees Celsius | Steinhart-Hart conversion result derived from `sens` | | `temperature` | Degrees Celsius | B-Parameter conversion result derived from `sens` |
| `pid_engaged` | Boolean | `true` if in closed-loop mode | | `pid_engaged` | Boolean | `true` if in closed-loop mode |
| `i_set` | Amperes | TEC output current | | `i_set` | Amperes | TEC output current |
| `vref` | Volts | MAX1968 VREF (1.5 V) |
| `dac_value` | Volts | AD5680 output derived from `i_set` | | `dac_value` | Volts | AD5680 output derived from `i_set` |
| `dac_feedback` | Volts | ADC measurement of the AD5680 output | | `dac_feedback` | Volts | ADC measurement of the AD5680 output |
| `i_tec` | Volts | MAX1968 TEC current monitor | | `i_tec` | Volts | MAX1968 TEC current monitor |
@ -268,6 +270,19 @@ 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).
## PID Tuning ## PID Tuning
The thermostat implements a PID control loop for each of the TEC channels, more details on setting up the PID control loop can be found [here](./doc/PID%20tuning.md). The thermostat implements a PID control loop for each of the TEC channels, more details on setting up the PID control loop can be found [here](./doc/PID%20tuning.md).
## Fan control
Fan control commands are available for thermostat revisions with an integrated fan system:
1. `fan` - show fan stats: `fan_pwm`, `abs_max_tec_i`, `auto_mode`, `k_a`, `k_b`, `k_c`.
2. `fan auto` - enable auto speed controller mode, where fan speed is controlled by the fan curve `fcurve`.
3. `fan <value>` - set the fan power with the value from `1` to `100` and disable auto mode. There is no way to completely disable the fan.
Please note that power doesn't correlate with the actual speed linearly.
4. `fcurve <a> <b> <c>` - set coefficients of the controlling curve `a*x^2 + b*x + c`, where `x` is `abs_max_tec_i/MAX_TEC_I`, a normalized value in range [0,1],
i.e. the (linear) proportion of current output capacity used, on the channel with the largest current flow. The controlling curve is also clamped to [0,1].
5. `fcurve default` - restore fan curve coefficients to defaults: `a = 1.0, b = 0.0, c = 0.0`.

1
cargosha256.nix
View File

@ -1 +0,0 @@
"0qb4s06jwgj3i9df6qq9gwcnyr3jq6dh4l5ygjghq5x1bmcqliix"

48
flake.lock Normal file
View File

@ -0,0 +1,48 @@
{
"nodes": {
"nixpkgs": {
"locked": {
"lastModified": 1722791413,
"narHash": "sha256-rCTrlCWvHzMCNcKxPE3Z/mMK2gDZ+BvvpEVyRM4tKmU=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "8b5b6723aca5a51edf075936439d9cd3947b7b2c",
"type": "github"
},
"original": {
"owner": "NixOS",
"ref": "nixos-24.05",
"repo": "nixpkgs",
"type": "github"
}
},
"root": {
"inputs": {
"nixpkgs": "nixpkgs",
"rust-overlay": "rust-overlay"
}
},
"rust-overlay": {
"inputs": {
"nixpkgs": [
"nixpkgs"
]
},
"locked": {
"lastModified": 1719281921,
"narHash": "sha256-LIBMfhM9pMOlEvBI757GOK5l0R58SRi6YpwfYMbf4yc=",
"owner": "oxalica",
"repo": "rust-overlay",
"rev": "b6032d3a404d8a52ecfc8571ff0c26dfbe221d07",
"type": "github"
},
"original": {
"owner": "oxalica",
"repo": "rust-overlay",
"type": "github"
}
}
},
"root": "root",
"version": 7
}

90
flake.nix Normal file
View File

@ -0,0 +1,90 @@
{
description = "Firmware for the Sinara 8451 Thermostat";
inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.05";
inputs.rust-overlay = {
url = "github:oxalica/rust-overlay";
inputs.nixpkgs.follows = "nixpkgs";
};
outputs =
{
self,
nixpkgs,
rust-overlay,
}:
let
pkgs = import nixpkgs {
system = "x86_64-linux";
overlays = [ (import rust-overlay) ];
};
rust = pkgs.rust-bin.stable."1.66.0".default.override {
extensions = [ "rust-src" ];
targets = [ "thumbv7em-none-eabihf" ];
};
rustPlatform = pkgs.makeRustPlatform {
rustc = rust;
cargo = rust;
};
thermostat = rustPlatform.buildRustPackage {
name = "thermostat";
version = "0.0.0";
src = self;
cargoLock = {
lockFile = ./Cargo.lock;
outputHashes = {
"stm32-eth-0.2.0" = "sha256-48RpZgagUqgVeKm7GXdk3Oo0v19ScF9Uby0nTFlve2o=";
};
};
nativeBuildInputs = [ pkgs.llvm ];
buildPhase = ''
cargo build --release --bin thermostat
'';
installPhase = ''
mkdir -p $out $out/nix-support
cp target/thumbv7em-none-eabihf/release/thermostat $out/thermostat.elf
echo file binary-dist $out/thermostat.elf >> $out/nix-support/hydra-build-products
llvm-objcopy -O binary target/thumbv7em-none-eabihf/release/thermostat $out/thermostat.bin
echo file binary-dist $out/thermostat.bin >> $out/nix-support/hydra-build-products
'';
dontFixup = true;
auditable = false;
};
in
{
packages.x86_64-linux = {
inherit thermostat;
default = thermostat;
};
hydraJobs = {
inherit thermostat;
};
devShells.x86_64-linux.default = pkgs.mkShellNoCC {
name = "thermostat-dev-shell";
packages =
with pkgs;
[
rust
llvm
openocd
dfu-util
rlwrap
]
++ (with python3Packages; [
numpy
matplotlib
]);
};
formatter.x86_64-linux = nixpkgs.legacyPackages.x86_64-linux.nixfmt-rfc-style;
};
}

10
pytec/autotune.py
View File

@ -114,9 +114,9 @@ class PIDAutotune:
# set output # set output
if (self._state == PIDAutotuneState.STATE_RELAY_STEP_UP): if (self._state == PIDAutotuneState.STATE_RELAY_STEP_UP):
self._output = self._initial_output + self._outputstep
elif self._state == PIDAutotuneState.STATE_RELAY_STEP_DOWN:
self._output = self._initial_output - self._outputstep self._output = self._initial_output - self._outputstep
elif self._state == PIDAutotuneState.STATE_RELAY_STEP_DOWN:
self._output = self._initial_output + self._outputstep
# respect output limits # respect output limits
self._output = min(self._output, self._out_max) self._output = min(self._output, self._out_max)
@ -223,7 +223,7 @@ def main():
# Thermostat channel # Thermostat channel
channel = 0 channel = 0
# Target temperature of the autotune routine, celcius # Target temperature of the autotune routine, celcius
target_temperature = 30 target_temperature = 20
# Value by which output will be increased/decreased from zero, amps # Value by which output will be increased/decreased from zero, amps
output_step = 1 output_step = 1
# Reference period for local minima/maxima, seconds # Reference period for local minima/maxima, seconds
@ -253,9 +253,9 @@ def main():
tuner_out = tuner.output() tuner_out = tuner.output()
tec.set_param("pwm", channel, "i_set", tuner_out) tec.set_param("output", channel, "i_set", tuner_out)
tec.set_param("pwm", channel, "i_set", 0) tec.set_param("output", channel, "i_set", 0)
if __name__ == "__main__": if __name__ == "__main__":

8
pytec/example.py
View File

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

137
pytec/pytec/client.py
View File

@ -1,5 +1,7 @@
import socket import socket
import json import json
import logging
import time
class CommandError(Exception): class CommandError(Exception):
pass pass
@ -8,6 +10,18 @@ class Client:
def __init__(self, host="192.168.1.26", port=23, timeout=None): def __init__(self, host="192.168.1.26", port=23, timeout=None):
self._socket = socket.create_connection((host, port), timeout) self._socket = socket.create_connection((host, port), timeout)
self._lines = [""] self._lines = [""]
self._check_zero_limits()
def disconnect(self):
self._socket.shutdown(socket.SHUT_RDWR)
self._socket.close()
def _check_zero_limits(self):
output_report = self.get_output()
for output_channel in output_report:
for limit in ["max_i_neg", "max_i_pos", "max_v"]:
if output_channel[limit] == 0.0:
logging.warning("`{}` limit is set to zero on channel {}".format(limit, output_channel["channel"]))
def _read_line(self): def _read_line(self):
# read more lines # read more lines
@ -37,25 +51,27 @@ class Client:
result[int(item["channel"])] = item result[int(item["channel"])] = item
return result return result
def get_pwm(self): def get_output(self):
"""Retrieve PWM limits for the TEC """Retrieve output limits for the TEC
Example:: Example::
[{'channel': 0, [{'channel': 0,
'center': 'vref', 'center': 'vref',
'i_set': {'max': 2.9802790335151985, 'value': -0.02002179650216762}, 'i_set': -0.02002179650216762,
'max_i_neg': {'max': 3.0, 'value': 3.0}, 'max_i_neg': 2.0,
'max_v': {'max': 5.988, 'value': 5.988}, 'max_v': 3.988,
'max_i_pos': {'max': 3.0, 'value': 3.0}}, 'max_i_pos': 2.0,
'polarity': 'normal',
{'channel': 1, {'channel': 1,
'center': 'vref', 'center': 'vref',
'i_set': {'max': 2.9802790335151985, 'value': -0.02002179650216762}, 'i_set': -0.02002179650216762,
'max_i_neg': {'max': 3.0, 'value': 3.0}, 'max_i_neg': 2.0,
'max_v': {'max': 5.988, 'value': 5.988}, 'max_v': 3.988,
'max_i_pos': {'max': 3.0, 'value': 3.0}} 'max_i_pos': 2.0}
'polarity': 'normal',
] ]
""" """
return self._get_conf("pwm") return self._get_conf("output")
def get_pid(self): def get_pid(self):
"""Retrieve PID control state """Retrieve PID control state
@ -67,33 +83,27 @@ class Client:
'ki': 0.02, 'ki': 0.02,
'kd': 0.0, 'kd': 0.0,
'output_min': 0.0, 'output_min': 0.0,
'output_max': 3.0, 'output_max': 3.0},
'integral_min': -100.0, 'target': 37.0},
'integral_max': 100.0},
'target': 37.0,
'integral': 38.41138597026372},
{'channel': 1, {'channel': 1,
'parameters': { 'parameters': {
'kp': 10.0, 'kp': 10.0,
'ki': 0.02, 'ki': 0.02,
'kd': 0.0, 'kd': 0.0,
'output_min': 0.0, 'output_min': 0.0,
'output_max': 3.0, 'output_max': 3.0},
'integral_min': -100.0, 'target': 36.5}]
'integral_max': 100.0},
'target': 36.5,
'integral': nan}]
""" """
return self._get_conf("pid") return self._get_conf("pid")
def get_steinhart_hart(self): def get_b_parameter(self):
"""Retrieve Steinhart-Hart parameters for resistance to temperature conversion """Retrieve B-Parameter equation 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("s-h") return self._get_conf("b-p")
def get_postfilter(self): def get_postfilter(self):
"""Retrieve DAC postfilter configuration """Retrieve DAC postfilter configuration
@ -104,6 +114,39 @@ class Client:
""" """
return self._get_conf("postfilter") return self._get_conf("postfilter")
def get_report(self):
"""Obtain one-time report on measurement values
Example of yielded data::
{'channel': 0,
'time': 2302524,
'interval': 0.12
'adc': 0.6199188965423515,
'sens': 6138.519310282602,
'temperature': 36.87032392655527,
'pid_engaged': True,
'i_set': 2.0635816680889123,
'dac_value': 2.527790834044456,
'dac_feedback': 2.523,
'i_tec': 2.331,
'tec_i': 2.0925,
'tec_u_meas': 2.5340000000000003,
'pid_output': 2.067581958092247}
"""
return self._get_conf("report")
def get_ipv4(self):
"""Get the IPv4 settings of the Thermostat"""
return self._command("ipv4")
def get_fan(self):
"""Get Thermostat current fan settings"""
return self._command("fan")
def get_hwrev(self):
"""Get Thermostat hardware revision"""
return self._command("hwrev")
def report_mode(self): def report_mode(self):
"""Start reporting measurement values """Start reporting measurement values
@ -123,9 +166,8 @@ class Client:
'tec_u_meas': 2.5340000000000003, 'tec_u_meas': 2.5340000000000003,
'pid_output': 2.067581958092247} 'pid_output': 2.067581958092247}
""" """
self._command("report mode", "on")
while True: while True:
self._socket.sendall("report\n".encode('utf-8'))
line = self._read_line() line = self._read_line()
if not line: if not line:
break break
@ -133,14 +175,15 @@ class Client:
yield json.loads(line) yield json.loads(line)
except json.decoder.JSONDecodeError: except json.decoder.JSONDecodeError:
pass pass
time.sleep(0.05)
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("pwm", 0, "max_v", 2.0) tec.set_param("output", 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("s-h", 0, "t0", 20.0) tec.set_param("b-p", 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)
@ -155,12 +198,40 @@ 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("pwm", channel, "pid") self.set_param("output", channel, "pid")
def save_config(self): def save_config(self, channel=""):
"""Save current configuration to EEPROM""" """Save current configuration to EEPROM"""
self._command("save") self._command("save", channel)
if channel != "":
self._read_line() # read the extra {}
def load_config(self): def load_config(self, channel=""):
"""Load current configuration from EEPROM""" """Load current configuration from EEPROM"""
self._command("load") self._command("load", channel)
if channel != "":
self._read_line() # read the extra {}
def reset(self):
"""Reset the device"""
self._socket.sendall("reset".encode("utf-8"))
self.disconnect() # resetting ends the TCP session, disconnect anyway
def enter_dfu_mode(self):
"""Reset device and enters USB device firmware update (DFU) mode"""
self._socket.sendall("dfu".encode("utf-8"))
self.disconnect() # resetting ends the TCP session, disconnect anyway
def set_ipv4(self, address, netmask, gateway=""):
"""Configure IPv4 address, netmask length, and optional default gateway"""
self._command("ipv4", f"{address}/{netmask}", gateway)
def set_fan(self, power=None):
"""Set fan power with values from 1 to 100. If omitted, set according to fcurve"""
if power is None:
power = "auto"
self._command("fan", power)
def set_fcurve(self, a=1.0, b=0.0, c=0.0):
"""Set fan controller curve coefficients"""
self._command("fcurve", a, b, c)

23
shell.nix
View File

@ -1,23 +0,0 @@
{ mozillaOverlay ? builtins.fetchTarball "https://github.com/mozilla/nixpkgs-mozilla/archive/master.tar.gz",
latestRustNightly ? false,
}:
let
pkgs = import <nixpkgs> {
overlays = [ (import mozillaOverlay) ];
};
rust =
if latestRustNightly
then pkgs.rustChannelOfTargets "nightly" null [ "thumbv7em-none-eabihf" ]
else (pkgs.recurseIntoAttrs (
pkgs.callPackage (import <nix-scripts/stm32/rustPlatform.nix>) {}
)).rust.cargo;
in
pkgs.mkShell {
name = "thermostat-env";
buildInputs = with pkgs; [
rust gcc
openocd dfu-util
] ++ (with python3Packages; [
numpy matplotlib
]);
}

26
src/ad5680.rs
View File

@ -1,12 +1,9 @@
use stm32f4xx_hal::{
hal::{
blocking::spi::Transfer,
digital::v2::OutputPin,
},
time::MegaHertz,
spi,
};
use crate::timer::sleep; use crate::timer::sleep;
use stm32f4xx_hal::{
hal::{blocking::spi::Transfer, digital::v2::OutputPin},
spi,
time::MegaHertz,
};
/// SPI Mode 1 /// SPI Mode 1
pub const SPI_MODE: spi::Mode = spi::Mode { pub const SPI_MODE: spi::Mode = spi::Mode {
@ -27,11 +24,8 @@ pub struct Dac<SPI: Transfer<u8>, S: OutputPin> {
impl<SPI: Transfer<u8>, S: OutputPin> Dac<SPI, S> { 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 { Dac { spi, sync }
spi,
sync,
}
} }
fn write(&mut self, buf: &mut [u8]) -> Result<(), SPI::Error> { fn write(&mut self, buf: &mut [u8]) -> Result<(), SPI::Error> {
@ -47,11 +41,7 @@ impl<SPI: Transfer<u8>, S: OutputPin> Dac<SPI, S> {
pub fn set(&mut self, value: u32) -> Result<u32, SPI::Error> { 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 = [ let mut buf = [(value >> 14) as u8, (value >> 6) as u8, (value << 2) as u8];
(value >> 14) as u8,
(value >> 6) as u8,
(value << 2) as u8,
];
self.write(&mut buf)?; self.write(&mut buf)?;
Ok(value) Ok(value)
} }

121
src/ad7172/adc.rs
View File

@ -1,18 +1,12 @@
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::{ use stm32f4xx_hal::hal::{blocking::spi::Transfer, digital::v2::OutputPin};
blocking::spi::Transfer, use uom::si::{electric_potential::volt, f64::ElectricPotential};
digital::v2::OutputPin,
};
use uom::si::{
f64::ElectricPotential,
electric_potential::volt,
};
use super::{
regs::{self, Register, RegisterData},
checksum::{ChecksumMode, Checksum},
Mode, Input, RefSource, PostFilter, DigitalFilterOrder,
};
/// AD7172-2 implementation /// AD7172-2 implementation
/// ///
@ -27,7 +21,8 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
pub fn new(spi: SPI, mut nss: NSS) -> Result<Self, SPI::Error> { 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, nss, spi,
nss,
checksum_mode: ChecksumMode::Off, checksum_mode: ChecksumMode::Off,
}; };
adc.reset()?; adc.reset()?;
@ -55,8 +50,7 @@ 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) self.read_reg(&regs::Id).map(|id| id.id())
.map(|id| id.id())
} }
pub fn set_checksum_mode(&mut self, mode: ChecksumMode) -> Result<(), SPI::Error> { pub fn set_checksum_mode(&mut self, mode: ChecksumMode) -> Result<(), SPI::Error> {
@ -76,7 +70,10 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
} }
pub fn setup_channel( pub fn setup_channel(
&mut self, index: u8, in_pos: Input, in_neg: Input &mut self,
index: u8,
in_pos: Input,
in_neg: Input,
) -> Result<(), SPI::Error> { ) -> 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);
@ -106,7 +103,11 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
let offset = self.read_reg(&regs::Offset { index })?.offset(); let 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 { offset, gain, bipolar }) Ok(ChannelCalibration {
offset,
gain,
bipolar,
})
} }
pub fn start_continuous_conversion(&mut self) -> Result<(), SPI::Error> { pub fn start_continuous_conversion(&mut self) -> Result<(), SPI::Error> {
@ -119,44 +120,43 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
} }
pub fn get_postfilter(&mut self, index: u8) -> Result<Option<PostFilter>, SPI::Error> { pub fn get_postfilter(&mut self, index: u8) -> Result<Option<PostFilter>, SPI::Error> {
self.read_reg(&regs::FiltCon { index }) self.read_reg(&regs::FiltCon { index }).map(|data| {
.map(|data| { if data.enh_filt_en() {
if data.enh_filt_en() { Some(data.enh_filt())
Some(data.enh_filt()) } else {
} else { None
None }
} })
})
} }
pub fn set_postfilter(&mut self, index: u8, filter: Option<PostFilter>) -> Result<(), SPI::Error> { pub fn set_postfilter(
self.update_reg(&regs::FiltCon { index }, |data| { &mut self,
match filter { index: u8,
None => data.set_enh_filt_en(false), filter: Option<PostFilter>,
Some(filter) => { ) -> Result<(), SPI::Error> {
data.set_enh_filt_en(true); self.update_reg(&regs::FiltCon { index }, |data| match filter {
data.set_enh_filt(filter); None => data.set_enh_filt_en(false),
} Some(filter) => {
data.set_enh_filt_en(true);
data.set_enh_filt(filter);
} }
}) })
} }
/// Returns the channel the data is from /// 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) self.read_reg(&regs::Status).map(|status| {
.map(|status| { if status.ready() {
if status.ready() { Some(status.channel())
Some(status.channel()) } else {
} else { None
None }
} })
})
} }
/// Get data /// 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) self.read_reg(&regs::Data).map(|data| data.data())
.map(|data| data.data())
} }
fn read_reg<R: regs::Register>(&mut self, reg: &R) -> Result<R::Data, SPI::Error> { fn read_reg<R: regs::Register>(&mut self, reg: &R) -> Result<R::Data, SPI::Error> {
@ -175,12 +175,21 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
break; break;
} }
// Retry // Retry
warn!("read_reg {:02X}: checksum error: {:?}!={:?}, retrying", reg.address(), checksum_expected, checksum_in); warn!(
"read_reg {:02X}: checksum error: {:?}!={:?}, retrying",
reg.address(),
checksum_expected,
checksum_in
);
} }
Ok(reg_data) Ok(reg_data)
} }
fn write_reg<R: regs::Register>(&mut self, reg: &R, reg_data: &mut R::Data) -> Result<(), SPI::Error> { fn write_reg<R: regs::Register>(
&mut self,
reg: &R,
reg_data: &mut R::Data,
) -> Result<(), SPI::Error> {
loop { 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 {
@ -190,7 +199,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();
@ -201,7 +210,10 @@ 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!("write_reg {:02X}: readback error, {:?}!={:?}, retrying", address, &*readback_data, &**reg_data); warn!(
"write_reg {:02X}: readback error, {:?}!={:?}, retrying",
address, &*readback_data, &**reg_data
);
} }
} }
@ -225,7 +237,12 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
Ok(()) Ok(())
} }
fn transfer<'w>(&mut self, addr: u8, reg_data: &'w mut [u8], checksum: Option<u8>) -> Result<Option<u8>, SPI::Error> { fn transfer(
&mut self,
addr: u8,
reg_data: &mut [u8],
checksum: Option<u8>,
) -> Result<Option<u8>, SPI::Error> {
let mut addr_buf = [addr]; let mut addr_buf = [addr];
let _ = self.nss.set_low(); let _ = self.nss.set_low();
@ -234,8 +251,7 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
Err(e) => Err(e), 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) {
@ -243,8 +259,7 @@ impl<SPI: Transfer<u8, Error = E>, NSS: OutputPin, E: fmt::Debug> Adc<SPI, NSS>
Err(e) => Err(e), Err(e) => Err(e),
} }
} }
(Err(e), _) => (Err(e), _) => 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,13 +1,10 @@
use core::fmt; use core::fmt;
use num_traits::float::Float; use num_traits::float::Float;
use serde::{Serialize, Deserialize}; use serde::{Deserialize, Serialize};
use stm32f4xx_hal::{ use stm32f4xx_hal::{spi, time::MegaHertz};
time::MegaHertz,
spi,
};
pub mod regs;
mod checksum; mod checksum;
pub mod regs;
pub use checksum::ChecksumMode; pub use checksum::ChecksumMode;
mod adc; mod adc;
pub use adc::*; pub use adc::*;
@ -22,7 +19,6 @@ 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 {
@ -105,7 +101,8 @@ impl fmt::Display for Input {
RefPos => "ref+", RefPos => "ref+",
RefNeg => "ref-", RefNeg => "ref-",
_ => "<INVALID>", _ => "<INVALID>",
}.fmt(fmt) }
.fmt(fmt)
} }
} }
@ -141,7 +138,8 @@ 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 core::ops::{Deref, DerefMut};
use byteorder::{BigEndian, ByteOrder};
use bit_field::BitField; use bit_field::BitField;
use byteorder::{BigEndian, ByteOrder};
use core::ops::{Deref, DerefMut};
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,7 +49,9 @@ 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 index: u8, } pub struct $Reg {
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 {
@ -76,7 +78,7 @@ macro_rules! def_reg {
} }
} }
} }
} };
} }
macro_rules! reg_bit { macro_rules! reg_bit {
@ -146,7 +148,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");
@ -159,9 +161,21 @@ 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!(sing_cyc, set_sing_cyc, 0, 5, "Can only used with single channel"); reg_bit!(
sing_cyc,
set_sing_cyc,
0,
5,
"Can only used with single channel"
);
reg_bit!(hide_delay, set_hide_delay, 0, 6, "Hide delay"); reg_bit!(hide_delay, set_hide_delay, 0, 6, "Hide delay");
reg_bit!(ref_en, set_ref_en, 0, 7, "Enable internal reference, output buffered 2.5 V to REFOUT"); reg_bit!(
ref_en,
set_ref_en,
0,
7,
"Enable internal reference, output buffered 2.5 V to REFOUT"
);
reg_bits!(clockset, set_clocksel, 1, 2..=3, "Clock source"); reg_bits!(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");
} }
@ -174,15 +188,19 @@ 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[0]) << 16) | (u32::from(self.0[1]) << 8) | u32::from(self.0[2])
(u32::from(self.0[1]) << 8) |
u32::from(self.0[2])
} }
} }
def_reg!(GpioCon, gpio_con, 0x06, 2); def_reg!(GpioCon, gpio_con, 0x06, 2);
impl gpio_con::Data { impl gpio_con::Data {
reg_bit!(sync_en, set_sync_en, 0, 3, "Enables the SYNC/ERROR pin as a sync input"); reg_bit!(
sync_en,
set_sync_en,
0,
3,
"Enables the SYNC/ERROR pin as a sync input"
);
} }
def_reg!(Id, id, 0x07, 2); def_reg!(Id, id, 0x07, 2);
@ -200,8 +218,7 @@ 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[0].get_bits(0..=1) << 3) | self.0[1].get_bits(5..=7)).into()
self.0[1].get_bits(5..=7)).into()
} }
/// Set which input is connected to positive input of this channel /// Set which input is connected to positive input of this channel
#[allow(unused)] #[allow(unused)]
@ -210,27 +227,66 @@ 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!(a_in_neg, set_a_in_neg, 1, 0..=4, Input, reg_bits!(
"Which input is connected to negative input of this channel"); a_in_neg,
set_a_in_neg,
1,
0..=4,
Input,
"Which input is connected to negative input of this channel"
);
} }
def_reg!(SetupCon, u8, setup_con, 0x20, 2); def_reg!(SetupCon, u8, setup_con, 0x20, 2);
impl setup_con::Data { impl setup_con::Data {
reg_bit!(bipolar, set_bipolar, 0, 4, "Unipolar (`false`) or bipolar (`true`) coded output"); reg_bit!(
bipolar,
set_bipolar,
0,
4,
"Unipolar (`false`) or bipolar (`true`) coded output"
);
reg_bit!(refbuf_pos, set_refbuf_pos, 0, 3, "Enable REF+ input buffer"); reg_bit!(refbuf_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!(ref_sel, set_ref_sel, 1, 4..=5, RefSource, "Select reference source for conversion"); reg_bits!(
ref_sel,
set_ref_sel,
1,
4..=5,
RefSource,
"Select reference source for conversion"
);
} }
def_reg!(FiltCon, u8, filt_con, 0x28, 2); 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!(enh_filt_en, set_enh_filt_en, 0, 3, "Enable postfilters for enhanced 50Hz and 60Hz rejection"); reg_bit!(
reg_bits!(enh_filt, set_enh_filt, 0, 0..=2, PostFilter, "Select postfilters for enhanced 50Hz and 60Hz rejection"); enh_filt_en,
reg_bits!(order, set_order, 1, 5..=6, DigitalFilterOrder, "order of the digital filter that processes the modulator data"); set_enh_filt_en,
0,
3,
"Enable postfilters for enhanced 50Hz and 60Hz rejection"
);
reg_bits!(
enh_filt,
set_enh_filt,
0,
0..=2,
PostFilter,
"Select postfilters for enhanced 50Hz and 60Hz rejection"
);
reg_bits!(
order,
set_order,
1,
5..=6,
DigitalFilterOrder,
"order of the digital filter that processes the modulator data"
);
reg_bits!(odr, set_odr, 1, 0..=4, "Output data rate"); reg_bits!(odr, set_odr, 1, 0..=4, "Output data rate");
} }
@ -238,9 +294,7 @@ def_reg!(Offset, u8, offset, 0x30, 3);
impl offset::Data { 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[0]) << 16) | (u32::from(self.0[1]) << 8) | u32::from(self.0[2])
(u32::from(self.0[1]) << 8) |
u32::from(self.0[2])
} }
#[allow(unused)] #[allow(unused)]
pub fn set_offset(&mut self, value: u32) { pub fn set_offset(&mut self, value: u32) {
@ -254,9 +308,7 @@ 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[0]) << 16) | (u32::from(self.0[1]) << 8) | u32::from(self.0[2])
(u32::from(self.0[1]) << 8) |
u32::from(self.0[2])
} }
#[allow(unused)] #[allow(unused)]
pub fn set_gain(&mut self, value: u32) { pub fn set_gain(&mut self, value: u32) {

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

@ -1,31 +1,29 @@
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};
/// Steinhart-Hart equation parameters /// B-Parameter 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,
/// Base resistance /// Thermistor resistance at base temperature
pub r0: ElectricalResistance, pub r0: ElectricalResistance,
/// Beta /// Beta (average slope of the function ln R vs. 1/T)
pub b: f64, pub b: TemperatureInterval,
} }
impl Parameters { impl Parameters {
/// Perform the voltage to temperature conversion. /// Perform the resistance to temperature conversion.
pub fn get_temperature(&self, r: ElectricalResistance) -> ThermodynamicTemperature { pub fn get_temperature(&self, r: ElectricalResistance) -> ThermodynamicTemperature {
let inv_temp = 1.0 / self.t0.get::<kelvin>() + (r / self.r0).get::<ratio>().ln() / self.b; let temp = (self.t0.recip() + (r / self.r0).get::<ratio>().ln() / self.b).recip();
ThermodynamicTemperature::new::<kelvin>(1.0 / inv_temp) ThermodynamicTemperature::new::<kelvin>(temp.get::<kelvin_interval>())
} }
} }
@ -34,7 +32,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: 3800.0, b: TemperatureInterval::new::<kelvin_interval>(3800.0),
} }
} }
} }

17
src/channel.rs
View File

@ -1,14 +1,10 @@
use stm32f4xx_hal::hal::digital::v2::OutputPin;
use uom::si::{
f64::ElectricPotential,
electric_potential::volt,
};
use crate::{ use crate::{
ad5680, ad5680, ad7172,
ad7172,
channel_state::ChannelState, channel_state::ChannelState,
pins::{ChannelPins, ChannelPinSet}, pins::{ChannelPinSet, ChannelPins},
}; };
use stm32f4xx_hal::hal::digital::v2::OutputPin;
use uom::si::{electric_potential::volt, f64::ElectricPotential};
/// Marker type for the first channel /// Marker type for the first channel
pub struct Channel0; pub struct Channel0;
@ -24,7 +20,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,
@ -40,7 +36,8 @@ impl<C: ChannelPins> Channel<C> {
Channel { Channel {
state, state,
dac, vref_meas, dac,
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,

53
src/channel_state.rs
View File

@ -1,23 +1,21 @@
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::{
f64::{ electric_current::ampere,
ElectricPotential,
ElectricalResistance,
ElectricCurrent,
ThermodynamicTemperature,
Time,
},
electric_potential::volt, electric_potential::volt,
electrical_resistance::ohm, electrical_resistance::ohm,
f64::{
ElectricCurrent, ElectricPotential, ElectricalResistance, ThermodynamicTemperature, Time,
},
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;
@ -27,14 +25,15 @@ pub struct ChannelState {
pub adc_calibration: ad7172::ChannelCalibration, pub adc_calibration: ad7172::ChannelCalibration,
pub adc_time: Instant, pub adc_time: Instant,
pub adc_interval: Duration, pub adc_interval: Duration,
/// VREF for the TEC (1.5V)
pub vref: ElectricPotential,
/// i_set 0A center point /// i_set 0A center point
pub center: CenterPoint, pub center: CenterPoint,
pub dac_value: ElectricPotential, pub dac_value: ElectricPotential,
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 sh: sh::Parameters, pub bp: bp::Parameters,
pub polarity: Polarity,
} }
impl ChannelState { impl ChannelState {
@ -45,13 +44,18 @@ 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),
// updated later with Channels.read_vref() center: CenterPoint::VRef,
vref: ElectricPotential::new::<volt>(1.5),
center: CenterPoint::Vref,
dac_value: ElectricPotential::new::<volt>(0.0), dac_value: ElectricPotential::new::<volt>(0.0),
i_set: ElectricCurrent::new::<ampere>(0.0),
pwm_limits: PwmLimits {
max_v: ElectricPotential::zero(),
max_i_pos: ElectricCurrent::zero(),
max_i_neg: ElectricCurrent::zero(),
},
pid_engaged: false, pid_engaged: false,
pid: pid::Controller::new(pid::Parameters::default()), pid: pid::Controller::new(pid::Parameters::default()),
sh: sh::Parameters::default(), bp: bp::Parameters::default(),
polarity: Polarity::Normal,
} }
} }
@ -67,10 +71,9 @@ 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, current: ElectricCurrent) -> Option<f64> { pub fn update_pid(&mut self) -> Option<f64> {
let temperature = self.get_temperature()? let temperature = self.get_temperature()?.get::<degree_celsius>();
.get::<degree_celsius>(); let pid_output = self.pid.update(temperature);
let pid_output = self.pid.update(temperature, self.get_adc_interval(), current);
Some(pid_output) Some(pid_output)
} }
@ -97,7 +100,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.sh.get_temperature(r); let temperature = self.bp.get_temperature(r);
Some(temperature) Some(temperature)
} }
} }

572
src/channels.rs
View File

@ -1,30 +1,59 @@
use heapless::{consts::{U2, U1024}, Vec}; use crate::timer::sleep;
use crate::{
ad5680, ad7172, b_parameter,
channel::{Channel, Channel0, Channel1},
channel_state::ChannelState,
command_handler::JsonBuffer,
command_parser::{CenterPoint, Polarity, PwmPin},
pins::{self, Channel0VRef, Channel1VRef},
};
use core::marker::PhantomData;
use heapless::{consts::U2, Vec};
use num_traits::Zero;
use serde::{Serialize, Serializer}; use 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::{
f64::{ElectricCurrent, ElectricPotential, ElectricalResistance, Time},
electric_potential::{millivolt, volt},
electric_current::ampere, electric_current::ampere,
electric_potential::{millivolt, volt},
electrical_resistance::ohm, electrical_resistance::ohm,
f64::{ElectricCurrent, ElectricPotential, ElectricalResistance, Time},
ratio::ratio, ratio::ratio,
thermodynamic_temperature::degree_celsius, thermodynamic_temperature::degree_celsius,
}; };
use crate::{
ad5680, pub enum PinsAdcReadTarget {
ad7172, VRef,
channel::{Channel, Channel0, Channel1}, DacVfb,
channel_state::ChannelState, ITec,
command_parser::{CenterPoint, PwmPin}, VTec,
pins, }
steinhart_hart,
};
pub const CHANNELS: usize = 2; pub const CHANNELS: usize = 2;
pub const R_SENSE: f64 = 0.05; pub const R_SENSE: f64 = 0.05;
// DAC chip outputs 0-5v, which is then passed through a resistor dividor to provide 0-3v range
const DAC_OUT_V_MAX: f64 = 3.0;
// From design specs
pub const MAX_TEC_I: ElectricCurrent = ElectricCurrent {
dimension: PhantomData,
units: PhantomData,
value: 2.0,
};
pub const MAX_TEC_V: ElectricPotential = ElectricPotential {
dimension: PhantomData,
units: PhantomData,
value: 4.0,
};
const MAX_TEC_I_DUTY_TO_CURRENT_RATE: ElectricCurrent = ElectricCurrent {
dimension: PhantomData,
units: PhantomData,
value: 1.0 / (10.0 * R_SENSE / 3.3),
};
// DAC chip outputs 0-5v, which is then passed through a resistor dividor to provide 0-3v range
const DAC_OUT_V_MAX: ElectricPotential = ElectricPotential {
dimension: PhantomData,
units: PhantomData,
value: 3.0,
};
// TODO: -pub // TODO: -pub
pub struct Channels { pub struct Channels {
channel0: Channel<Channel0>, channel0: Channel<Channel0>,
@ -42,21 +71,26 @@ impl Channels {
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).unwrap(); adc.setup_channel(0, ad7172::Input::Ain2, ad7172::Input::Ain3)
let adc_calibration0 = adc.get_calibration(0) .unwrap();
.expect("adc_calibration0"); let adc_calibration0 = adc.get_calibration(0).expect("adc_calibration0");
adc.setup_channel(1, ad7172::Input::Ain0, ad7172::Input::Ain1).unwrap(); adc.setup_channel(1, ad7172::Input::Ain0, ad7172::Input::Ain1)
let adc_calibration1 = adc.get_calibration(1) .unwrap();
.expect("adc_calibration1"); let adc_calibration1 = adc.get_calibration(1).expect("adc_calibration1");
adc.start_continuous_conversion().unwrap(); 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 { channel0, channel1, adc, pins_adc, pwm }; let mut channels = Channels {
channel0,
channel1,
adc,
pins_adc,
pwm,
};
for channel in 0..CHANNELS { for channel in 0..CHANNELS {
channels.channel_state(channel).vref = channels.read_vref(channel);
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));
} }
@ -75,10 +109,9 @@ impl Channels {
pub fn poll_adc(&mut self, instant: Instant) -> Option<u8> { pub fn poll_adc(&mut self, instant: Instant) -> Option<u8> {
self.adc.data_ready().unwrap().map(|channel| { self.adc.data_ready().unwrap().map(|channel| {
let data = self.adc.read_data().unwrap(); let data = self.adc.read_data().unwrap();
let current = self.get_tec_i(channel.into());
let state = self.channel_state(channel); let state = self.channel_state(channel);
state.update(instant, data); state.update(instant, data);
match state.update_pid(current) { match state.update_pid() {
Some(pid_output) if state.pid_engaged => { Some(pid_output) if state.pid_engaged => {
// Forward PID output to i_set DAC // Forward PID output to i_set DAC
self.set_i(channel.into(), ElectricCurrent::new::<ampere>(pid_output)); self.set_i(channel.into(), ElectricCurrent::new::<ampere>(pid_output));
@ -97,13 +130,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 => { CenterPoint::VRef => self.adc_read(channel, PinsAdcReadTarget::VRef, 8),
let vref = self.read_vref(channel); CenterPoint::Override(center_point) => {
self.channel_state(channel).vref = vref; ElectricPotential::new::<volt>(center_point.into())
vref }
},
CenterPoint::Override(center_point) =>
ElectricPotential::new::<volt>(center_point.into()),
} }
} }
@ -113,17 +143,14 @@ impl Channels {
voltage voltage
} }
pub fn get_i(&mut self, channel: usize) -> ElectricCurrent { pub fn get_i_set(&mut self, channel: usize) -> ElectricCurrent {
let center_point = self.get_center(channel); let i_set = self.channel_state(channel).i_set;
let r_sense = ElectricalResistance::new::<ohm>(R_SENSE); i_set
let voltage = self.get_dac(channel);
let i_tec = (voltage - center_point) / (10.0 * r_sense);
i_tec
} }
/// 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 / ElectricPotential::new::<volt>(DAC_OUT_V_MAX)).get::<ratio>() * (ad5680::MAX_VALUE as f64)) as u32 ; let value = ((voltage / 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(),
@ -133,114 +160,123 @@ impl Channels {
voltage voltage
} }
pub fn set_i(&mut self, channel: usize, i_tec: ElectricCurrent) -> ElectricCurrent { pub fn set_i(&mut self, channel: usize, i_set: ElectricCurrent) -> ElectricCurrent {
let vref_meas = match channel.into() { let i_set = i_set.min(MAX_TEC_I).max(-MAX_TEC_I);
self.channel_state(channel).i_set = i_set;
let negate = match self.channel_state(channel).polarity {
Polarity::Normal => 1.0,
Polarity::Reversed => -1.0,
};
let vref_meas = match channel {
0 => self.channel0.vref_meas, 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 = i_tec * 10.0 * r_sense + center_point; let voltage = negate * i_set * 10.0 * r_sense + center_point;
let voltage = self.set_dac(channel, voltage); let voltage = self.set_dac(channel, voltage);
let i_tec = (voltage - center_point) / (10.0 * r_sense);
i_tec negate * (voltage - center_point) / (10.0 * r_sense)
} }
pub fn read_dac_feedback(&mut self, channel: usize) -> ElectricPotential { /// AN4073: ADC Reading Dispersion can be reduced through Averaging
pub fn adc_read(
&mut self,
channel: usize,
adc_read_target: PinsAdcReadTarget,
avg_pt: u16,
) -> ElectricPotential {
let mut sample: u32 = 0;
match channel { match channel {
0 => { 0 => {
let sample = self.pins_adc.convert( sample = match adc_read_target {
&self.channel0.dac_feedback_pin, PinsAdcReadTarget::VRef => match &self.channel0.vref_pin {
stm32f4xx_hal::adc::config::SampleTime::Cycles_480 Channel0VRef::Analog(vref_pin) => {
); for _ in (0..avg_pt).rev() {
let mv = self.pins_adc.sample_to_millivolts(sample); sample += self.pins_adc.convert(
vref_pin,
stm32f4xx_hal::adc::config::SampleTime::Cycles_480,
) as u32;
}
sample / avg_pt as u32
}
Channel0VRef::Disabled(_) => 2048_u32,
},
PinsAdcReadTarget::DacVfb => {
for _ in (0..avg_pt).rev() {
sample += self.pins_adc.convert(
&self.channel0.dac_feedback_pin,
stm32f4xx_hal::adc::config::SampleTime::Cycles_480,
) as u32;
}
sample / avg_pt as u32
}
PinsAdcReadTarget::ITec => {
for _ in (0..avg_pt).rev() {
sample += self.pins_adc.convert(
&self.channel0.itec_pin,
stm32f4xx_hal::adc::config::SampleTime::Cycles_480,
) as u32;
}
sample / avg_pt as u32
}
PinsAdcReadTarget::VTec => {
for _ in (0..avg_pt).rev() {
sample += self.pins_adc.convert(
&self.channel0.tec_u_meas_pin,
stm32f4xx_hal::adc::config::SampleTime::Cycles_480,
) as u32;
}
sample / avg_pt as u32
}
};
let mv = self.pins_adc.sample_to_millivolts(sample as u16);
ElectricPotential::new::<millivolt>(mv as f64) ElectricPotential::new::<millivolt>(mv as f64)
} }
1 => { 1 => {
let sample = self.pins_adc.convert( sample = match adc_read_target {
&self.channel1.dac_feedback_pin, PinsAdcReadTarget::VRef => match &self.channel1.vref_pin {
stm32f4xx_hal::adc::config::SampleTime::Cycles_480 Channel1VRef::Analog(vref_pin) => {
); for _ in (0..avg_pt).rev() {
let mv = self.pins_adc.sample_to_millivolts(sample); sample += self.pins_adc.convert(
ElectricPotential::new::<millivolt>(mv as f64) vref_pin,
} stm32f4xx_hal::adc::config::SampleTime::Cycles_480,
_ => unreachable!(), ) as u32;
} }
} sample / avg_pt as u32
}
pub fn read_dac_feedback_until_stable(&mut self, channel: usize, tolerance: ElectricPotential) -> ElectricPotential { Channel1VRef::Disabled(_) => 2048_u32,
let mut prev = self.read_dac_feedback(channel); },
loop { PinsAdcReadTarget::DacVfb => {
let current = self.read_dac_feedback(channel); for _ in (0..avg_pt).rev() {
if (current - prev).abs() < tolerance { sample += self.pins_adc.convert(
return current; &self.channel1.dac_feedback_pin,
} stm32f4xx_hal::adc::config::SampleTime::Cycles_480,
prev = current; ) as u32;
} }
} sample / avg_pt as u32
}
pub fn read_itec(&mut self, channel: usize) -> ElectricPotential { PinsAdcReadTarget::ITec => {
match channel { for _ in (0..avg_pt).rev() {
0 => { sample += self.pins_adc.convert(
let sample = self.pins_adc.convert( &self.channel1.itec_pin,
&self.channel0.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) }
} PinsAdcReadTarget::VTec => {
1 => { for _ in (0..avg_pt).rev() {
let sample = self.pins_adc.convert( sample += self.pins_adc.convert(
&self.channel1.itec_pin, &self.channel1.tec_u_meas_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); }
ElectricPotential::new::<millivolt>(mv as f64) sample / avg_pt as u32
} }
_ => 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!(),
@ -251,30 +287,29 @@ impl Channels {
/// ///
/// The thermostat DAC applies a control voltage signal to the CTLI pin of MAX driver chip to control its output current. /// The thermostat DAC applies a control voltage signal to the CTLI pin of MAX driver chip to control its output current.
/// The CTLI input signal is centered around VREF of the MAX chip. Applying VREF to CTLI sets the output current to 0. /// The CTLI input signal is centered around VREF of the MAX chip. Applying VREF to CTLI sets the output current to 0.
/// ///
/// This calibration routine measures the VREF voltage and the DAC output with the STM32 ADC, and uses a breadth-first /// This calibration routine measures the VREF voltage and the DAC output with the STM32 ADC, and uses a breadth-first
/// search to find the DAC setting that will produce a DAC output voltage closest to VREF. This DAC output voltage will /// search to find the DAC setting that will produce a DAC output voltage closest to VREF. This DAC output voltage will
/// be stored and used in subsequent i_set routines to bias the current control signal to the measured VREF, reducing /// be stored and used in subsequent i_set routines to bias the current control signal to the measured VREF, reducing
/// the offset error of the current control signal. /// the offset error of the current control signal.
/// ///
/// The input offset of the STM32 ADC is eliminated by using the same ADC for the measurements, and by only using the /// The input offset of the STM32 ADC is eliminated by using the same ADC for the measurements, and by only using the
/// difference in VREF and DAC output for the calibration. /// difference in VREF and DAC output for the calibration.
/// ///
/// This routine should be called only once after boot, repeated reading of the vref signal and changing of the stored /// This routine should be called only once after boot, repeated reading of the vref signal and changing of the stored
/// VREF measurement can introduce significant noise at the current output, degrading the stabilily performance of the /// VREF measurement can introduce significant noise at the current output, degrading the stabilily performance of the
/// thermostat. /// thermostat.
pub fn calibrate_dac_value(&mut self, channel: usize) { pub fn calibrate_dac_value(&mut self, channel: usize) {
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 = target_voltage + self.get_center(channel); target_voltage += self.get_center(channel);
} }
target_voltage = target_voltage / samples as f64; 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 (0..18).rev() { for step in (5..18).rev() {
let mut prev_value = start_value;
for value in (start_value..=ad5680::MAX_VALUE).step_by(1 << step) { for value in (start_value..=ad5680::MAX_VALUE).step_by(1 << step) {
match channel { match channel {
0 => { 0 => {
@ -285,24 +320,23 @@ impl Channels {
} }
_ => unreachable!(), _ => unreachable!(),
} }
sleep(10);
let dac_feedback = self.read_dac_feedback_until_stable(channel, ElectricPotential::new::<volt>(0.001)); let dac_feedback = self.adc_read(channel, PinsAdcReadTarget::DacVfb, 64);
let error = target_voltage - dac_feedback; 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 = prev_value; start_value = value;
let vref = (value as f64 / ad5680::MAX_VALUE as f64) * ElectricPotential::new::<volt>(DAC_OUT_V_MAX); let vref = (value as f64 / ad5680::MAX_VALUE as f64) * 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;
} }
} }
@ -328,131 +362,132 @@ 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 {
let max = 4.0 * ElectricPotential::new::<volt>(3.3); self.channel_state(channel).pwm_limits.max_v
let duty = self.get_pwm(channel, PwmPin::MaxV);
duty * max
} }
pub fn get_max_i_pos(&mut self, channel: usize) -> (ElectricCurrent, ElectricCurrent) { pub fn get_max_i_pos(&mut self, channel: usize) -> ElectricCurrent {
let max = ElectricCurrent::new::<ampere>(3.0); self.channel_state(channel).pwm_limits.max_i_pos
let duty = self.get_pwm(channel, PwmPin::MaxIPos);
(duty * max, max)
} }
pub fn get_max_i_neg(&mut self, channel: usize) -> (ElectricCurrent, ElectricCurrent) { pub fn get_max_i_neg(&mut self, channel: usize) -> ElectricCurrent {
let max = ElectricCurrent::new::<ampere>(3.0); self.channel_state(channel).pwm_limits.max_i_neg
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 {
(self.read_itec(channel) - self.read_vref(channel)) / ElectricalResistance::new::<ohm>(0.4) let tec_i = (self.adc_read(channel, PinsAdcReadTarget::ITec, 16)
- 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.read_tec_u_meas(channel) - ElectricPotential::new::<volt>(1.5)) * 4.0 (self.adc_read(channel, PinsAdcReadTarget::VTec, 16) - ElectricPotential::new::<volt>(1.5))
* 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) => (_, PwmPin::ISet) => panic!("i_set is no pwm pin"),
panic!("i_set is no pwm pin"), (0, PwmPin::MaxIPos) => set(&mut self.pwm.max_i_pos0, duty),
(0, PwmPin::MaxIPos) => (0, PwmPin::MaxINeg) => set(&mut self.pwm.max_i_neg0, duty),
set(&mut self.pwm.max_i_pos0, duty), (0, PwmPin::MaxV) => set(&mut self.pwm.max_v0, duty),
(0, PwmPin::MaxINeg) => (1, PwmPin::MaxIPos) => set(&mut self.pwm.max_i_pos1, duty),
set(&mut self.pwm.max_i_neg0, duty), (1, PwmPin::MaxINeg) => set(&mut self.pwm.max_i_neg1, duty),
(0, PwmPin::MaxV) => (1, PwmPin::MaxV) => set(&mut self.pwm.max_v1, duty),
set(&mut self.pwm.max_v0, duty), _ => unreachable!(),
(1, PwmPin::MaxIPos) =>
set(&mut self.pwm.max_i_pos1, duty),
(1, PwmPin::MaxINeg) =>
set(&mut self.pwm.max_i_neg1, duty),
(1, PwmPin::MaxV) =>
set(&mut self.pwm.max_v1, duty),
_ =>
unreachable!(),
} }
} }
pub fn set_max_v(&mut self, channel: usize, max_v: ElectricPotential) -> (ElectricPotential, ElectricPotential) { pub fn set_max_v(
&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(&mut self, channel: usize, max_i_pos: ElectricCurrent) -> (ElectricCurrent, ElectricCurrent) { pub fn set_max_i_pos(
&mut self,
channel: usize,
max_i_pos: ElectricCurrent,
) -> (ElectricCurrent, ElectricCurrent) {
let max = ElectricCurrent::new::<ampere>(3.0); let max = ElectricCurrent::new::<ampere>(3.0);
let duty = (max_i_pos / max).get::<ratio>(); let max_i_pos = max_i_pos.min(MAX_TEC_I).max(ElectricCurrent::zero());
let duty = self.set_pwm(channel, PwmPin::MaxIPos, duty); let duty = (max_i_pos / MAX_TEC_I_DUTY_TO_CURRENT_RATE).get::<ratio>();
(duty * max, max) let duty = match self.channel_state(channel).polarity {
Polarity::Normal => self.set_pwm(channel, PwmPin::MaxIPos, duty),
Polarity::Reversed => self.set_pwm(channel, PwmPin::MaxINeg, duty),
};
self.channel_state(channel).pwm_limits.max_i_pos = max_i_pos;
(duty * MAX_TEC_I_DUTY_TO_CURRENT_RATE, max)
} }
pub fn set_max_i_neg(&mut self, channel: usize, max_i_neg: ElectricCurrent) -> (ElectricCurrent, ElectricCurrent) { pub fn set_max_i_neg(
&mut self,
channel: usize,
max_i_neg: ElectricCurrent,
) -> (ElectricCurrent, ElectricCurrent) {
let max = ElectricCurrent::new::<ampere>(3.0); let max = ElectricCurrent::new::<ampere>(3.0);
let duty = (max_i_neg / max).get::<ratio>(); let max_i_neg = max_i_neg.min(MAX_TEC_I).max(ElectricCurrent::zero());
let duty = self.set_pwm(channel, PwmPin::MaxINeg, duty); let duty = (max_i_neg / MAX_TEC_I_DUTY_TO_CURRENT_RATE).get::<ratio>();
(duty * max, max) let duty = match self.channel_state(channel).polarity {
Polarity::Normal => self.set_pwm(channel, PwmPin::MaxINeg, duty),
Polarity::Reversed => self.set_pwm(channel, PwmPin::MaxIPos, duty),
};
self.channel_state(channel).pwm_limits.max_i_neg = max_i_neg;
(duty * MAX_TEC_I_DUTY_TO_CURRENT_RATE, max)
}
pub fn 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 vref = self.channel_state(channel).vref; 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 = self.read_itec(channel);
let tec_i = self.get_tec_i(channel); let tec_i = self.get_tec_i(channel);
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 = state.pid.last_output.map(|last_output| let pid_output = ElectricCurrent::new::<ampere>(state.pid.y1);
ElectricCurrent::new::<ampere>(last_output)
);
Report { Report {
channel, channel,
time: state.get_adc_time(), time: state.get_adc_time(),
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.get_temperature() temperature: state
.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,
vref,
dac_value, dac_value,
dac_feedback: self.read_dac_feedback(channel), dac_feedback: self.adc_read(channel, PinsAdcReadTarget::DacVfb, 1),
i_tec, i_tec,
tec_i, tec_i,
tec_u_meas: self.get_tec_v(channel), tec_u_meas: self.get_tec_v(channel),
@ -476,27 +511,40 @@ impl Channels {
serde_json_core::to_vec(&summaries) serde_json_core::to_vec(&summaries)
} }
fn pwm_summary(&mut self, channel: usize) -> PwmSummary { pub fn pid_engaged(&mut self) -> bool {
PwmSummary { for channel in 0..CHANNELS {
if self.channel_state(channel).pid_engaged {
return true;
}
}
false
}
fn output_summary(&mut self, channel: usize) -> OutputSummary {
OutputSummary {
channel, channel,
center: CenterPointJson(self.channel_state(channel).center.clone()), center: CenterPointJson(self.channel_state(channel).center.clone()),
i_set: (self.get_i(channel), ElectricCurrent::new::<ampere>(3.0)).into(), i_set: self.get_i_set(channel),
max_v: (self.get_max_v(channel), ElectricPotential::new::<volt>(5.0)).into(), max_v: self.get_max_v(channel),
max_i_pos: self.get_max_i_pos(channel).into(), max_i_pos: self.get_max_i_pos(channel),
max_i_neg: self.get_max_i_neg(channel).into(), max_i_neg: self.get_max_i_neg(channel),
polarity: PolarityJson(self.channel_state(channel).polarity.clone()),
} }
} }
pub fn pwm_summaries_json(&mut self) -> Result<JsonBuffer, serde_json_core::ser::Error> { pub fn output_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.pwm_summary(channel)); let _ = summaries.push(self.output_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.adc.get_postfilter(channel as u8).unwrap() let rate = self
.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 }
} }
@ -509,21 +557,28 @@ impl Channels {
serde_json_core::to_vec(&summaries) serde_json_core::to_vec(&summaries)
} }
fn steinhart_hart_summary(&mut self, channel: usize) -> SteinhartHartSummary { fn b_parameter_summary(&mut self, channel: usize) -> BParameterSummary {
let params = self.channel_state(channel).sh.clone(); let params = self.channel_state(channel).bp.clone();
SteinhartHartSummary { channel, params } BParameterSummary { channel, params }
} }
pub fn steinhart_hart_summaries_json(&mut self) -> Result<JsonBuffer, serde_json_core::ser::Error> { pub fn b_parameter_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.steinhart_hart_summary(channel)); let _ = summaries.push(self.b_parameter_summary(channel));
} }
serde_json_core::to_vec(&summaries) serde_json_core::to_vec(&summaries)
} }
}
type JsonBuffer = Vec<u8, U1024>; pub fn current_abs_max_tec_i(&mut self) -> ElectricCurrent {
(0..CHANNELS)
.map(|channel| self.get_tec_i(channel).abs())
.max_by(|a, b| a.partial_cmp(b).unwrap_or(core::cmp::Ordering::Equal))
.unwrap()
}
}
#[derive(Serialize)] #[derive(Serialize)]
pub struct Report { pub struct Report {
@ -535,13 +590,12 @@ pub struct Report {
temperature: Option<f64>, temperature: Option<f64>,
pid_engaged: bool, pid_engaged: bool,
i_set: ElectricCurrent, i_set: ElectricCurrent,
vref: ElectricPotential,
dac_value: ElectricPotential, dac_value: ElectricPotential,
dac_feedback: ElectricPotential, dac_feedback: ElectricPotential,
i_tec: ElectricPotential, i_tec: ElectricPotential,
tec_i: ElectricCurrent, tec_i: ElectricCurrent,
tec_u_meas: ElectricPotential, tec_u_meas: ElectricPotential,
pid_output: Option<ElectricCurrent>, pid_output: ElectricCurrent,
} }
pub struct CenterPointJson(CenterPoint); pub struct CenterPointJson(CenterPoint);
@ -553,34 +607,36 @@ impl Serialize for CenterPointJson {
S: Serializer, S: Serializer,
{ {
match self.0 { match self.0 {
CenterPoint::Vref => CenterPoint::VRef => serializer.serialize_str("vref"),
serializer.serialize_str("vref"), CenterPoint::Override(vref) => serializer.serialize_f32(vref),
CenterPoint::Override(vref) =>
serializer.serialize_f32(vref),
} }
} }
} }
#[derive(Serialize)] pub struct PolarityJson(Polarity);
pub struct PwmSummaryField<T: Serialize> {
value: T,
max: T,
}
impl<T: Serialize> From<(T, T)> for PwmSummaryField<T> { // used in JSON encoding, not for config
fn from((value, max): (T, T)) -> Self { impl Serialize for PolarityJson {
PwmSummaryField { value, max } fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_str(match self.0 {
Polarity::Normal => "normal",
Polarity::Reversed => "reversed",
})
} }
} }
#[derive(Serialize)] #[derive(Serialize)]
pub struct PwmSummary { pub struct OutputSummary {
channel: usize, channel: usize,
center: CenterPointJson, center: CenterPointJson,
i_set: PwmSummaryField<ElectricCurrent>, i_set: ElectricCurrent,
max_v: PwmSummaryField<ElectricPotential>, max_v: ElectricPotential,
max_i_pos: PwmSummaryField<ElectricCurrent>, max_i_pos: ElectricCurrent,
max_i_neg: PwmSummaryField<ElectricCurrent>, max_i_neg: ElectricCurrent,
polarity: PolarityJson,
} }
#[derive(Serialize)] #[derive(Serialize)]
@ -590,7 +646,7 @@ pub struct PostFilterSummary {
} }
#[derive(Serialize)] #[derive(Serialize)]
pub struct SteinhartHartSummary { pub struct BParameterSummary {
channel: usize, channel: usize,
params: steinhart_hart::Parameters, params: b_parameter::Parameters,
} }

528
src/command_handler.rs Normal file
View File

@ -0,0 +1,528 @@
use super::{
ad7172,
channels::{Channels, CHANNELS},
command_parser::{
BpParameter, CenterPoint, Command, Ipv4Config, PidParameter, Polarity, PwmPin, ShowCommand,
},
config::ChannelConfig,
dfu,
flash_store::FlashStore,
hw_rev::HWRev,
net, FanCtrl, CHANNEL_CONFIG_KEY,
};
use core::fmt::Write;
use heapless::{consts::U1024, Vec};
use log::{error, warn};
use smoltcp::socket::TcpSocket;
use uom::si::{
electric_current::ampere,
electric_potential::volt,
electrical_resistance::ohm,
f64::{
ElectricCurrent, ElectricPotential, ElectricalResistance, TemperatureInterval,
ThermodynamicTemperature,
},
temperature_interval::kelvin,
thermodynamic_temperature::degree_celsius,
};
#[derive(Debug, Clone, PartialEq)]
pub enum Handler {
Handled,
CloseSocket,
NewIPV4(Ipv4Config),
Reset,
}
#[derive(Clone, Debug, PartialEq)]
pub enum Error {
Report,
PostFilterRate,
Flash,
}
pub type JsonBuffer = Vec<u8, U1024>;
fn send_line(socket: &mut TcpSocket, data: &[u8]) -> bool {
let send_free = socket.send_capacity() - socket.send_queue();
if data.len() > send_free + 1 {
// Not enough buffer space, skip report for now,
// instead of sending incomplete line
warn!(
"TCP socket has only {}/{} needed {}",
send_free + 1,
socket.send_capacity(),
data.len(),
);
} else {
match socket.send_slice(data) {
Ok(sent) if sent == data.len() => {
let _ = socket.send_slice(b"\n");
// success
return true;
}
Ok(sent) => warn!("sent only {}/{} bytes", sent, data.len()),
Err(e) => error!("error sending line: {:?}", e),
}
}
// not success
false
}
impl Handler {
fn show_report(socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> {
match channels.reports_json() {
Ok(buf) => {
send_line(socket, &buf[..]);
}
Err(e) => {
error!("unable to serialize report: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
return Err(Error::Report);
}
}
Ok(Handler::Handled)
}
fn show_pid(socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> {
match channels.pid_summaries_json() {
Ok(buf) => {
send_line(socket, &buf);
}
Err(e) => {
error!("unable to serialize pid summary: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
return Err(Error::Report);
}
}
Ok(Handler::Handled)
}
fn show_pwm(socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> {
match channels.output_summaries_json() {
Ok(buf) => {
send_line(socket, &buf);
}
Err(e) => {
error!("unable to serialize pwm summary: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
return Err(Error::Report);
}
}
Ok(Handler::Handled)
}
fn show_b_parameter(socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> {
match channels.b_parameter_summaries_json() {
Ok(buf) => {
send_line(socket, &buf);
}
Err(e) => {
error!("unable to serialize b parameter summaries: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
return Err(Error::Report);
}
}
Ok(Handler::Handled)
}
fn show_post_filter(socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> {
match channels.postfilter_summaries_json() {
Ok(buf) => {
send_line(socket, &buf);
}
Err(e) => {
error!("unable to serialize postfilter summary: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
return Err(Error::Report);
}
}
Ok(Handler::Handled)
}
fn show_ipv4(socket: &mut TcpSocket, ipv4_config: &mut Ipv4Config) -> Result<Handler, Error> {
let (cidr, gateway) = net::split_ipv4_config(ipv4_config.clone());
let _ = write!(socket, "{{\"addr\":\"{}\"", cidr);
gateway.map(|gateway| write!(socket, ",\"gateway\":\"{}\"", gateway));
let _ = writeln!(socket, "}}");
Ok(Handler::Handled)
}
fn engage_pid(
socket: &mut TcpSocket,
channels: &mut Channels,
channel: usize,
) -> Result<Handler, Error> {
channels.channel_state(channel).pid_engaged = true;
send_line(socket, b"{}");
Ok(Handler::Handled)
}
fn set_polarity(
socket: &mut TcpSocket,
channels: &mut Channels,
channel: usize,
polarity: Polarity,
) -> Result<Handler, Error> {
channels.set_polarity(channel, polarity);
send_line(socket, b"{}");
Ok(Handler::Handled)
}
fn set_pwm(
socket: &mut TcpSocket,
channels: &mut Channels,
channel: usize,
pin: PwmPin,
value: f64,
) -> Result<Handler, Error> {
match pin {
PwmPin::ISet => {
channels.channel_state(channel).pid_engaged = false;
let current = ElectricCurrent::new::<ampere>(value);
channels.set_i(channel, current);
channels.power_up(channel);
}
PwmPin::MaxV => {
let voltage = ElectricPotential::new::<volt>(value);
channels.set_max_v(channel, voltage);
}
PwmPin::MaxIPos => {
let current = ElectricCurrent::new::<ampere>(value);
channels.set_max_i_pos(channel, current);
}
PwmPin::MaxINeg => {
let current = ElectricCurrent::new::<ampere>(value);
channels.set_max_i_neg(channel, current);
}
}
send_line(socket, b"{}");
Ok(Handler::Handled)
}
fn set_center_point(
socket: &mut TcpSocket,
channels: &mut Channels,
channel: usize,
center: CenterPoint,
) -> Result<Handler, Error> {
let i_set = channels.get_i_set(channel);
let state = channels.channel_state(channel);
state.center = center;
if !state.pid_engaged {
channels.set_i(channel, i_set);
}
send_line(socket, b"{}");
Ok(Handler::Handled)
}
fn set_pid(
socket: &mut TcpSocket,
channels: &mut Channels,
channel: usize,
parameter: PidParameter,
value: f64,
) -> Result<Handler, Error> {
let pid = &mut channels.channel_state(channel).pid;
use super::command_parser::PidParameter::*;
match parameter {
Target => pid.target = value,
KP => pid.parameters.kp = value as f32,
KI => pid.update_ki(value as f32),
KD => pid.parameters.kd = value as f32,
OutputMin => pid.parameters.output_min = value as f32,
OutputMax => pid.parameters.output_max = value as f32,
}
send_line(socket, b"{}");
Ok(Handler::Handled)
}
fn set_b_parameter(
socket: &mut TcpSocket,
channels: &mut Channels,
channel: usize,
parameter: BpParameter,
value: f64,
) -> Result<Handler, Error> {
let bp = &mut channels.channel_state(channel).bp;
use super::command_parser::BpParameter::*;
match parameter {
T0 => bp.t0 = ThermodynamicTemperature::new::<degree_celsius>(value),
B => bp.b = TemperatureInterval::new::<kelvin>(value),
R0 => bp.r0 = ElectricalResistance::new::<ohm>(value),
}
send_line(socket, b"{}");
Ok(Handler::Handled)
}
fn reset_post_filter(
socket: &mut TcpSocket,
channels: &mut Channels,
channel: usize,
) -> Result<Handler, Error> {
channels.adc.set_postfilter(channel as u8, None).unwrap();
send_line(socket, b"{}");
Ok(Handler::Handled)
}
fn set_post_filter(
socket: &mut TcpSocket,
channels: &mut Channels,
channel: usize,
rate: f32,
) -> Result<Handler, Error> {
let filter = ad7172::PostFilter::closest(rate);
match filter {
Some(filter) => {
channels
.adc
.set_postfilter(channel as u8, Some(filter))
.unwrap();
send_line(socket, b"{}");
}
None => {
error!("unable to choose postfilter for rate {:.3}", rate);
send_line(
socket,
b"{{\"error\": \"unable to choose postfilter rate\"}}",
);
return Err(Error::PostFilterRate);
}
}
Ok(Handler::Handled)
}
fn load_channel(
socket: &mut TcpSocket,
channels: &mut Channels,
store: &mut FlashStore,
channel: Option<usize>,
) -> Result<Handler, Error> {
for (c, key) in CHANNEL_CONFIG_KEY.iter().enumerate().take(CHANNELS) {
if channel.is_none() || channel == Some(c) {
match store.read_value::<ChannelConfig>(key) {
Ok(Some(config)) => {
config.apply(channels, c);
send_line(socket, b"{}");
}
Ok(None) => {
error!("flash config not found");
send_line(socket, b"{{\"error\": \"flash config not found\"}}");
}
Err(e) => {
error!("unable to load config from flash: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
return Err(Error::Flash);
}
}
}
}
Ok(Handler::Handled)
}
fn save_channel(
socket: &mut TcpSocket,
channels: &mut Channels,
channel: Option<usize>,
store: &mut FlashStore,
) -> Result<Handler, Error> {
for (c, key) in CHANNEL_CONFIG_KEY.iter().enumerate().take(CHANNELS) {
let mut store_value_buf = [0u8; 256];
if channel.is_none() || channel == Some(c) {
let config = ChannelConfig::new(channels, c);
match store.write_value(key, &config, &mut store_value_buf) {
Ok(()) => {
send_line(socket, b"{}");
}
Err(e) => {
error!("unable to save channel {} config to flash: {:?}", c, e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
return Err(Error::Flash);
}
}
}
}
Ok(Handler::Handled)
}
fn set_ipv4(
socket: &mut TcpSocket,
store: &mut FlashStore,
config: Ipv4Config,
) -> Result<Handler, Error> {
let _ = store
.write_value("ipv4", &config, [0; 16])
.map_err(|e| error!("unable to save ipv4 config to flash: {:?}", e));
let new_ipv4_config = Some(config);
send_line(socket, b"{}");
Ok(Handler::NewIPV4(new_ipv4_config.unwrap()))
}
fn reset(channels: &mut Channels) -> Result<Handler, Error> {
for i in 0..CHANNELS {
channels.power_down(i);
}
// should_reset = true;
Ok(Handler::Reset)
}
fn dfu(channels: &mut Channels) -> Result<Handler, Error> {
for i in 0..CHANNELS {
channels.power_down(i);
}
unsafe {
dfu::set_dfu_trigger();
}
// should_reset = true;
Ok(Handler::Reset)
}
fn set_fan(
socket: &mut TcpSocket,
fan_pwm: u32,
fan_ctrl: &mut FanCtrl,
) -> Result<Handler, Error> {
if !fan_ctrl.fan_available() {
send_line(
socket,
b"{ \"warning\": \"this thermostat doesn't have a fan!\" }",
);
return Ok(Handler::Handled);
}
fan_ctrl.set_auto_mode(false);
fan_ctrl.set_pwm(fan_pwm);
if fan_ctrl.fan_pwm_recommended() {
send_line(socket, b"{}");
} else {
send_line(socket, b"{ \"warning\": \"this fan doesn't have full PWM support. Use it at your own risk!\" }");
}
Ok(Handler::Handled)
}
fn show_fan(socket: &mut TcpSocket, fan_ctrl: &mut FanCtrl) -> Result<Handler, Error> {
match fan_ctrl.summary() {
Ok(buf) => {
send_line(socket, &buf);
Ok(Handler::Handled)
}
Err(e) => {
error!("unable to serialize fan summary: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
Err(Error::Report)
}
}
}
fn fan_auto(socket: &mut TcpSocket, fan_ctrl: &mut FanCtrl) -> Result<Handler, Error> {
if !fan_ctrl.fan_available() {
send_line(
socket,
b"{ \"warning\": \"this thermostat doesn't have a fan!\" }",
);
return Ok(Handler::Handled);
}
fan_ctrl.set_auto_mode(true);
if fan_ctrl.fan_pwm_recommended() {
send_line(socket, b"{}");
} else {
send_line(socket, b"{ \"warning\": \"this fan doesn't have full PWM support. Use it at your own risk!\" }");
}
Ok(Handler::Handled)
}
fn fan_curve(
socket: &mut TcpSocket,
fan_ctrl: &mut FanCtrl,
k_a: f32,
k_b: f32,
k_c: f32,
) -> Result<Handler, Error> {
fan_ctrl.set_curve(k_a, k_b, k_c);
send_line(socket, b"{}");
Ok(Handler::Handled)
}
fn fan_defaults(socket: &mut TcpSocket, fan_ctrl: &mut FanCtrl) -> Result<Handler, Error> {
fan_ctrl.restore_defaults();
send_line(socket, b"{}");
Ok(Handler::Handled)
}
fn show_hwrev(socket: &mut TcpSocket, hwrev: HWRev) -> Result<Handler, Error> {
match hwrev.summary() {
Ok(buf) => {
send_line(socket, &buf);
Ok(Handler::Handled)
}
Err(e) => {
error!("unable to serialize HWRev summary: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
Err(Error::Report)
}
}
}
pub fn handle_command(
command: Command,
socket: &mut TcpSocket,
channels: &mut Channels,
store: &mut FlashStore,
ipv4_config: &mut Ipv4Config,
fan_ctrl: &mut FanCtrl,
hwrev: HWRev,
) -> Result<Self, Error> {
match command {
Command::Quit => Ok(Handler::CloseSocket),
Command::Show(ShowCommand::Input) => Handler::show_report(socket, channels),
Command::Show(ShowCommand::Pid) => Handler::show_pid(socket, channels),
Command::Show(ShowCommand::Output) => Handler::show_pwm(socket, channels),
Command::Show(ShowCommand::BParameter) => Handler::show_b_parameter(socket, channels),
Command::Show(ShowCommand::PostFilter) => Handler::show_post_filter(socket, channels),
Command::Show(ShowCommand::Ipv4) => Handler::show_ipv4(socket, ipv4_config),
Command::OutputPid { channel } => Handler::engage_pid(socket, channels, channel),
Command::OutputPolarity { channel, polarity } => {
Handler::set_polarity(socket, channels, channel, polarity)
}
Command::Output {
channel,
pin,
value,
} => Handler::set_pwm(socket, channels, channel, pin, value),
Command::CenterPoint { channel, center } => {
Handler::set_center_point(socket, channels, channel, center)
}
Command::Pid {
channel,
parameter,
value,
} => Handler::set_pid(socket, channels, channel, parameter, value),
Command::BParameter {
channel,
parameter,
value,
} => Handler::set_b_parameter(socket, channels, channel, parameter, value),
Command::PostFilter {
channel,
rate: None,
} => Handler::reset_post_filter(socket, channels, channel),
Command::PostFilter {
channel,
rate: Some(rate),
} => Handler::set_post_filter(socket, channels, channel, rate),
Command::Load { channel } => Handler::load_channel(socket, channels, store, channel),
Command::Save { channel } => Handler::save_channel(socket, channels, channel, store),
Command::Ipv4(config) => Handler::set_ipv4(socket, store, config),
Command::Reset => Handler::reset(channels),
Command::Dfu => Handler::dfu(channels),
Command::FanSet { fan_pwm } => Handler::set_fan(socket, fan_pwm, fan_ctrl),
Command::ShowFan => Handler::show_fan(socket, fan_ctrl),
Command::FanAuto => Handler::fan_auto(socket, fan_ctrl),
Command::FanCurve { k_a, k_b, k_c } => {
Handler::fan_curve(socket, fan_ctrl, k_a, k_b, k_c)
}
Command::FanCurveDefaults => Handler::fan_defaults(socket, fan_ctrl),
Command::ShowHWRev => Handler::show_hwrev(socket, hwrev),
}
}
}

721
src/command_parser.rs
View File

@ -2,18 +2,20 @@ 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::{is_digit, complete::{char, one_of}}, character::{
complete::{char, one_of},
is_digit,
},
combinator::{complete, map, opt, value}, combinator::{complete, map, opt, value},
sequence::preceded,
multi::{fold_many0, fold_many1},
error::ErrorKind, error::ErrorKind,
multi::{fold_many0, fold_many1},
sequence::preceded,
IResult, Needed,
}; };
use num_traits::{Num, ParseFloatError}; use num_traits::{Num, ParseFloatError};
use serde::{Serialize, Deserialize}; use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
pub enum Error { pub enum Error {
@ -29,12 +31,9 @@ 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(_) => nom::Err::Incomplete(_) => Error::Incomplete,
Error::Incomplete, nom::Err::Error((_, e)) => Error::Parser(e),
nom::Err::Error((_, e)) => nom::Err::Failure((_, e)) => Error::Parser(e),
Error::Parser(e),
nom::Err::Failure((_, e)) =>
Error::Parser(e),
} }
} }
} }
@ -60,8 +59,7 @@ 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 => Error::Incomplete => "incomplete input".fmt(fmt),
"incomplete input".fmt(fmt),
Error::UnexpectedInput(c) => { Error::UnexpectedInput(c) => {
"unexpected input: ".fmt(fmt)?; "unexpected input: ".fmt(fmt)?;
c.fmt(fmt) c.fmt(fmt)
@ -78,9 +76,7 @@ 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 => { Error::ParseFloat => "parsing float".fmt(fmt),
"parsing float".fmt(fmt)
}
} }
} }
} }
@ -95,10 +91,9 @@ pub struct Ipv4Config {
#[derive(Debug, Clone, PartialEq)] #[derive(Debug, Clone, PartialEq)]
pub enum ShowCommand { pub enum ShowCommand {
Input, Input,
Reporting, Output,
Pwm,
Pid, Pid,
SteinhartHart, BParameter,
PostFilter, PostFilter,
Ipv4, Ipv4,
} }
@ -111,13 +106,11 @@ pub enum PidParameter {
KD, KD,
OutputMin, OutputMin,
OutputMax, OutputMax,
IntegralMin,
IntegralMax,
} }
/// Steinhart-Hart equation parameter /// B-Parameter equation parameter
#[derive(Debug, Clone, PartialEq)] #[derive(Debug, Clone, PartialEq)]
pub enum ShParameter { pub enum BpParameter {
T0, T0,
B, B,
R0, R0,
@ -133,10 +126,16 @@ 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,
@ -149,17 +148,20 @@ pub enum Command {
Reset, Reset,
Ipv4(Ipv4Config), Ipv4(Ipv4Config),
Show(ShowCommand), Show(ShowCommand),
Reporting(bool),
/// PWM parameter setting /// PWM parameter setting
Pwm { Output {
channel: usize, channel: usize,
pin: PwmPin, pin: PwmPin,
value: f64, value: f64,
}, },
/// Enable PID control for `i_set` /// Enable PID control for `i_set`
PwmPid { OutputPid {
channel: usize, channel: usize,
}, },
OutputPolarity {
channel: usize,
polarity: Polarity,
},
CenterPoint { CenterPoint {
channel: usize, channel: usize,
center: CenterPoint, center: CenterPoint,
@ -170,9 +172,9 @@ pub enum Command {
parameter: PidParameter, parameter: PidParameter,
value: f64, value: f64,
}, },
SteinhartHart { BParameter {
channel: usize, channel: usize,
parameter: ShParameter, parameter: BpParameter,
value: f64, value: f64,
}, },
PostFilter { PostFilter {
@ -180,15 +182,22 @@ pub enum Command {
rate: Option<f32>, rate: Option<f32>,
}, },
Dfu, Dfu,
FanSet {
fan_pwm: u32,
},
FanAuto,
ShowFan,
FanCurve {
k_a: f32,
k_b: f32,
k_c: f32,
},
FanCurveDefaults,
ShowHWRev,
} }
fn end(input: &[u8]) -> IResult<&[u8], ()> { fn end(input: &[u8]) -> IResult<&[u8], ()> {
complete( complete(fold_many0(one_of("\r\n\t "), (), |(), _| ()))(input)
fold_many0(
one_of("\r\n\t "),
(), |(), _| ()
)
)(input)
} }
fn whitespace(input: &[u8]) -> IResult<&[u8], ()> { fn whitespace(input: &[u8]) -> IResult<&[u8], ()> {
@ -196,38 +205,25 @@ 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) take_while1(is_digit)(input).map(|(input, digits)| {
.map(|(input, digits)| { let result = from_utf8(digits)
let result = .map_err(|e| e.into())
from_utf8(digits) .and_then(|digits| digits.parse::<u32>().map_err(|e| e.into()));
.map_err(|e| e.into()) (input, result)
.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 == '.' as u8)(input)?; let (input, digits) = take_while1(|c| is_digit(c) || c == b'.')(input)?;
let result = let result = from_utf8(digits)
from_utf8(digits)
.map_err(|e| e.into()) .map_err(|e| e.into())
.and_then(|digits| f64::from_str_radix(digits, 10) .and_then(|digits| f64::from_str_radix(digits, 10).map_err(|e| e.into()))
.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)
} }
@ -235,83 +231,55 @@ 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"),
alt(( // `report` - Report once
preceded( value(Command::Show(ShowCommand::Input), end),
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 = |pin: PwmPin| let result_with_pin =
move |result: Result<f64, Error>| |pin: PwmPin| move |result: Result<f64, Error>| result.map(|value| (pin, value));
result.map(|value| (pin, value));
alt(( alt((
map( map(
preceded( preceded(tag("i_set"), preceded(whitespace, float)),
tag("i_set"), result_with_pin(PwmPin::ISet),
preceded(
whitespace,
float
)
),
result_with_pin(PwmPin::ISet)
), ),
map( map(
preceded( preceded(tag("max_i_pos"), preceded(whitespace, float)),
tag("max_i_pos"), result_with_pin(PwmPin::MaxIPos),
preceded(
whitespace,
float
)
),
result_with_pin(PwmPin::MaxIPos)
), ),
map( map(
preceded( preceded(tag("max_i_neg"), preceded(whitespace, float)),
tag("max_i_neg"), result_with_pin(PwmPin::MaxINeg),
preceded(
whitespace,
float
)
),
result_with_pin(PwmPin::MaxINeg)
), ),
map( map(
preceded( preceded(tag("max_v"), preceded(whitespace, float)),
tag("max_v"), result_with_pin(PwmPin::MaxV),
preceded( ),
whitespace, ))(input)
float
)
),
result_with_pin(PwmPin::MaxV)
))
)(input)
} }
/// `pwm <0-1> pid` - Set PWM to be controlled by PID /// `output <0-1> pid` - Set output to be controlled by PID
fn pwm_pid(input: &[u8]) -> IResult<&[u8], ()> { fn output_pid(input: &[u8]) -> IResult<&[u8], ()> {
value((), tag("pid"))(input) value((), tag("pid"))(input)
} }
fn pwm(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> { fn output_polarity(input: &[u8]) -> IResult<&[u8], Polarity> {
let (input, _) = tag("pwm")(input)?; preceded(
tag("polarity"),
preceded(
whitespace,
alt((
value(Polarity::Normal, tag("normal")),
value(Polarity::Reversed, tag("reversed")),
)),
),
)(input)
}
fn output(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
let (input, _) = tag("output")(input)?;
alt(( alt((
|input| { |input| {
let (input, _) = whitespace(input)?; let (input, _) = whitespace(input)?;
@ -319,23 +287,32 @@ fn pwm(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, ()) = pwm_pid(input)?; let (input, ()) = output_pid(input)?;
Ok((input, Ok(Command::PwmPid { channel }))) Ok((input, Ok(Command::OutputPid { 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((pin, value)) => Ok((
Ok((input, Ok(Command::Pwm { channel, pin, value }))), input,
Err(e) => Ok(Command::Output {
Ok((input, Err(e))), channel,
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::Pwm)), end) value(Ok(Command::Show(ShowCommand::Output)), end),
))(input) ))(input)
} }
@ -344,38 +321,39 @@ 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(( let (input, center) = alt((value(Ok(CenterPoint::VRef), tag("vref")), |input| {
value(Ok(CenterPoint::Vref), tag("vref")), let (input, value) = float(input)?;
|input| { Ok((
let (input, value) = float(input)?; input,
Ok((input, value.map(|value| CenterPoint::Override(value as f32)))) value.map(|value| CenterPoint::Override(value as f32)),
} ))
))(input)?; }))(input)?;
end(input)?; end(input)?;
Ok((input, center.map(|center| Command::CenterPoint { Ok((
channel, input,
center, center.map(|center| Command::CenterPoint { channel, 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) = let (input, parameter) = alt((
alt((value(PidParameter::Target, tag("target")), 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")),
value(PidParameter::IntegralMin, tag("integral_min")), ))(input)?;
value(PidParameter::IntegralMax, tag("integral_max"))
))(input)?;
let (input, _) = whitespace(input)?; let (input, _) = whitespace(input)?;
let (input, value) = float(input)?; let (input, value) = float(input)?;
let result = value let result = value.map(|value| Command::Pid {
.map(|value| Command::Pid { channel, parameter, value }); channel,
parameter,
value,
});
Ok((input, result)) Ok((input, result))
} }
@ -383,70 +361,66 @@ 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( preceded(whitespace, pid_parameter),
whitespace, value(Ok(Command::Show(ShowCommand::Pid)), end),
pid_parameter
),
value(Ok(Command::Show(ShowCommand::Pid)), end)
))(input) ))(input)
} }
/// `s-h <0-1> <parameter> <value>` /// `b-p <0-1> <parameter> <value>`
fn steinhart_hart_parameter(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> { fn b_parameter_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) = let (input, parameter) = alt((
alt((value(ShParameter::T0, tag("t0")), value(BpParameter::T0, tag("t0")),
value(ShParameter::B, tag("b")), value(BpParameter::B, tag("b")),
value(ShParameter::R0, tag("r0")) value(BpParameter::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 let result = value.map(|value| Command::BParameter {
.map(|value| Command::SteinhartHart { channel, parameter, value }); channel,
parameter,
value,
});
Ok((input, result)) Ok((input, result))
} }
/// `s-h` | `s-h <steinhart_hart_parameter>` /// `b-p` | `b-p <b_parameter_parameter>`
fn steinhart_hart(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> { fn b_parameter(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
let (input, _) = tag("s-h")(input)?; let (input, _) = tag("b-p")(input)?;
alt(( alt((
preceded( preceded(whitespace, b_parameter_parameter),
whitespace, value(Ok(Command::Show(ShowCommand::BParameter)), end),
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( preceded(whitespace, |input| {
whitespace, let (input, channel) = channel(input)?;
|input| { let (input, _) = whitespace(input)?;
let (input, channel) = channel(input)?; alt((
let (input, _) = whitespace(input)?; value(
alt(( Ok(Command::PostFilter {
value(Ok(Command::PostFilter {
channel, channel,
rate: None, rate: None,
}), tag("off")), }),
move |input| { tag("off"),
let (input, _) = tag("rate")(input)?; ),
let (input, _) = whitespace(input)?; move |input| {
let (input, rate) = float(input)?; let (input, _) = tag("rate")(input)?;
let result = rate let (input, _) = whitespace(input)?;
.map(|rate| Command::PostFilter { let (input, rate) = float(input)?;
channel, let result = rate.map(|rate| Command::PostFilter {
rate: Some(rate as f32), channel,
}); 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)
} }
@ -459,7 +433,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 });
@ -475,7 +449,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 });
@ -524,31 +498,95 @@ fn ipv4(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
))(input) ))(input)
} }
fn fan(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
let (input, _) = tag("fan")(input)?;
alt((
|input| {
let (input, _) = whitespace(input)?;
let (input, result) = alt((
|input| {
let (input, _) = tag("auto")(input)?;
Ok((input, Ok(Command::FanAuto)))
},
|input| {
let (input, value) = unsigned(input)?;
Ok((
input,
Ok(Command::FanSet {
fan_pwm: value.unwrap_or(0),
}),
))
},
))(input)?;
Ok((input, result))
},
value(Ok(Command::ShowFan), end),
))(input)
}
fn fan_curve(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
let (input, _) = tag("fcurve")(input)?;
alt((
|input| {
let (input, _) = whitespace(input)?;
let (input, result) = alt((
|input| {
let (input, _) = tag("default")(input)?;
Ok((input, Ok(Command::FanCurveDefaults)))
},
|input| {
let (input, k_a) = float(input)?;
let (input, _) = whitespace(input)?;
let (input, k_b) = float(input)?;
let (input, _) = whitespace(input)?;
let (input, k_c) = float(input)?;
if let (Ok(k_a), Ok(k_b), Ok(k_c)) = (k_a, k_b, k_c) {
Ok((
input,
Ok(Command::FanCurve {
k_a: k_a as f32,
k_b: k_b as f32,
k_c: k_c as f32,
}),
))
} else {
Err(nom::Err::Incomplete(Needed::Size(3)))
}
},
))(input)?;
Ok((input, result))
},
value(Err(Error::Incomplete), end),
))(input)
}
fn command(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> { fn command(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
alt((value(Ok(Command::Quit), tag("quit")), alt((
load, value(Ok(Command::Quit), tag("quit")),
save, load,
value(Ok(Command::Reset), tag("reset")), save,
ipv4, value(Ok(Command::Reset), tag("reset")),
map(report, Ok), ipv4,
pwm, map(report, Ok),
center_point, output,
pid, center_point,
steinhart_hart, pid,
postfilter, b_parameter,
value(Ok(Command::Dfu), tag("dfu")), postfilter,
value(Ok(Command::Dfu), tag("dfu")),
fan,
fan_curve,
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.len() == 0 => Ok((input_remain, result)) if input_remain.is_empty() => result,
result, Ok((input_remain, _)) => Err(Error::UnexpectedInput(input_remain[0])),
Ok((input_remain, _)) => Err(e) => Err(e.into()),
Err(Error::UnexpectedInput(input_remain[0])),
Err(e) =>
Err(e.into()),
} }
} }
} }
@ -596,21 +634,27 @@ 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!(command, Ok(Command::Ipv4(Ipv4Config { assert_eq!(
address: [192, 168, 1, 26], command,
mask_len: 24, Ok(Command::Ipv4(Ipv4Config {
gateway: None, address: [192, 168, 1, 26],
}))); 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!(command, Ok(Command::Ipv4(Ipv4Config { assert_eq!(
address: [10, 42, 0, 126], command,
mask_len: 8, Ok(Command::Ipv4(Ipv4Config {
gateway: Some([10, 1, 0, 1]), address: [10, 42, 0, 126],
}))); mask_len: 8,
gateway: Some([10, 1, 0, 1]),
}))
);
} }
#[test] #[test]
@ -620,69 +664,73 @@ mod test {
} }
#[test] #[test]
fn parse_report_mode() { fn parse_output_i_set() {
let command = Command::parse(b"report mode"); let command = Command::parse(b"output 1 i_set 16383");
assert_eq!(command, Ok(Command::Show(ShowCommand::Reporting))); assert_eq!(
command,
Ok(Command::Output {
channel: 1,
pin: PwmPin::ISet,
value: 16383.0,
})
);
} }
#[test] #[test]
fn parse_report_mode_on() { fn parse_output_polarity() {
let command = Command::parse(b"report mode on"); let command = Command::parse(b"output 0 polarity reversed");
assert_eq!(command, Ok(Command::Reporting(true))); assert_eq!(
command,
Ok(Command::OutputPolarity {
channel: 0,
polarity: Polarity::Reversed,
})
);
} }
#[test] #[test]
fn parse_report_mode_off() { fn parse_output_pid() {
let command = Command::parse(b"report mode off"); let command = Command::parse(b"output 0 pid");
assert_eq!(command, Ok(Command::Reporting(false))); assert_eq!(command, Ok(Command::OutputPid { channel: 0 }));
} }
#[test] #[test]
fn parse_pwm_i_set() { fn parse_output_max_i_pos() {
let command = Command::parse(b"pwm 1 i_set 16383"); let command = Command::parse(b"output 0 max_i_pos 7");
assert_eq!(command, Ok(Command::Pwm { assert_eq!(
channel: 1, command,
pin: PwmPin::ISet, Ok(Command::Output {
value: 16383.0, channel: 0,
})); pin: PwmPin::MaxIPos,
value: 7.0,
})
);
} }
#[test] #[test]
fn parse_pwm_pid() { fn parse_output_max_i_neg() {
let command = Command::parse(b"pwm 0 pid"); let command = Command::parse(b"output 0 max_i_neg 128");
assert_eq!(command, Ok(Command::PwmPid { assert_eq!(
channel: 0, command,
})); Ok(Command::Output {
channel: 0,
pin: PwmPin::MaxINeg,
value: 128.0,
})
);
} }
#[test] #[test]
fn parse_pwm_max_i_pos() { fn parse_output_max_v() {
let command = Command::parse(b"pwm 0 max_i_pos 7"); let command = Command::parse(b"output 0 max_v 32768");
assert_eq!(command, Ok(Command::Pwm { assert_eq!(
channel: 0, command,
pin: PwmPin::MaxIPos, Ok(Command::Output {
value: 7.0, channel: 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]
@ -694,37 +742,33 @@ 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!(command, Ok(Command::Pid { assert_eq!(
channel: 0, command,
parameter: PidParameter::Target, Ok(Command::Pid {
value: 36.5, channel: 0,
})); parameter: PidParameter::Target,
value: 36.5,
})
);
} }
#[test] #[test]
fn parse_pid_integral_max() { fn parse_b_parameter() {
let command = Command::parse(b"pid 1 integral_max 2000"); let command = Command::parse(b"b-p");
assert_eq!(command, Ok(Command::Pid { assert_eq!(command, Ok(Command::Show(ShowCommand::BParameter)));
channel: 1,
parameter: PidParameter::IntegralMax,
value: 2000.0,
}));
} }
#[test] #[test]
fn parse_steinhart_hart() { fn parse_b_parameter_set() {
let command = Command::parse(b"s-h"); let command = Command::parse(b"b-p 1 t0 23.05");
assert_eq!(command, Ok(Command::Show(ShowCommand::SteinhartHart))); assert_eq!(
} command,
Ok(Command::BParameter {
#[test] channel: 1,
fn parse_steinhart_hart_set() { parameter: BpParameter::T0,
let command = Command::parse(b"s-h 1 t0 23.05"); value: 23.05,
assert_eq!(command, Ok(Command::SteinhartHart { })
channel: 1, );
parameter: ShParameter::T0,
value: 23.05,
}));
} }
#[test] #[test]
@ -736,36 +780,91 @@ 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!(command, Ok(Command::PostFilter { assert_eq!(
channel: 1, command,
rate: None, Ok(Command::PostFilter {
})); 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!(command, Ok(Command::PostFilter { assert_eq!(
channel: 0, command,
rate: Some(21.0), Ok(Command::PostFilter {
})); 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!(command, Ok(Command::CenterPoint { assert_eq!(
channel: 0, command,
center: CenterPoint::Override(1.5), Ok(Command::CenterPoint {
})); 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!(command, Ok(Command::CenterPoint { assert_eq!(
channel: 1, command,
center: CenterPoint::Vref, Ok(Command::CenterPoint {
})); channel: 1,
center: CenterPoint::VRef,
})
);
}
#[test]
fn parse_fan_show() {
let command = Command::parse(b"fan");
assert_eq!(command, Ok(Command::ShowFan));
}
#[test]
fn parse_fan_set() {
let command = Command::parse(b"fan 42");
assert_eq!(command, Ok(Command::FanSet { fan_pwm: 42 }));
}
#[test]
fn parse_fan_auto() {
let command = Command::parse(b"fan auto");
assert_eq!(command, Ok(Command::FanAuto));
}
#[test]
fn parse_fcurve_set() {
let command = Command::parse(b"fcurve 1.2 3.4 5.6");
assert_eq!(
command,
Ok(Command::FanCurve {
k_a: 1.2,
k_b: 3.4,
k_c: 5.6
})
);
}
#[test]
fn parse_fcurve_default() {
let command = Command::parse(b"fcurve default");
assert_eq!(command, Ok(Command::FanCurveDefaults));
}
#[test]
fn parse_hwrev() {
let command = Command::parse(b"hwrev");
assert_eq!(command, Ok(Command::ShowHWRev));
} }
} }

58
src/config.rs
View File

@ -1,16 +1,13 @@
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, command_parser::{CenterPoint, Polarity},
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 {
@ -18,7 +15,9 @@ pub struct ChannelConfig {
pid: pid::Parameters, pid: pid::Parameters,
pid_target: f32, pid_target: f32,
pid_engaged: bool, pid_engaged: bool,
sh: steinhart_hart::Parameters, i_set: ElectricCurrent,
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,
@ -28,17 +27,26 @@ 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.adc.get_postfilter(channel as u8) let adc_postfilter = channels
.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,
sh: state.sh.clone(), i_set,
polarity: state.polarity.clone(),
bp: state.bp.clone(),
pwm, pwm,
adc_postfilter, adc_postfilter,
} }
@ -50,7 +58,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.sh = self.sh.clone(); state.bp = self.bp.clone();
self.pwm.apply(channels, channel); self.pwm.apply(channels, channel);
@ -59,31 +67,33 @@ 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)]
struct PwmLimits { pub struct PwmLimits {
max_v: f64, pub max_v: ElectricPotential,
max_i_pos: f64, pub max_i_pos: ElectricCurrent,
max_i_neg: f64, pub max_i_neg: ElectricCurrent,
} }
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.get::<volt>(), max_v,
max_i_pos: max_i_pos.get::<ampere>(), max_i_pos,
max_i_neg: max_i_neg.get::<ampere>(), max_i_neg,
} }
} }
pub fn apply(&self, channels: &mut Channels, channel: usize) { pub fn apply(&self, channels: &mut Channels, channel: usize) {
channels.set_max_v(channel, ElectricPotential::new::<volt>(self.max_v)); channels.set_max_v(channel, self.max_v);
channels.set_max_i_pos(channel, ElectricCurrent::new::<ampere>(self.max_i_pos)); channels.set_max_i_pos(channel, self.max_i_pos);
channels.set_max_i_neg(channel, ElectricCurrent::new::<ampere>(self.max_i_neg)); channels.set_max_i_neg(channel, self.max_i_neg);
} }
} }

9
src/dfu.rs
View File

@ -1,3 +1,4 @@
use core::arch::asm;
use cortex_m_rt::pre_init; use cortex_m_rt::pre_init;
use stm32f4xx_hal::stm32::{RCC, SYSCFG}; use stm32f4xx_hal::stm32::{RCC, SYSCFG};
@ -13,7 +14,7 @@ pub unsafe fn set_dfu_trigger() {
} }
/// Called by reset handler in lib.rs immediately after reset. /// Called by reset handler in lib.rs immediately after reset.
/// This function should not be called outside of reset handler as /// This function should not be called outside of reset handler as
/// bootloader expects MCU to be in reset state when called. /// bootloader expects MCU to be in reset state when called.
#[cfg(target_arch = "arm")] #[cfg(target_arch = "arm")]
#[pre_init] #[pre_init]
@ -26,13 +27,13 @@ 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
cortex_m::asm::isb(); cortex_m::asm::isb();
cortex_m::asm::dsb(); cortex_m::asm::dsb();
asm!( asm!(
// Set stack pointer to bootloader location // Set stack pointer to bootloader location
"LDR R0, =0x1FFF0000", "LDR R0, =0x1FFF0000",

162
src/fan_ctrl.rs Normal file
View File

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

16
src/flash_store.rs
View File

@ -1,9 +1,9 @@
use log::{info, error}; use log::{error, info};
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,9 +21,7 @@ pub struct FlashBackend {
} }
fn get_offset() -> usize { fn get_offset() -> usize {
unsafe { unsafe { (&_config_start as *const usize as usize) - (&_flash_start as *const usize as usize) }
(&_config_start as *const usize as usize) - (&_flash_start as *const usize as usize)
}
} }
impl StoreBackend for FlashBackend { impl StoreBackend for FlashBackend {
@ -40,8 +38,9 @@ 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.unlocked() self.flash
.program(get_offset() + offset, payload.iter().cloned()) .unlocked()
.program(get_offset() + offset, payload.iter())
} }
fn backup_space(&self) -> &'static mut [u8] { fn backup_space(&self) -> &'static mut [u8] {
@ -60,7 +59,8 @@ 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.erase() let _ = store
.erase()
.map_err(|e| error!("flash erase failed: {:?}", e)); .map_err(|e| error!("flash erase failed: {:?}", e));
} }
} }

86
src/hw_rev.rs Normal file
View File

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

8
src/init_log.rs
View File

@ -10,17 +10,15 @@ 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 { let logger = unsafe { LOGGER.get_or_insert(logger) };
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::{PD9, PD10, PD11}, gpiod::{PD10, PD11, PD9},
Output, PushPull, Output, PushPull,
}, },
hal::digital::v2::OutputPin, hal::digital::v2::OutputPin,

500
src/main.rs
View File

@ -1,72 +1,56 @@
#![cfg_attr(not(test), no_std)] #![cfg_attr(not(test), no_std)]
#![cfg_attr(not(test), no_main)] #![cfg_attr(not(test), no_main)]
#![feature(maybe_uninit_extra, maybe_uninit_ref, asm)]
#![cfg_attr(test, allow(unused))] #![cfg_attr(test, allow(unused))]
// TODO: #![deny(warnings, unused)] // TODO: #![deny(warnings, unused)]
#[cfg(not(any(feature = "semihosting", test)))] #[cfg(not(any(feature = "semihosting", test)))]
use panic_abort as _; 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 core::fmt::Write;
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::{WatchdogEnable, Watchdog}, hal::watchdog::{Watchdog, WatchdogEnable},
rcc::RccExt, rcc::RccExt,
stm32::{CorePeripherals, Peripherals, SCB}, stm32::{CorePeripherals, Peripherals, SCB},
time::{U32Ext, MegaHertz}, time::{MegaHertz, U32Ext},
watchdog::IndependentWatchdog, watchdog::IndependentWatchdog,
}; };
use smoltcp::{
time::Instant,
socket::TcpSocket,
wire::EthernetAddress,
};
use uom::{
si::{
f64::{
ElectricCurrent,
ElectricPotential,
ElectricalResistance,
ThermodynamicTemperature,
},
electric_current::ampere,
electric_potential::volt,
electrical_resistance::ohm,
thermodynamic_temperature::degree_celsius,
},
};
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 ad7172;
mod ad5680; mod ad5680;
mod ad7172;
mod net; mod net;
mod server; mod server;
use server::Server; use server::Server;
mod session; mod session;
use session::{Session, SessionInput}; use session::{Session, SessionInput};
mod command_parser; mod command_parser;
use command_parser::{Command, Ipv4Config, PwmPin, ShowCommand}; use command_parser::Ipv4Config;
mod timer; mod b_parameter;
mod pid;
mod steinhart_hart;
mod channels; mod channels;
use channels::{CHANNELS, Channels}; mod pid;
mod timer;
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 flash_store; mod command_handler;
mod dfu; mod dfu;
mod flash_store;
use command_handler::Handler;
mod fan_ctrl;
use fan_ctrl::FanCtrl;
mod hw_rev;
const HSE: MegaHertz = MegaHertz(8); const HSE: MegaHertz = MegaHertz(8);
#[cfg(not(feature = "semihosting"))] #[cfg(not(feature = "semihosting"))]
@ -85,19 +69,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, socket.send_capacity(), data.len(), send_free + 1,
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) => Ok(sent) => warn!("sent only {}/{} bytes", sent, data.len()),
warn!("sent only {}/{} bytes", sent, data.len()), Err(e) => error!("error sending line: {:?}", e),
Err(e) =>
error!("error sending line: {:?}", e),
} }
} }
// not success // not success
@ -116,7 +100,9 @@ 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.RCC.constrain() let clocks = dp
.RCC
.constrain()
.cfgr .cfgr
.use_hse(HSE) .use_hse(HSE)
.sysclk(168.mhz()) .sysclk(168.mhz())
@ -131,15 +117,16 @@ fn main() -> ! {
timer::setup(cp.SYST, clocks); timer::setup(cp.SYST, clocks);
let (pins, mut leds, mut eeprom, eth_pins, usb) = Pins::setup( let (pins, mut leds, mut eeprom, eth_pins, usb, fan, hwrev, hw_settings) = Pins::setup(
clocks, dp.TIM1, dp.TIM3, clocks,
dp.GPIOA, dp.GPIOB, dp.GPIOC, dp.GPIOD, dp.GPIOE, dp.GPIOF, dp.GPIOG, (dp.TIM1, dp.TIM3, dp.TIM8),
(
dp.GPIOA, dp.GPIOB, dp.GPIOC, dp.GPIOD, dp.GPIOE, dp.GPIOF, dp.GPIOG,
),
dp.I2C1, dp.I2C1,
dp.SPI2, dp.SPI4, dp.SPI5, (dp.SPI2, dp.SPI4, dp.SPI5),
dp.ADC1, dp.ADC1,
dp.OTG_FS_GLOBAL, (dp.OTG_FS_GLOBAL, dp.OTG_FS_DEVICE, dp.OTG_FS_PWRCLK),
dp.OTG_FS_DEVICE,
dp.OTG_FS_PWRCLK,
); );
leds.r1.on(); leds.r1.on();
@ -149,20 +136,18 @@ fn main() -> ! {
usb::State::setup(usb); usb::State::setup(usb);
let mut store = flash_store::store(dp.FLASH); let mut store = flash_store::store(dp.FLASH);
let mut store_value_buf = [0u8; 256];
let mut channels = Channels::new(pins); let mut channels = Channels::new(pins);
for c in 0..CHANNELS { for (c, key) in CHANNEL_CONFIG_KEY.iter().enumerate().take(CHANNELS) {
match store.read_value::<ChannelConfig>(CHANNEL_CONFIG_KEY[c]) { match store.read_value::<ChannelConfig>(key) {
Ok(Some(config)) => Ok(Some(config)) => config.apply(&mut channels, c),
config.apply(&mut channels, c), Ok(None) => error!("flash config not found for channel {}", c),
Ok(None) => Err(e) => error!("unable to load config {} from flash: {:?}", c, e),
error!("flash config not found for channel {}", c),
Err(e) =>
error!("unable to load config {} from flash: {:?}", c, e),
} }
} }
let mut fan_ctrl = FanCtrl::new(fan, hw_settings);
// default net config: // default net config:
let mut ipv4_config = Ipv4Config { let mut ipv4_config = Ipv4Config {
address: [192, 168, 1, 26], address: [192, 168, 1, 26],
@ -170,11 +155,9 @@ fn main() -> ! {
gateway: None, gateway: None,
}; };
match store.read_value("ipv4") { match store.read_value("ipv4") {
Ok(Some(config)) => Ok(Some(config)) => ipv4_config = config,
ipv4_config = config,
Ok(None) => {} Ok(None) => {}
Err(e) => Err(e) => error!("cannot read ipv4 config: {:?}", 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
@ -183,320 +166,115 @@ fn main() -> ! {
let hwaddr = EthernetAddress(eui48); let hwaddr = EthernetAddress(eui48);
info!("EEPROM MAC address: {}", hwaddr); info!("EEPROM MAC address: {}", hwaddr);
net::run(clocks, dp.ETHERNET_MAC, dp.ETHERNET_DMA, eth_pins, hwaddr, ipv4_config.clone(), |iface| { net::run(
Server::<Session>::run(iface, |server| { clocks,
leds.r1.off(); dp.ETHERNET_MAC,
let mut should_reset = false; dp.ETHERNET_DMA,
eth_pins,
hwaddr,
ipv4_config.clone(),
|iface| {
Server::<Session>::run(iface, |server| {
leds.r1.off();
let mut should_reset = false;
loop { loop {
let 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()));
let updated_channel = channels.poll_adc(instant); channels.poll_adc(instant);
if let Some(channel) = updated_channel {
server.for_each(|_, session| session.set_report_pending(channel.into()));
}
let instant = Instant::from_millis(i64::from(timer::now())); fan_ctrl.cycle(channels.current_abs_max_tec_i());
cortex_m::interrupt::free(net::clear_pending);
server.poll(instant) if channels.pid_engaged() {
.unwrap_or_else(|e| { leds.g3.on();
} else {
leds.g3.off();
}
let instant = Instant::from_millis(i64::from(timer::now()));
cortex_m::interrupt::free(net::clear_pending);
server.poll(instant).unwrap_or_else(|e| {
warn!("poll: {:?}", e); 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)) => match command { Ok(SessionInput::Command(command)) => {
Command::Quit => match Handler::handle_command(
socket.close(), command,
Command::Reporting(_reporting) => { &mut socket,
// handled by session &mut channels,
send_line(&mut socket, b"{}"); &mut store,
} &mut ipv4_config,
Command::Show(ShowCommand::Reporting) => { &mut fan_ctrl,
let _ = writeln!(socket, "{{ \"report\": {:?} }}", session.reporting()); hwrev,
} ) {
Command::Show(ShowCommand::Input) => { Ok(Handler::NewIPV4(ip)) => new_ipv4_config = Some(ip),
match channels.reports_json() { Ok(Handler::Handled) => {}
Ok(buf) => { Ok(Handler::CloseSocket) => socket.close(),
send_line(&mut socket, &buf[..]); Ok(Handler::Reset) => should_reset = true,
} Err(_) => {}
Err(e) => {
error!("unable to serialize report: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
}
} }
} }
Command::Show(ShowCommand::Pid) => { Ok(SessionInput::Error(e)) => {
match channels.pid_summaries_json() { error!("session input: {:?}", e);
Ok(buf) => { send_line(&mut socket, b"{ \"error\": \"invalid input\" }");
send_line(&mut socket, &buf);
}
Err(e) => {
error!("unable to serialize pid summary: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
}
}
}
Command::Show(ShowCommand::Pwm) => {
match channels.pwm_summaries_json() {
Ok(buf) => {
send_line(&mut socket, &buf);
}
Err(e) => {
error!("unable to serialize pwm summary: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
}
}
}
Command::Show(ShowCommand::SteinhartHart) => {
match channels.steinhart_hart_summaries_json() {
Ok(buf) => {
send_line(&mut socket, &buf);
}
Err(e) => {
error!("unable to serialize steinhart-hart summaries: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
}
}
}
Command::Show(ShowCommand::PostFilter) => {
match channels.postfilter_summaries_json() {
Ok(buf) => {
send_line(&mut socket, &buf);
}
Err(e) => {
error!("unable to serialize postfilter summary: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
}
}
}
Command::Show(ShowCommand::Ipv4) => {
let (cidr, gateway) = net::split_ipv4_config(ipv4_config.clone());
let _ = write!(socket, "{{\"addr\":\"{}\"", cidr);
gateway.map(|gateway| write!(socket, ",\"gateway\":\"{}\"", gateway));
let _ = writeln!(socket, "}}");
}
Command::PwmPid { channel } => {
channels.channel_state(channel).pid_engaged = true;
leds.g3.on();
send_line(&mut socket, b"{}");
}
Command::Pwm { channel, pin, value } => {
match pin {
PwmPin::ISet => {
channels.channel_state(channel).pid_engaged = false;
leds.g3.off();
let current = ElectricCurrent::new::<ampere>(value);
channels.set_i(channel, current);
channels.power_up(channel);
}
PwmPin::MaxV => {
let voltage = ElectricPotential::new::<volt>(value);
channels.set_max_v(channel, voltage);
}
PwmPin::MaxIPos => {
let current = ElectricCurrent::new::<ampere>(value);
channels.set_max_i_pos(channel, current);
}
PwmPin::MaxINeg => {
let current = ElectricCurrent::new::<ampere>(value);
channels.set_max_i_neg(channel, current);
}
}
send_line(&mut socket, b"{}");
}
Command::CenterPoint { channel, center } => {
let i_tec = channels.get_i(channel);
let state = channels.channel_state(channel);
state.center = center;
if !state.pid_engaged {
channels.set_i(channel, i_tec);
}
send_line(&mut socket, b"{}");
}
Command::Pid { channel, parameter, value } => {
let pid = &mut channels.channel_state(channel).pid;
use command_parser::PidParameter::*;
match parameter {
Target =>
pid.target = value,
KP =>
pid.parameters.kp = value as f32,
KI =>
pid.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,
IntegralMin =>
pid.parameters.integral_min = value as f32,
IntegralMax =>
pid.parameters.integral_max = value as f32,
}
send_line(&mut socket, b"{}");
}
Command::SteinhartHart { channel, parameter, value } => {
let sh = &mut channels.channel_state(channel).sh;
use command_parser::ShParameter::*;
match parameter {
T0 => sh.t0 = ThermodynamicTemperature::new::<degree_celsius>(value),
B => sh.b = value,
R0 => sh.r0 = ElectricalResistance::new::<ohm>(value),
}
send_line(&mut socket, b"{}");
}
Command::PostFilter { channel, rate: None } => {
channels.adc.set_postfilter(channel as u8, None).unwrap();
send_line(&mut socket, b"{}");
}
Command::PostFilter { channel, rate: Some(rate) } => {
let filter = ad7172::PostFilter::closest(rate);
match filter {
Some(filter) => {
channels.adc.set_postfilter(channel as u8, Some(filter)).unwrap();
send_line(&mut socket, b"{}");
}
None => {
error!("unable to choose postfilter for rate {:.3}", rate);
send_line(&mut socket, b"{{\"error\": \"unable to choose postfilter rate\"}}");
}
}
}
Command::Load { channel } => {
for c in 0..CHANNELS {
if channel.is_none() || channel == Some(c) {
match store.read_value::<ChannelConfig>(CHANNEL_CONFIG_KEY[c]) {
Ok(Some(config)) => {
config.apply(&mut channels, c);
send_line(&mut socket, b"{}");
}
Ok(None) => {
error!("flash config not found");
send_line(&mut socket, b"{{\"error\": \"flash config not found\"}}");
}
Err(e) => {
error!("unable to load config from flash: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
}
}
}
}
}
Command::Save { channel } => {
for c in 0..CHANNELS {
if channel.is_none() || channel == Some(c) {
let config = ChannelConfig::new(&mut channels, c);
match store.write_value(CHANNEL_CONFIG_KEY[c], &config, &mut store_value_buf) {
Ok(()) => {
send_line(&mut socket, b"{}");
}
Err(e) => {
error!("unable to save channel {} config to flash: {:?}", c, e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
}
}
}
}
}
Command::Ipv4(config) => {
let _ = store
.write_value("ipv4", &config, [0; 16])
.map_err(|e| error!("unable to save ipv4 config to flash: {:?}", e));
new_ipv4_config = Some(config);
send_line(&mut socket, b"{}");
}
Command::Reset => {
for i in 0..CHANNELS {
channels.power_down(i);
}
should_reset = true;
}
Command::Dfu => {
for i in 0..CHANNELS {
channels.power_down(i);
}
unsafe {
dfu::set_dfu_trigger();
}
should_reset = true;
}
}
Ok(SessionInput::Error(e)) => {
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();
} }
}); }
} 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 // Apply new IPv4 address/gateway
new_ipv4_config.take() if let Some(config) = new_ipv4_config.take() {
.map(|config| {
server.set_ipv4_config(config.clone()); server.set_ipv4_config(config.clone());
ipv4_config = config; 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();
// 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!()
} }

53
src/net.rs
View File

@ -1,20 +1,17 @@
//! 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 core::cell::RefCell;
use cortex_m::interrupt::{CriticalSection, Mutex};
use stm32f4xx_hal::{
rcc::Clocks,
stm32::{interrupt, Peripherals, ETHERNET_MAC, ETHERNET_DMA},
};
use smoltcp::wire::{EthernetAddress, Ipv4Address, Ipv4Cidr};
use smoltcp::iface::{
EthernetInterfaceBuilder, EthernetInterface,
NeighborCache, Routes,
};
use stm32_eth::{Eth, RingEntry, PhyAddress, RxDescriptor, TxDescriptor};
use crate::command_parser::Ipv4Config; use crate::command_parser::Ipv4Config;
use crate::pins::EthernetPins; use crate::pins::EthernetPins;
use core::cell::RefCell;
use cortex_m::interrupt::{CriticalSection, Mutex};
use smoltcp::iface::{EthernetInterface, EthernetInterfaceBuilder, NeighborCache, Routes};
use smoltcp::wire::{EthernetAddress, Ipv4Address, Ipv4Cidr};
use stm32_eth::{Eth, RingEntry, RxDescriptor, TxDescriptor};
use stm32f4xx_hal::{
pac::{interrupt, Peripherals, ETHERNET_DMA, ETHERNET_MAC},
rcc::Clocks,
};
/// 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)
@ -30,28 +27,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_dma: ETHERNET_DMA, ethernet_mac: ETHERNET_MAC,
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 { let rx_ring = unsafe { RX_RING.get_or_insert(Default::default()) };
RX_RING.get_or_insert(Default::default()) let tx_ring = unsafe { TX_RING.get_or_insert(Default::default()) };
};
let tx_ring = unsafe {
TX_RING.get_or_insert(Default::default())
};
// Ethernet driver // Ethernet driver
let mut eth_dev = Eth::new( let mut eth_dev = Eth::new(
ethernet_mac, ethernet_dma, ethernet_mac,
&mut rx_ring[..], &mut tx_ring[..], ethernet_dma,
PhyAddress::_0, &mut rx_ring[..],
&mut tx_ring[..],
clocks, clocks,
eth_pins, eth_pins,
).unwrap(); )
.unwrap();
eth_dev.enable_interrupt(); eth_dev.enable_interrupt();
// IP stack // IP stack
@ -77,8 +73,7 @@ pub fn run<F>(
#[interrupt] #[interrupt]
fn ETH() { fn ETH() {
cortex_m::interrupt::free(|cs| { cortex_m::interrupt::free(|cs| {
*NET_PENDING.borrow(cs) *NET_PENDING.borrow(cs).borrow_mut() = true;
.borrow_mut() = true;
}); });
let p = unsafe { Peripherals::steal() }; let p = unsafe { Peripherals::steal() };
@ -87,15 +82,13 @@ 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) *NET_PENDING.borrow(cs).borrow()
.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) *NET_PENDING.borrow(cs).borrow_mut() = false;
.borrow_mut() = false;
} }
/// utility for destructuring into smoltcp types /// utility for destructuring into smoltcp types

122
src/pid.rs
View File

@ -1,12 +1,4 @@
use serde::{Serialize, Deserialize}; use serde::{Deserialize, Serialize};
use uom::si::{
f64::{Time, ElectricCurrent},
time::second,
electric_current::ampere,
};
/// Allowable current error for integral accumulation
const CURRENT_ERROR_MAX: f64 = 0.1;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Parameters { pub struct Parameters {
@ -20,10 +12,6 @@ pub struct Parameters {
pub output_min: f32, pub output_min: f32,
/// Output limit maximum /// Output limit maximum
pub output_max: f32, pub output_max: f32,
/// Integral clipping minimum
pub integral_min: f32,
/// Integral clipping maximum
pub integral_max: f32
} }
impl Default for Parameters { impl Default for Parameters {
@ -34,8 +22,6 @@ impl Default for Parameters {
kd: 0.0, kd: 0.0,
output_min: -2.0, output_min: -2.0,
output_max: 2.0, output_max: 2.0,
integral_min: -10.0,
integral_max: 10.0,
} }
} }
} }
@ -44,68 +30,46 @@ impl Default for Parameters {
pub struct Controller { pub struct Controller {
pub parameters: Parameters, pub parameters: Parameters,
pub target: f64, pub target: f64,
integral: f64, u1: f64,
last_input: Option<f64>, x1: f64,
pub last_output: Option<f64>, x2: f64,
pub y1: f64,
} }
impl Controller { 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,
last_input: None, u1: 0.0,
integral: 0.0, x1: 0.0,
last_output: None, x2: 0.0,
y1: 0.0,
} }
} }
pub fn update(&mut self, input: f64, time_delta: Time, current: ElectricCurrent) -> f64 { // Based on https://hackmd.io/IACbwcOTSt6Adj3_F9bKuw PID implementation
let time_delta = time_delta.get::<second>(); // Input x(t), target u(t), output y(t)
// y0' = y1 - ki * u0
// error // + x0 * (kp + ki + kd)
let error = self.target - input; // - x1 * (kp + 2kd)
// + x2 * kd
// proportional // y0 = clip(y0', ymin, ymax)
let p = f64::from(self.parameters.kp) * error; pub fn update(&mut self, input: f64) -> f64 {
let mut output: f64 = self.y1 - self.target * f64::from(self.parameters.ki)
// integral + input * f64::from(self.parameters.kp + self.parameters.ki + self.parameters.kd)
if let Some(last_output_val) = self.last_output { - self.x1 * f64::from(self.parameters.kp + 2.0 * self.parameters.kd)
let electric_current_error = ElectricCurrent::new::<ampere>(last_output_val) - current; + self.x2 * f64::from(self.parameters.kd);
// anti integral windup
if last_output_val < self.parameters.output_max.into() &&
last_output_val > self.parameters.output_min.into() &&
electric_current_error < ElectricCurrent::new::<ampere>(CURRENT_ERROR_MAX) &&
electric_current_error > -ElectricCurrent::new::<ampere>(CURRENT_ERROR_MAX) {
self.integral += error * time_delta;
}
}
if self.integral < self.parameters.integral_min.into() {
self.integral = self.parameters.integral_min.into();
}
if self.integral > self.parameters.integral_max.into() {
self.integral = self.parameters.integral_max.into();
}
let i = self.integral * f64::from(self.parameters.ki);
// derivative
let d = match self.last_input {
None =>
0.0,
Some(last_input) =>
f64::from(self.parameters.kd) * (last_input - input) / time_delta,
};
self.last_input = Some(input);
// output
let mut output = p + i + d;
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();
} }
if output > self.parameters.output_max.into() { if output > self.parameters.output_max.into() {
output = self.parameters.output_max.into(); output = self.parameters.output_max.into();
} }
self.last_output = Some(output); self.x2 = self.x1;
self.x1 = input;
self.u1 = self.target;
self.y1 = output;
output output
} }
@ -114,17 +78,10 @@ impl Controller {
channel, channel,
parameters: self.parameters.clone(), parameters: self.parameters.clone(),
target: self.target, target: self.target,
integral: self.integral,
} }
} }
pub fn update_ki(&mut self, new_ki: f32) { pub fn update_ki(&mut self, new_ki: f32) {
if new_ki == 0.0 {
self.integral = 0.0;
} else {
// Rescale integral with changes to kI, aka "Bumpless operation"
self.integral = f64::from(self.parameters.ki) * self.integral / f64::from(new_ki);
}
self.parameters.ki = new_ki; self.parameters.ki = new_ki;
} }
} }
@ -134,7 +91,6 @@ pub struct Summary {
channel: usize, channel: usize,
parameters: Parameters, parameters: Parameters,
target: f64, target: f64,
integral: f64,
} }
#[cfg(test)] #[cfg(test)]
@ -147,24 +103,22 @@ mod test {
kd: 0.15, kd: 0.15,
output_min: -10.0, output_min: -10.0,
output_max: 10.0, output_max: 10.0,
integral_min: -1000.0,
integral_max: 1000.0,
}; };
#[test] #[test]
fn test_controller() { fn test_controller() {
// Initial and ambient temperature // Initial and ambient temperature
const DEFAULT: f64 = 20.0; const DEFAULT: f64 = 20.0;
// Target temperature // Target temperature
const TARGET: f64 = 40.0; const TARGET: f64 = 40.0;
// Control tolerance // Control tolerance
const ERROR: f64 = 0.01; const ERROR: f64 = 0.01;
// System response delay // System response delay
const DELAY: usize = 10; const DELAY: usize = 10;
// Heat lost // Heat lost
const LOSS: f64 = 0.05; const LOSS: f64 = 0.05;
// Limit simulation cycle, reaching this limit before settling fails test // Limit simulation cycle, reaching this limit before settling fails test
const CYCLE_LIMIT: u32 = 1000; const CYCLE_LIMIT: u32 = 1000;
let mut pid = Controller::new(PARAMETERS.clone()); let mut pid = Controller::new(PARAMETERS.clone());
pid.target = TARGET; pid.target = TARGET;
@ -177,9 +131,9 @@ mod test {
while !values.iter().all(|value| target.contains(value)) && total_t < CYCLE_LIMIT { while !values.iter().all(|value| target.contains(value)) && total_t < CYCLE_LIMIT {
let next_t = (t + 1) % DELAY; let next_t = (t + 1) % DELAY;
// Feed the oldest temperature // Feed the oldest temperature
output = pid.update(values[next_t], Time::new::<second>(1.0), ElectricCurrent::new::<ampere>(output)); output = pid.update(values[next_t]);
// Overwrite oldest with previous temperature - output // Overwrite oldest with previous temperature - output
values[next_t] = values[t] + output - (values[t] - DEFAULT) * LOSS; values[next_t] = values[t] - output - (values[t] - DEFAULT) * LOSS;
t = next_t; t = next_t;
total_t += 1; total_t += 1;
println!("{}", values[t].to_string()); println!("{}", values[t].to_string());

302
src/pins.rs
View File

@ -1,95 +1,106 @@
use crate::{
channel::{Channel0, Channel1},
fan_ctrl::FanPin,
hw_rev::{HWRev, HWSettings},
leds::Leds,
};
use eeprom24x::{self, Eeprom24x};
use stm32_eth::EthPins;
use stm32f4xx_hal::{ use stm32f4xx_hal::{
adc::Adc, adc::Adc,
gpio::{ gpio::{
AF5, Alternate, AlternateOD, Analog, Floating, Input, gpioa::*, gpiob::*, gpioc::*, gpioe::*, gpiof::*, gpiog::*, Alternate, AlternateOD, Analog,
gpioa::*, Floating, GpioExt, Input, Output, PushPull, AF5,
gpiob::*,
gpioc::*,
gpioe::*,
gpiof::*,
gpiog::*,
GpioExt,
Output, PushPull,
}, },
hal::{self, blocking::spi::Transfer, digital::v2::OutputPin}, hal::{self, blocking::spi::Transfer, digital::v2::OutputPin},
i2c::I2c, i2c::I2c,
otg_fs::USB, otg_fs::USB,
rcc::Clocks, pac::{
pwm::{self, PwmChannels}, ADC1, GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, GPIOF, GPIOG, I2C1, OTG_FS_DEVICE, OTG_FS_GLOBAL,
spi::{Spi, NoMiso}, OTG_FS_PWRCLK, SPI2, SPI4, SPI5, TIM1, TIM3, TIM8,
stm32::{
ADC1,
GPIOA, GPIOB, GPIOC, GPIOD, GPIOE, GPIOF, GPIOG,
I2C1,
OTG_FS_GLOBAL, OTG_FS_DEVICE, OTG_FS_PWRCLK,
SPI2, SPI4, SPI5,
TIM1, TIM3,
}, },
pwm::{self, PwmChannels},
rcc::Clocks,
spi::{NoMiso, Spi, TransferModeNormal},
time::U32Ext, time::U32Ext,
}; timer::Timer,
use eeprom24x::{self, Eeprom24x};
use stm32_eth::EthPins;
use crate::{
channel::{Channel0, Channel1},
leds::Leds,
}; };
pub type Eeprom = Eeprom24x< pub type Eeprom = Eeprom24x<
I2c<I2C1, ( I2c<
PB8<AlternateOD<stm32f4xx_hal::gpio::AF4>>, I2C1,
PB9<AlternateOD<stm32f4xx_hal::gpio::AF4>> (
)>, PB8<AlternateOD<{ stm32f4xx_hal::gpio::AF4 }>>,
PB9<AlternateOD<{ stm32f4xx_hal::gpio::AF4 }>>,
),
>,
eeprom24x::page_size::B8, eeprom24x::page_size::B8,
eeprom24x::addr_size::OneByte eeprom24x::addr_size::OneByte,
>; >;
pub type EthernetPins = EthPins< pub type EthernetPins = EthPins<
PA1<Input<Floating>>, PA1<Input<Floating>>,
PA2<Input<Floating>>,
PC1<Input<Floating>>,
PA7<Input<Floating>>, PA7<Input<Floating>>,
PB11<Input<Floating>>, PB11<Input<Floating>>,
PG13<Input<Floating>>, PG13<Input<Floating>>,
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 = PA0<Analog>; type VRefPin = Channel0VRef;
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 = PA3<Analog>; type VRefPin = Channel1VRef;
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<SPI2, (PB10<Alternate<AF5>>, PB14<Alternate<AF5>>, PB15<Alternate<AF5>>)>; pub type AdcSpi = Spi<
SPI2,
(
PB10<Alternate<AF5>>,
PB14<Alternate<AF5>>,
PB15<Alternate<AF5>>,
),
TransferModeNormal,
>;
pub type AdcNss = PB12<Output<PushPull>>; pub type AdcNss = PB12<Output<PushPull>>;
type Dac0Spi = Spi<SPI4, (PE2<Alternate<AF5>>, NoMiso, PE6<Alternate<AF5>>)>; type Dac0Spi = Spi<SPI4, (PE2<Alternate<AF5>>, NoMiso, PE6<Alternate<AF5>>), TransferModeNormal>;
type Dac1Spi = Spi<SPI5, (PF7<Alternate<AF5>>, NoMiso, PF9<Alternate<AF5>>)>; type Dac1Spi = Spi<SPI5, (PF7<Alternate<AF5>>, NoMiso, PF9<Alternate<AF5>>), TransferModeNormal>;
pub type PinsAdc = Adc<ADC1>; pub type PinsAdc = Adc<ADC1>;
pub struct ChannelPinSet<C: ChannelPins> { pub struct ChannelPinSet<C: ChannelPins> {
@ -97,11 +108,18 @@ 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,
} }
pub struct HWRevPins {
pub hwrev0: stm32f4xx_hal::gpio::gpiod::PD0<Input<Floating>>,
pub hwrev1: stm32f4xx_hal::gpio::gpiod::PD1<Input<Floating>>,
pub hwrev2: stm32f4xx_hal::gpio::gpiod::PD2<Input<Floating>>,
pub hwrev3: stm32f4xx_hal::gpio::gpiod::PD3<Input<Floating>>,
}
pub struct Pins { pub struct Pins {
pub adc_spi: AdcSpi, pub adc_spi: AdcSpi,
pub adc_nss: AdcNss, pub adc_nss: AdcNss,
@ -115,13 +133,34 @@ 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: TIM1, tim3: TIM3, (tim1, tim3, tim8): (TIM1, TIM3, TIM8),
gpioa: GPIOA, gpiob: GPIOB, gpioc: GPIOC, gpiod: GPIOD, gpioe: GPIOE, gpiof: GPIOF, gpiog: GPIOG, (gpioa, gpiob, gpioc, gpiod, gpioe, gpiof, gpiog): (
GPIOA,
GPIOB,
GPIOC,
GPIOD,
GPIOE,
GPIOF,
GPIOG,
),
i2c1: I2C1, i2c1: I2C1,
spi2: SPI2, spi4: SPI4, spi5: SPI5, (spi2, spi4, spi5): (SPI2, SPI4, SPI5),
adc1: ADC1, adc1: ADC1,
otg_fs_global: OTG_FS_GLOBAL, otg_fs_device: OTG_FS_DEVICE, otg_fs_pwrclk: OTG_FS_PWRCLK, (otg_fs_global, otg_fs_device, otg_fs_pwrclk): (
) -> (Self, Leds, Eeprom, EthernetPins, USB) { OTG_FS_GLOBAL,
OTG_FS_DEVICE,
OTG_FS_PWRCLK,
),
) -> (
Self,
Leds,
Eeprom,
EthernetPins,
USB,
Option<FanPin>,
HWRev,
HWSettings,
) {
let gpioa = gpioa.split(); let gpioa = gpioa.split();
let gpiob = gpiob.split(); let gpiob = gpiob.split();
let gpioc = gpioc.split(); let gpioc = gpioc.split();
@ -136,19 +175,29 @@ 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, tim1, tim3, clocks,
gpioc.pc6, gpioc.pc7, (tim1, tim3),
gpioe.pe9, gpioe.pe11, (gpioc.pc6, gpioc.pc7),
gpioe.pe13, gpioe.pe14 (gpioe.pe9, gpioe.pe11),
(gpioe.pe13, gpioe.pe14),
); );
let (dac0_spi, dac0_sync) = Self::setup_dac0( let hwrev = HWRev::detect_hw_rev(&HWRevPins {
clocks, spi4, hwrev0: gpiod.pd0,
gpioe.pe2, gpioe.pe4, gpioe.pe6 hwrev1: gpiod.pd1,
); hwrev2: gpiod.pd2,
hwrev3: gpiod.pd3,
});
let hw_settings = hwrev.settings();
let (dac0_spi, dac0_sync) = Self::setup_dac0(clocks, spi4, gpioe.pe2, gpioe.pe4, gpioe.pe6);
let mut shdn0 = gpioe.pe10.into_push_pull_output(); let mut shdn0 = gpioe.pe10.into_push_pull_output();
let _ = shdn0.set_low(); shdn0.set_low();
let vref0_pin = gpioa.pa0.into_analog(); let vref0_pin = if hwrev.major > 2 {
Channel0VRef::Analog(gpioa.pa0.into_analog())
} else {
Channel0VRef::Disabled(gpioa.pa0)
};
let itec0_pin = gpioa.pa6.into_analog(); let 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();
@ -162,13 +211,14 @@ 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( let (dac1_spi, dac1_sync) = Self::setup_dac1(clocks, spi5, gpiof.pf7, gpiof.pf6, gpiof.pf9);
clocks, spi5,
gpiof.pf7, gpiof.pf6, gpiof.pf9
);
let mut shdn1 = gpioe.pe15.into_push_pull_output(); let mut shdn1 = gpioe.pe15.into_push_pull_output();
let _ = shdn1.set_low(); shdn1.set_low();
let vref1_pin = gpioa.pa3.into_analog(); let vref1_pin = if hwrev.major > 2 {
Channel1VRef::Analog(gpioa.pa3.into_analog())
} else {
Channel1VRef::Disabled(gpioa.pa3)
};
let itec1_pin = gpiob.pb0.into_analog(); let 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();
@ -183,24 +233,27 @@ impl Pins {
}; };
let pins = Pins { let pins = Pins {
adc_spi, adc_nss, adc_spi,
adc_nss,
pins_adc, pins_adc,
pwm, pwm,
channel0, channel0,
channel1, channel1,
}; };
let leds = Leds::new(gpiod.pd9, gpiod.pd10.into_push_pull_output(), gpiod.pd11.into_push_pull_output()); let leds = Leds::new(
gpiod.pd9,
gpiod.pd10.into_push_pull_output(),
gpiod.pd11.into_push_pull_output(),
);
let eeprom_scl = gpiob.pb8.into_alternate_af4().set_open_drain(); let eeprom_scl = gpiob.pb8.into_alternate().set_open_drain();
let eeprom_sda = gpiob.pb9.into_alternate_af4().set_open_drain(); let eeprom_sda = gpiob.pb9.into_alternate().set_open_drain();
let eeprom_i2c = I2c::i2c1(i2c1, (eeprom_scl, eeprom_sda), 400.khz(), clocks); let eeprom_i2c = I2c::new(i2c1, (eeprom_scl, eeprom_sda), 400.khz(), clocks);
let eeprom = Eeprom24x::new_24x02(eeprom_i2c, eeprom24x::SlaveAddr::default()); let eeprom = Eeprom24x::new_24x02(eeprom_i2c, eeprom24x::SlaveAddr::default());
let eth_pins = EthPins { let eth_pins = EthPins {
ref_clk: gpioa.pa1, ref_clk: gpioa.pa1,
md_io: gpioa.pa2,
md_clk: gpioc.pc1,
crs: gpioa.pa7, crs: gpioa.pa7,
tx_en: gpiob.pb11, tx_en: gpiob.pb11,
tx_d0: gpiog.pg13, tx_d0: gpiog.pg13,
@ -213,12 +266,21 @@ impl Pins {
usb_global: otg_fs_global, usb_global: otg_fs_global,
usb_device: otg_fs_device, usb_device: otg_fs_device,
usb_pwrclk: otg_fs_pwrclk, usb_pwrclk: otg_fs_pwrclk,
pin_dm: gpioa.pa11.into_alternate_af10(), pin_dm: gpioa.pa11.into_alternate(),
pin_dp: gpioa.pa12.into_alternate_af10(), pin_dp: gpioa.pa12.into_alternate(),
hclk: clocks.hclk(), hclk: clocks.hclk(),
}; };
(pins, leds, eeprom, eth_pins, usb) let fan = if hw_settings.fan_available {
Some(
Timer::new(tim8, &clocks)
.pwm(gpioc.pc9.into_alternate(), hw_settings.fan_pwm_freq_hz.hz()),
)
} else {
None
};
(pins, leds, eeprom, eth_pins, usb, fan, hwrev, hw_settings)
} }
/// Configure the GPIO pins for SPI operation, and initialize SPI /// Configure the GPIO pins for SPI operation, and initialize SPI
@ -228,32 +290,34 @@ 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_af5(); let miso = miso.into_alternate();
let miso = miso.into_alternate_af5(); let mosi = mosi.into_alternate();
let mosi = mosi.into_alternate_af5(); Spi::new(
Spi::spi2(
spi2, spi2,
(sck, miso, mosi), (sck, miso, mosi),
crate::ad7172::SPI_MODE, crate::ad7172::SPI_MODE,
crate::ad7172::SPI_CLOCK.into(), crate::ad7172::SPI_CLOCK,
clocks clocks,
) )
} }
fn setup_dac0<M1, M2, M3>( fn setup_dac0<M1, M2, M3>(
clocks: Clocks, spi4: SPI4, clocks: Clocks,
sclk: PE2<M1>, sync: PE4<M2>, sdin: PE6<M3> spi4: SPI4,
sclk: PE2<M1>,
sync: PE4<M2>,
sdin: PE6<M3>,
) -> (Dac0Spi, <Channel0 as ChannelPins>::DacSync) { ) -> (Dac0Spi, <Channel0 as ChannelPins>::DacSync) {
let sclk = sclk.into_alternate_af5(); let sclk = sclk.into_alternate();
let sdin = sdin.into_alternate_af5(); let sdin = sdin.into_alternate();
let spi = Spi::spi4( let spi = Spi::new(
spi4, spi4,
(sclk, NoMiso, sdin), (sclk, NoMiso {}, sdin),
crate::ad5680::SPI_MODE, crate::ad5680::SPI_MODE,
crate::ad5680::SPI_CLOCK.into(), crate::ad5680::SPI_CLOCK,
clocks clocks,
); );
let sync = sync.into_push_pull_output(); let sync = sync.into_push_pull_output();
@ -261,17 +325,20 @@ impl Pins {
} }
fn setup_dac1<M1, M2, M3>( fn setup_dac1<M1, M2, M3>(
clocks: Clocks, spi5: SPI5, clocks: Clocks,
sclk: PF7<M1>, sync: PF6<M2>, sdin: PF9<M3> spi5: SPI5,
sclk: PF7<M1>,
sync: PF6<M2>,
sdin: PF9<M3>,
) -> (Dac1Spi, <Channel1 as ChannelPins>::DacSync) { ) -> (Dac1Spi, <Channel1 as ChannelPins>::DacSync) {
let sclk = sclk.into_alternate_af5(); let sclk = sclk.into_alternate();
let sdin = sdin.into_alternate_af5(); let sdin = sdin.into_alternate();
let spi = Spi::spi5( let spi = Spi::new(
spi5, spi5,
(sclk, NoMiso, sdin), (sclk, NoMiso {}, sdin),
crate::ad5680::SPI_MODE, crate::ad5680::SPI_MODE,
crate::ad5680::SPI_CLOCK.into(), crate::ad5680::SPI_CLOCK,
clocks clocks,
); );
let sync = sync.into_push_pull_output(); let sync = sync.into_push_pull_output();
@ -291,46 +358,43 @@ 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: TIM1, (tim1, tim3): (TIM1, TIM3),
tim3: TIM3, (max_v0, max_v1): (PC6<M1>, PC7<M2>),
max_v0: PC6<M1>, (max_i_pos0, max_i_pos1): (PE9<M3>, PE11<M4>),
max_v1: PC7<M2>, (max_i_neg0, max_i_neg1): (PE13<M5>, PE14<M6>),
max_i_pos0: PE9<M3>,
max_i_pos1: PE11<M4>,
max_i_neg0: PE13<M5>,
max_i_neg1: PE14<M6>,
) -> PwmPins { ) -> 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 = ( let channels = (max_v0.into_alternate(), max_v1.into_alternate());
max_v0.into_alternate_af2(), //let (mut max_v0, mut max_v1) = pwm::tim3(tim3, channels, clocks, freq);
max_v1.into_alternate_af2(), let (mut max_v0, mut max_v1) = Timer::new(tim3, &clocks).pwm(channels, freq);
);
let (mut max_v0, mut max_v1) = pwm::tim3(tim3, channels, clocks, freq);
init_pwm_pin(&mut max_v0); init_pwm_pin(&mut max_v0);
init_pwm_pin(&mut max_v1); init_pwm_pin(&mut max_v1);
let channels = ( let channels = (
max_i_pos0.into_alternate_af1(), max_i_pos0.into_alternate(),
max_i_pos1.into_alternate_af1(), max_i_pos1.into_alternate(),
max_i_neg0.into_alternate_af1(), max_i_neg0.into_alternate(),
max_i_neg1.into_alternate_af1(), max_i_neg1.into_alternate(),
); );
let (mut max_i_pos0, mut max_i_pos1, mut max_i_neg0, mut max_i_neg1) = let (mut max_i_pos0, mut max_i_pos1, mut max_i_neg0, mut max_i_neg1) =
pwm::tim1(tim1, channels, clocks, freq); Timer::new(tim1, &clocks).pwm(channels, freq);
init_pwm_pin(&mut max_i_pos0); init_pwm_pin(&mut max_i_pos0);
init_pwm_pin(&mut max_i_neg0); init_pwm_pin(&mut max_i_neg0);
init_pwm_pin(&mut max_i_pos1); init_pwm_pin(&mut max_i_pos1);
init_pwm_pin(&mut max_i_neg1); init_pwm_pin(&mut max_i_neg1);
PwmPins { PwmPins {
max_v0, max_v1, max_v0,
max_i_pos0, max_i_pos1, max_v1,
max_i_neg0, max_i_neg1, max_i_pos0,
max_i_pos1,
max_i_neg0,
max_i_neg1,
} }
} }
} }

84
src/server.rs
View File

@ -1,18 +1,33 @@
use core::mem::MaybeUninit; use crate::command_parser::Ipv4Config;
use crate::net::split_ipv4_config;
use smoltcp::{ use smoltcp::{
iface::EthernetInterface, iface::EthernetInterface,
socket::{SocketSet, SocketHandle, TcpSocket, TcpSocketBuffer, SocketRef}, socket::{SocketHandle, SocketRef, SocketSet, TcpSocket, TcpSocketBuffer},
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> {
fn new(
sockets: &mut SocketSet<'a>,
tcp_rx_storage: &'a mut [u8; TCP_RX_BUFFER_SIZE],
tcp_tx_storage: &'a mut [u8; TCP_TX_BUFFER_SIZE],
) -> SocketState<S> {
let tcp_rx_buffer = TcpSocketBuffer::new(&mut tcp_rx_storage[..]);
let tcp_tx_buffer = TcpSocketBuffer::new(&mut tcp_tx_storage[..]);
let tcp_socket = TcpSocket::new(tcp_rx_buffer, tcp_tx_buffer);
SocketState::<S> {
handle: sockets.add(tcp_socket),
state: S::default(),
}
}
}
/// Number of server sockets and therefore concurrent client /// Number of server sockets and therefore concurrent client
/// sessions. Many data structures in `Server::run()` correspond to /// sessions. Many data structures in `Server::run()` correspond to
/// this const. /// this const.
@ -24,39 +39,38 @@ const TCP_TX_BUFFER_SIZE: usize = 2048;
/// Contains a number of server sockets that get all sent the same /// Contains a number of server sockets that get all sent the same
/// data (through `fmt::Write`). /// data (through `fmt::Write`).
pub struct Server<'a, 'b, S> { pub struct Server<'a, 'b, S> {
net: EthernetInterface<'a, 'a, 'a, &'a mut stm32_eth::Eth<'static, 'static>>, net: EthernetInterface<'a, &'a mut stm32_eth::Eth<'static, 'static>>,
sockets: SocketSet<'b, 'b, 'b>, sockets: SocketSet<'b>,
states: [SocketState<S>; SOCKET_COUNT], states: [SocketState<S>; SOCKET_COUNT],
} }
impl<'a, 'b, S: Default> Server<'a, 'b, S> { impl<'a, 'b, S: Default> Server<'a, 'b, S> {
/// Run a server with stack-allocated sockets /// Run a server with stack-allocated sockets
pub fn run<F>(net: EthernetInterface<'a, 'a, 'a, &'a mut stm32_eth::Eth<'static, 'static>>, f: F) pub fn run<F>(net: EthernetInterface<'a, &'a mut stm32_eth::Eth<'static, 'static>>, f: F)
where where
F: FnOnce(&mut Server<'a, '_, S>), F: FnOnce(&mut Server<'a, '_, S>),
{ {
let mut sockets_storage: [_; SOCKET_COUNT] = Default::default(); macro_rules! create_rtx_storage {
let mut sockets = SocketSet::new(&mut sockets_storage[..]); ($rx_storage:ident, $tx_storage:ident) => {
let mut states: [SocketState<S>; SOCKET_COUNT] = unsafe { MaybeUninit::uninit().assume_init() };
macro_rules! create_socket {
($set:ident, $rx_storage:ident, $tx_storage:ident, $target:expr) => {
let mut $rx_storage = [0; TCP_RX_BUFFER_SIZE]; let mut $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];
let tcp_rx_buffer = TcpSocketBuffer::new(&mut $rx_storage[..]); };
let tcp_tx_buffer = TcpSocketBuffer::new(&mut $tx_storage[..]);
let tcp_socket = TcpSocket::new(tcp_rx_buffer, tcp_tx_buffer);
$target = $set.add(tcp_socket);
}
} }
create_socket!(sockets, tcp_rx_storage0, tcp_tx_storage0, states[0].handle);
create_socket!(sockets, tcp_rx_storage1, tcp_tx_storage1, states[1].handle);
create_socket!(sockets, tcp_rx_storage2, tcp_tx_storage2, states[2].handle);
create_socket!(sockets, tcp_rx_storage3, tcp_tx_storage3, states[3].handle);
for state in &mut states { create_rtx_storage!(tcp_rx_storage0, tcp_tx_storage0);
state.state = S::default(); create_rtx_storage!(tcp_rx_storage1, tcp_tx_storage1);
} create_rtx_storage!(tcp_rx_storage2, tcp_tx_storage2);
create_rtx_storage!(tcp_rx_storage3, tcp_tx_storage3);
let mut sockets_storage: [_; SOCKET_COUNT] = Default::default();
let mut sockets = SocketSet::new(&mut sockets_storage[..]);
let states: [SocketState<S>; SOCKET_COUNT] = [
SocketState::<S>::new(&mut sockets, &mut tcp_rx_storage0, &mut tcp_tx_storage0),
SocketState::<S>::new(&mut sockets, &mut tcp_rx_storage1, &mut tcp_tx_storage1),
SocketState::<S>::new(&mut sockets, &mut tcp_rx_storage2, &mut tcp_tx_storage2),
SocketState::<S>::new(&mut sockets, &mut tcp_rx_storage3, &mut tcp_tx_storage3),
];
let mut server = Server { let mut server = Server {
states, states,
@ -89,15 +103,10 @@ 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() {
match addr { if let IpCidr::Ipv4(_) = addr {
IpCidr::Ipv4(_) => { *addr = IpCidr::Ipv4(ipv4_address);
*addr = IpCidr::Ipv4(ipv4_address); // done
// done break;
break
}
_ => {
// skip
}
} }
} }
}); });
@ -106,10 +115,9 @@ 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 => None => routes.update(|routes_storage| {
routes.update(|routes_storage| { routes_storage.remove(&IpCidr::new(IpAddress::v4(0, 0, 0, 0), 0));
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,5 +1,4 @@
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;
@ -46,15 +45,14 @@ 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.map(SessionInput::Command) input
.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 {
@ -67,43 +65,11 @@ 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) {
@ -111,18 +77,9 @@ 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);
match line { if let Some(line) = line {
Some(line) => { let command = Command::parse(line);
let command = Command::parse(&line); return (buf_bytes, command.into());
match command {
Ok(Command::Reporting(reporting)) => {
self.reporting = reporting;
}
_ => {}
}
return (buf_bytes, command.into());
}
None => {}
} }
} }
(buf_bytes, SessionInput::Nothing) (buf_bytes, SessionInput::Nothing)

18
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,
time::U32Ext,
timer::{Timer, Event as TimerEvent},
stm32::SYST, stm32::SYST,
time::U32Ext,
timer::{Event as TimerEvent, Timer},
}; };
/// Rate in Hz /// Rate in Hz
@ -18,26 +18,22 @@ 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 mut timer = Timer::syst(syst, TIMER_RATE.hz(), clocks); let timer = Timer::syst(syst, &clocks);
timer.listen(TimerEvent::TimeOut); let mut countdown = timer.start_count_down(TIMER_RATE.hz());
countdown.listen(TimerEvent::TimeOut);
} }
/// SysTick exception (Timer) /// SysTick exception (Timer)
#[exception] #[exception]
fn SysTick() { fn SysTick() {
cortex_m::interrupt::free(|cs| { cortex_m::interrupt::free(|cs| {
*TIMER_MS.borrow(cs) *TIMER_MS.borrow(cs).borrow_mut() += TIMER_DELTA;
.borrow_mut() += TIMER_DELTA;
}); });
} }
/// Obtain current time in milliseconds /// Obtain current time in milliseconds
pub fn now() -> u32 { pub fn now() -> u32 {
cortex_m::interrupt::free(|cs| { cortex_m::interrupt::free(|cs| *TIMER_MS.borrow(cs).borrow().deref())
*TIMER_MS.borrow(cs)
.borrow()
.deref()
})
} }
/// block for at least `amount` milliseconds /// block for at least `amount` milliseconds

18
src/usb.rs
View File

@ -1,15 +1,18 @@
use core::{fmt::{self, Write}, mem::MaybeUninit}; use core::{
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::{USB, UsbBus as Bus}, otg_fs::{UsbBus as Bus, USB},
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];
@ -36,8 +39,8 @@ impl State {
.device_class(usbd_serial::USB_CLASS_CDC) .device_class(usbd_serial::USB_CLASS_CDC)
.build(); .build();
free(|_| { free(|_| unsafe {
unsafe { STATE = Some(State { serial, dev }); } STATE = Some(State { serial, dev });
}); });
unsafe { unsafe {
@ -94,8 +97,7 @@ 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)) free(|_| state.serial.write(chunk)).map_err(|_| fmt::Error)?;
.map_err(|_| fmt::Error)?;
} }
} }
Ok(()) Ok(())