M-Labs/kirdy
3
0
Fork 1
Code Issues 11 Pull Requests Projects Releases Wiki Activity

Compare commits

base: M-Labs:f22ab430b8d80eb0552cc025d9de0a2242b0496f
Branches Tags
M-Labs:master
..
compare: M-Labs:4132bfacd36a38a3b8b6f410f16cbdc2744372fb
Branches Tags
M-Labs:master

No commits in common. "f22ab430b8d80eb0552cc025d9de0a2242b0496f" and "4132bfacd36a38a3b8b6f410f16cbdc2744372fb" have entirely different histories.
f22ab430b8 ... 4132bfacd3

10 changed files with 275 additions and 536 deletions
Show Stats Expand all files Collapse all files

24
Cargo.lock generated
View File

@ -358,17 +358,6 @@ dependencies = [
"stable_deref_trait",
]
[[package]]
name = "idsp"
version = "0.14.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f255ee573949fb629362d10aa3abd0a97a7c4950a3b8890b435b8c7516cf38f"
dependencies = [
"num-complex 0.4.4",
"num-traits",
"serde",
]
[[package]]
name = "ieee802_3_miim"
version = "0.8.0"
@ -396,7 +385,6 @@ dependencies = [
"cortex-m-rt",
"cortex-m-semihosting 0.5.0",
"fugit",
"idsp",
"ieee802_3_miim",
"log",
"miniconf",
@ -513,7 +501,7 @@ version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b7a8e9be5e039e2ff869df49155f1c06bd01ade2117ec783e56ab0932b67a8f"
dependencies = [
"num-complex 0.3.1",
"num-complex",
"num-integer",
"num-iter",
"num-rational",
@ -529,16 +517,6 @@ dependencies = [
"num-traits",
]
[[package]]
name = "num-complex"
version = "0.4.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ba157ca0885411de85d6ca030ba7e2a83a28636056c7c699b07c8b6f7383214"
dependencies = [
"num-traits",
"serde",
]
[[package]]
name = "num-integer"
version = "0.1.45"

1
Cargo.toml
View File

@ -33,7 +33,6 @@ usbd-serial = "0.1.1"
fugit = "0.3.6"
rtt-target = { version = "0.3.1", features = ["cortex-m"] }
miniconf = "0.9.0"
idsp = "0.14.1"
serde = { version = "1.0.158", features = ["derive"], default-features = false }
sfkv = "0.1"
bit_field = "0.10"

91
eth_cmd_test.py
View File

@ -2,13 +2,12 @@
# Kirdy is written to be controlled via a json object based on miniconf rust crate
# Json Field:
# "rev": hw_rev
# "laser_diode_cmd / thermostat_cmd": Check cmd_handler.rs for the list of cmds
# "laser_diode_cmd": Check cmd_handler.rs for the cmd Enum to control the laser diode
# "data_f32": Optional f32 Data field depending on cmd
# "data_f64": Optional f64 Data field depending on cmd
import socket
import json
import time
# Kirdy IP and Port Number
HOST = "192.168.1.132"
@ -20,92 +19,6 @@ ld_cmd = {
"data_f64": 0.0,
}
tec_power_down = {
"rev": 3,
"thermostat_cmd": "PowerDown",
}
tec_set_sh_t0_cmd = {
"rev": 3,
"thermostat_cmd": "SetShT0",
"data_f64": 25.0,
}
tec_set_sh_r0_cmd = {
"rev": 3,
"thermostat_cmd": "SetShR0",
"data_f64": 10.0 * 1000,
}
tec_set_sh_beta_cmd = {
"rev": 3,
"thermostat_cmd": "SetShBeta",
"data_f64": 3900.0,
}
tec_set_temperature_setpoint_cmd = {
"rev": 3,
"thermostat_cmd": "SetTemperatureSetpoint",
"data_f64": 45.0,
}
tec_set_pid_kp_cmd = {
"rev": 3,
"thermostat_cmd": "SetPidKp",
"data_f64": 1.0,
}
tec_set_pid_ki_cmd = {
"rev": 3,
"thermostat_cmd": "SetPidKi",
"data_f64": 0.01,
}
tec_set_pid_kd_cmd = {
"rev": 3,
"thermostat_cmd": "SetPidKd",
"data_f64": 0.0,
}
tec_set_pid_out_min_cmd = {
"rev": 3,
"thermostat_cmd": "SetPidOutMin",
"data_f64": -1.0,
}
tec_set_pid_out_max_cmd = {
"rev": 3,
"thermostat_cmd": "SetPidOutMax",
"data_f64": 1.0,
}
tec_power_up = {
"rev": 3,
"thermostat_cmd": "PowerUp",
}
# Current version of cmd_handler cannot service multiple cmds in the same eth buffer
delay = 0.25
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.connect((HOST, PORT))
s.send(bytes(json.dumps(tec_power_down), "UTF-8"))
time.sleep(delay)
s.send(bytes(json.dumps(tec_set_sh_t0_cmd), "UTF-8"))
time.sleep(delay)
s.send(bytes(json.dumps(tec_set_sh_r0_cmd), "UTF-8"))
time.sleep(delay)
s.send(bytes(json.dumps(tec_set_sh_beta_cmd), "UTF-8"))
time.sleep(delay)
s.send(bytes(json.dumps(tec_set_temperature_setpoint_cmd), "UTF-8"))
time.sleep(delay)
s.send(bytes(json.dumps(tec_set_pid_kp_cmd), "UTF-8"))
time.sleep(delay)
s.send(bytes(json.dumps(tec_set_pid_ki_cmd), "UTF-8"))
time.sleep(delay)
s.send(bytes(json.dumps(tec_set_pid_kd_cmd), "UTF-8"))
time.sleep(delay)
s.send(bytes(json.dumps(tec_power_up), "UTF-8"))
print("press enter to force thermostat to stop")
input()
s.send(bytes(json.dumps(tec_power_down), "UTF-8"))
s.send(bytes(json.dumps(ld_cmd), "UTF-8"))

20
src/main.rs
View File

@ -7,15 +7,15 @@ use stm32f4xx_hal::pac::{CorePeripherals, Peripherals};
mod device;
mod laser_diode;
mod thermostat;
mod pid;
mod net;
use device::{boot::bootup, log_setup, sys_timer};
use uom::fmt::DisplayStyle::Abbreviation;
use uom::si::electric_potential::volt;
use uom::si::electric_current::{ampere, milliampere};
use uom::si::thermodynamic_temperature::degree_celsius;
use uom::si::power::milliwatt;
use uom::si::f64::{ElectricPotential, ElectricCurrent, Power, ThermodynamicTemperature};
use uom::si::f64::{ElectricPotential, ElectricCurrent, Power};
use serde::{Serialize, Deserialize};
// If RTT is used, print panic info through RTT
@ -31,13 +31,14 @@ fn panic(info: &PanicInfo) -> ! {
#[cfg(all(not(feature = "RTT"), not(test)))]
use panic_halt as _;
use miniconf::{Error, JsonCoreSlash, Tree, TreeKey};
static mut ETH_DATA_BUFFER: [u8; 1024] = [0; 1024];
#[cfg(not(test))]
#[entry]
fn main() -> ! {
log_setup::init_log();
info!("Kirdy init");
@ -82,21 +83,20 @@ fn main() -> ! {
loop {
wd.feed();
let mut eth_is_pending = false;
info!("looping");
info!("curr_ld_drive_cuurent: {:?}", mili_amp_fmt.with(laser.get_ld_drive_current()));
if thermostat.poll_adc_and_update_pid() {
info!("curr_dac_vfb: {:?}", volt_fmt.with(thermostat.get_dac_vfb()));
info!("curr_vref: {:?}", volt_fmt.with(thermostat.get_vref()));
info!("curr_tec_i: {:?}", amp_fmt.with(thermostat.get_tec_i()));
info!("curr_tec_v: {:?}", volt_fmt.with(thermostat.get_tec_v()));
info!("curr_ld_drive_cuurent: {:?}", mili_amp_fmt.with(laser.get_ld_drive_current()));
info!("pd_mon_v: {:?}", volt_fmt.with(laser.pd_mon_status().v));
info!("power_excursion: {:?}", laser.pd_mon_status().pwr_excursion);
info!("Termination Status: {:?}", laser.get_term_status());
}
let mut eth_is_pending = false;
if net::net::eth_is_socket_active() {
cortex_m::interrupt::free(|cs|
@ -112,9 +112,11 @@ fn main() -> ! {
});
let bytes = net::net::eth_recv(&mut ETH_DATA_BUFFER);
debug!("Number of bytes recv: {:?}", bytes);
(laser, thermostat) = net::cmd_handler::execute_cmd(&mut ETH_DATA_BUFFER, bytes, laser, thermostat);
laser = net::cmd_handler::execute_cmd(&mut ETH_DATA_BUFFER, bytes, laser);
}
}
}
sys_timer::sleep(500);
}
}

235
src/net/cmd_handler.rs
View File

@ -1,15 +1,8 @@
use core::fmt::Debug;
use miniconf::{JsonCoreSlash, Tree};
use miniconf::{Error, JsonCoreSlash, Tree, TreeKey};
use serde::{Deserialize, Serialize};
use uom::si::{
electric_current::{ampere, milliampere, ElectricCurrent},
electric_potential::{volt, ElectricPotential},
electrical_resistance::{ElectricalResistance, ohm},
f64::ThermodynamicTemperature, thermodynamic_temperature::degree_celsius
};
use uom::si::electric_current::{milliampere, ElectricCurrent};
use crate::laser_diode::laser_diode::LdDrive;
use crate::thermostat::thermostat::Thermostat;
use crate::thermostat::pid_state::PidSettings::*;
use log::info;
#[derive(Deserialize, Serialize, Copy, Clone, Default, Debug)]
@ -35,40 +28,10 @@ enum LdCmdEnum {
GetAlramStatus,
}
#[derive(Deserialize, Serialize, Copy, Clone, Default, Debug)]
enum ThermostatCmdEnum {
#[default]
Reserved,
PowerUp,
PowerDown,
// TEC
SetTecMaxV,
SetTecMaxIPos,
SetTecMaxINeg,
SetTecIOut, // Constant Current Mode
SetTemperatureSetpoint,
// PID
SetPidKp,
SetPidKi,
SetPidKd,
SetPidOutMin,
SetPidOutMax,
SetPidUpdateInterval, // Update Interval is set based on the sampling rate of ADC
// Steinhart-Hart Equation
SetShT0,
SetShR0,
SetShBeta,
// Report Related
GetTecStatus,
GetPidStatus,
GetShParams,
}
#[derive(Deserialize, Serialize, Copy, Clone, Debug, Default, Tree)]
pub struct CmdJsonObj{
rev: u8,
laser_diode_cmd: Option<LdCmdEnum>,
thermostat_cmd: Option<ThermostatCmdEnum>,
laser_diode_cmd: LdCmdEnum,
data_f32: Option<f32>,
data_f64: Option<f64>,
}
@ -77,29 +40,28 @@ pub struct Cmd {
json: CmdJsonObj
}
pub fn execute_cmd(buffer: &mut [u8], buffer_size: usize, mut laser: LdDrive, mut tec: Thermostat)->(LdDrive, Thermostat){
pub fn execute_cmd(buffer: &mut [u8], buffer_size: usize, mut laser: LdDrive)->(LdDrive){
let mut cmd = Cmd {
json: CmdJsonObj::default()
};
match cmd.set_json("/json", &buffer[0..buffer_size]){
Ok(_) => {
info!("############ Laser Diode Command Received {:?}", cmd.json.laser_diode_cmd);
info!("############ Thermostat Command Received {:?}", cmd.json.thermostat_cmd);
info!("############ Command Received {:?}", cmd.json.laser_diode_cmd);
match cmd.json.laser_diode_cmd {
Some(LdCmdEnum::PowerUp) => {
LdCmdEnum::PowerUp => {
laser.power_up()
}
Some(LdCmdEnum::PowerDown) => {
LdCmdEnum::PowerDown => {
laser.power_down()
}
Some(LdCmdEnum::LdTermsShort) => {
LdCmdEnum::LdTermsShort => {
laser.ld_short();
}
Some(LdCmdEnum::LdTermsOpen) => {
LdCmdEnum::LdTermsOpen => {
laser.ld_open();
}
Some(LdCmdEnum::SetI) => {
LdCmdEnum::SetI => {
match cmd.json.data_f64 {
Some(val) => {
laser.ld_set_i(ElectricCurrent::new::<milliampere>(val));
@ -109,7 +71,7 @@ pub fn execute_cmd(buffer: &mut [u8], buffer_size: usize, mut laser: LdDrive, mu
}
}
}
Some(LdCmdEnum::SetISoftLimit) => {
LdCmdEnum::SetISoftLimit => {
match cmd.json.data_f64 {
Some(val) => {
laser.set_ld_drive_current_limit(ElectricCurrent::new::<milliampere>(val))
@ -119,13 +81,13 @@ pub fn execute_cmd(buffer: &mut [u8], buffer_size: usize, mut laser: LdDrive, mu
}
}
}
Some(LdCmdEnum::SetPdResponsitivity) => {
LdCmdEnum::SetPdResponsitivity => {
info!("Not supported Yet")
}
Some(LdCmdEnum::SetPdDarkCurrent) => {
LdCmdEnum::SetPdDarkCurrent => {
info!("Not supported Yet")
}
Some(LdCmdEnum::SetPdILimit) => {
LdCmdEnum::SetPdILimit => {
match cmd.json.data_f64 {
Some(val) => {
laser.set_pd_i_limit(ElectricCurrent::new::<milliampere>(val))
@ -135,178 +97,21 @@ pub fn execute_cmd(buffer: &mut [u8], buffer_size: usize, mut laser: LdDrive, mu
}
}
}
Some(LdCmdEnum::SetLdPwrLimit) => {
LdCmdEnum::SetLdPwrLimit => {
info!("Not supported Yet")
}
Some(LdCmdEnum::ClearAlarmStatus) => {
LdCmdEnum::ClearAlarmStatus => {
laser.pd_mon_clear_alarm()
}
Some(LdCmdEnum::GetModInTermStatus) => {
LdCmdEnum::GetModInTermStatus => {
info!("Not supported Yet")
}
Some(LdCmdEnum::GetLdStatus) => {
LdCmdEnum::GetLdStatus => {
info!("Not supported Yet")
}
Some(LdCmdEnum::GetAlramStatus) => {
LdCmdEnum::GetAlramStatus => {
info!("Not supported Yet")
}
None => { /* Do Nothing*/ }
_ => {
info!("Unimplemented Command")
}
}
match cmd.json.thermostat_cmd {
Some(ThermostatCmdEnum::PowerUp) => {
tec.set_pid_engaged(true);
}
Some(ThermostatCmdEnum::PowerDown) => {
tec.set_pid_engaged(false);
}
Some(ThermostatCmdEnum::SetTecMaxV) => {
match cmd.json.data_f64 {
Some(val) => {
tec.set_max_v(ElectricPotential::new::<volt>(val));
}
None => {
info!("Wrong Data type is received")
}
}
}
Some(ThermostatCmdEnum::SetTecMaxIPos) => {
match cmd.json.data_f64 {
Some(val) => {
tec.set_max_i_pos(ElectricCurrent::new::<ampere>(val));
}
None => {
info!("Wrong Data type is received")
}
}
}
Some(ThermostatCmdEnum::SetTecMaxINeg) => {
match cmd.json.data_f64 {
Some(val) => {
tec.set_max_i_pos(ElectricCurrent::new::<milliampere>(val));
}
None => {
info!("Wrong Data type is received")
}
}
}
Some(ThermostatCmdEnum::SetTecIOut) => {
match cmd.json.data_f64 {
Some(val) => {
tec.set_i(ElectricCurrent::new::<milliampere>(val));
}
None => {
info!("Wrong Data type is received")
}
}
}
Some(ThermostatCmdEnum::SetTemperatureSetpoint) => {
match cmd.json.data_f64 {
Some(val) => {
tec.set_temperature_setpoint(ThermodynamicTemperature::new::<degree_celsius>(val));
}
None => {
info!("Wrong Data type is received")
}
}
}
Some(ThermostatCmdEnum::SetPidKp) => {
match cmd.json.data_f64 {
Some(val) => {
tec.set_pid(Kp, val);
}
None => {
info!("Wrong Data type is received")
}
}
}
Some(ThermostatCmdEnum::SetPidKi) => {
match cmd.json.data_f64 {
Some(val) => {
tec.set_pid(Ki, val);
}
None => {
info!("Wrong Data type is received")
}
}
}
Some(ThermostatCmdEnum::SetPidKd) => {
match cmd.json.data_f64 {
Some(val) => {
tec.set_pid(Kd, val);
}
None => {
info!("Wrong Data type is received")
}
}
}
Some(ThermostatCmdEnum::SetPidOutMin) => {
match cmd.json.data_f64 {
Some(val) => {
tec.set_pid(Min, val);
}
None => {
info!("Wrong Data type is received")
}
}
}
Some(ThermostatCmdEnum::SetPidOutMax) => {
match cmd.json.data_f64 {
Some(val) => {
tec.set_pid(Max, val);
}
None => {
info!("Wrong Data type is received")
}
}
}
Some(ThermostatCmdEnum::SetPidUpdateInterval) => {
info!("Not supported Yet")
}
Some(ThermostatCmdEnum::SetShT0) => {
match cmd.json.data_f64 {
Some(val) => {
tec.set_sh_t0(ThermodynamicTemperature::new::<degree_celsius>(val));
}
None => {
info!("Wrong Data type is received")
}
}
}
Some(ThermostatCmdEnum::SetShR0) => {
match cmd.json.data_f64 {
Some(val) => {
tec.set_sh_r0(ElectricalResistance::new::<ohm>(val));
}
None => {
info!("Wrong Data type is received")
}
}
}
Some(ThermostatCmdEnum::SetShBeta) => {
match cmd.json.data_f64 {
Some(val) => {
tec.set_sh_beta(val);
}
None => {
info!("Wrong Data type is received")
}
}
}
Some(ThermostatCmdEnum::GetTecStatus) => {
info!("Not supported Yet")
}
Some(ThermostatCmdEnum::GetPidStatus) => {
info!("Not supported Yet")
}
Some(ThermostatCmdEnum::GetShParams) => {
info!("Not supported Yet")
}
None => { /* Do Nothing*/ }
_ => {
info!("Unimplemented Command")
}
@ -316,5 +121,5 @@ pub fn execute_cmd(buffer: &mut [u8], buffer_size: usize, mut laser: LdDrive, mu
info!("Invalid Command: {:?}", err);
}
}
(laser, tec)
laser
}

1
src/pid/mod.rs Normal file
View File

@ -0,0 +1 @@
pub mod pid;

144
src/pid/pid.rs Normal file
View File

@ -0,0 +1,144 @@
#[macro_use]
use miniconf::Tree;
use miniconf::{Serialize, Deserialize};
#[derive(Clone, Copy, Debug, PartialEq, Tree)]
pub struct Parameters {
/// Gain coefficient for proportional term
pub kp: f32,
/// Gain coefficient for integral term
pub ki: f32,
/// Gain coefficient for derivative term
pub kd: f32,
/// Output limit minimum
pub output_min: f32,
/// Output limit maximum
pub output_max: f32,
}
impl Default for Parameters {
fn default() -> Self {
Parameters {
kp: 0.0,
ki: 0.0,
kd: 0.0,
output_min: -2.0,
output_max: 2.0,
}
}
}
#[derive(Clone, Debug, PartialEq, Tree)]
pub struct Controller {
#[tree]
pub parameters: Parameters,
pub target : f64,
u1 : f64,
x1 : f64,
x2 : f64,
pub y1 : f64,
}
impl Controller {
pub const fn new(parameters: Parameters) -> Controller {
Controller {
parameters: parameters,
target : 0.0,
u1 : 0.0,
x1 : 0.0,
x2 : 0.0,
y1 : 0.0,
}
}
// Based on https://hackmd.io/IACbwcOTSt6Adj3_F9bKuw PID implementation
// Input x(t), target u(t), output y(t)
// y0' = y1 - ki * u0
// + x0 * (kp + ki + kd)
// - x1 * (kp + 2kd)
// + x2 * kd
// + kp * (u0 - u1)
// y0 = clip(y0', ymin, ymax)
pub fn update(&mut self, input: f64) -> f64 {
let mut output: f64 = self.y1 - self.target * f64::from(self.parameters.ki)
+ input * f64::from(self.parameters.kp + self.parameters.ki + self.parameters.kd)
- self.x1 * f64::from(self.parameters.kp + 2.0 * self.parameters.kd)
+ self.x2 * f64::from(self.parameters.kd)
+ f64::from(self.parameters.kp) * (self.target - self.u1);
if output < self.parameters.output_min.into() {
output = self.parameters.output_min.into();
}
if output > self.parameters.output_max.into() {
output = self.parameters.output_max.into();
}
self.x2 = self.x1;
self.x1 = input;
self.u1 = self.target;
self.y1 = output;
output
}
pub fn summary(&self) -> Summary {
Summary {
parameters: self.parameters.clone(),
target: self.target,
}
}
}
#[derive(Clone, Debug, Tree)]
pub struct Summary {
#[tree]
parameters: Parameters,
target: f64,
}
#[cfg(test)]
mod test {
use super::*;
const PARAMETERS: Parameters = Parameters {
kp: 0.03,
ki: 0.002,
kd: 0.15,
output_min: -10.0,
output_max: 10.0,
};
#[test]
fn test_controller() {
// Initial and ambient temperature
const DEFAULT: f64 = 20.0;
// Target temperature
const TARGET: f64 = 40.0;
// Control tolerance
const ERROR: f64 = 0.01;
// System response delay
const DELAY: usize = 10;
// Heat lost
const LOSS: f64 = 0.05;
// Limit simulation cycle, reaching this limit before settling fails test
const CYCLE_LIMIT: u32 = 1000;
let mut pid = Controller::new(PARAMETERS.clone());
pid.target = TARGET;
let mut values = [DEFAULT; DELAY];
let mut t = 0;
let mut total_t = 0;
let mut output: f64 = 0.0;
let target = (TARGET - ERROR)..=(TARGET + ERROR);
while !values.iter().all(|value| target.contains(value)) && total_t < CYCLE_LIMIT {
let next_t = (t + 1) % DELAY;
// Feed the oldest temperature
output = pid.update(values[next_t]);
// Overwrite oldest with previous temperature - output
values[next_t] = values[t] - output - (values[t] - DEFAULT) * LOSS;
t = next_t;
total_t += 1;
println!("{}", values[t].to_string());
}
assert_ne!(CYCLE_LIMIT, total_t);
}
}

173
src/thermostat/pid_state.rs
View File

@ -1,91 +1,92 @@
use smoltcp::time::{Duration, Instant};
use uom::si::{
electric_current::ampere, electric_potential::volt, electrical_resistance::ohm, f64::{
ElectricCurrent, ElectricPotential, ElectricalResistance, ThermodynamicTemperature
}, thermodynamic_temperature::degree_celsius
f64::{
ElectricPotential,
ElectricalResistance,
ThermodynamicTemperature,
Time,
},
electric_potential::volt,
electrical_resistance::ohm,
thermodynamic_temperature::degree_celsius,
time::millisecond,
};
use crate::thermostat::{
ad7172,
steinhart_hart as sh,
};
use idsp::iir::{Pid, Action, Biquad};
use crate::debug;
use crate::pid::pid;
const R_INNER: f64 = 2.0 * 5100.0;
const VREF_SENS: f64 = 3.3 / 2.0;
pub struct PidState {
adc_data: Option<u32>,
adc_calibration: ad7172::ChannelCalibration,
pid_engaged: bool,
pid: Biquad<f32>,
pid_out_min: ElectricCurrent,
pid_out_max: ElectricCurrent,
xy: [f32; 4],
set_point: ThermodynamicTemperature,
settings: Pid<f32>,
sh: sh::Parameters,
pub adc_data: Option<u32>,
pub adc_calibration: ad7172::ChannelCalibration,
pub update_ts: Time,
pub update_interval: Time,
/// i_set 0A center point
pub center_point: ElectricPotential,
pub dac_volt: ElectricPotential,
pub pid_engaged: bool,
pub pid: pid::Controller,
pub sh: sh::Parameters,
}
impl PidState {
fn adc_calibration(mut self, adc_calibration: ad7172::ChannelCalibration) -> Self {
self.adc_calibration = adc_calibration;
self
}
}
impl Default for PidState {
fn default() -> Self {
const OUT_MIN: f32 = -1.0;
const OUT_MAX: f32 = 1.0;
let mut pid_settings = Pid::<f32>::default();
pid_settings
// Pid Update Period depends on the AD7172 Output Data Rate Set
.period(0.1)
.limit(Action::Kp, 10.0)
.limit(Action::Ki, 10.0)
.limit(Action::Kd, 10.0);
let mut pid: Biquad<f32> = pid_settings.build().unwrap().into();
pid.set_min(OUT_MIN);
pid.set_max(OUT_MAX);
PidState {
adc_data: None,
adc_calibration: ad7172::ChannelCalibration::default(),
update_ts: Time::new::<millisecond>(0.0),
// default: 10 Hz
update_interval: Time::new::<millisecond>(100.0),
center_point: ElectricPotential::new::<volt>(1.5),
dac_volt: ElectricPotential::new::<volt>(0.0),
pid_engaged: false,
pid: pid,
pid_out_min: ElectricCurrent::new::<ampere>(OUT_MIN as f64),
pid_out_max: ElectricCurrent::new::<ampere>(OUT_MAX as f64),
xy: [0.0; 4],
set_point: ThermodynamicTemperature::new::<degree_celsius>(0.0),
settings: pid_settings,
pid: pid::Controller::new(pid::Parameters::default()),
sh: sh::Parameters::default(),
}
}
}
pub enum PidSettings {
Kp,
Ki,
Kd,
Min,
Max,
impl PidState {
pub fn new(adc_calibration: ad7172::ChannelCalibration) -> Self {
PidState::default().adc_calibration(adc_calibration)
}
impl PidState {
pub fn update(&mut self, adc_data: u32) {
pub fn update(&mut self, now: Instant, adc_data: u32) {
self.adc_data = if adc_data == ad7172::MAX_VALUE {
// this means there is no thermistor plugged into the ADC.
None
} else {
Some(adc_data)
};
self.update_interval = Time::new::<millisecond>(now.millis() as f64) - self.update_ts;
self.update_ts = Time::new::<millisecond>(now.millis() as f64);
}
/// Update PID state on ADC input, calculate new DAC output
pub fn update_pid(&mut self) -> Option<f64> {
let input = (self.get_temperature()?.get::<degree_celsius>() as f32) - (self.set_point.get::<degree_celsius>() as f32);
let pid_output = self.pid.update(&mut self.xy, input);
debug!("BiQuad Storage [x0, x1, y0, y1]: {:?}", self.xy);
Some(pid_output as f64)
let temperature = self.get_temperature()?
.get::<degree_celsius>();
let pid_output = self.pid.update(temperature);
Some(pid_output)
}
pub fn reset_pid_state(&mut self){
self.xy = [0.0; 4];
pub fn get_update_ts(&self) -> Time {
self.update_ts
}
pub fn get_update_interval(&self) -> Time {
self.update_interval
}
pub fn get_adc(&self) -> Option<ElectricPotential> {
@ -106,76 +107,4 @@ impl PidState {
let temperature = self.sh.get_temperature(r);
Some(temperature)
}
pub fn set_pid_params(&mut self, param: PidSettings, val: f64){
match param {
PidSettings::Kp => {
self.settings.gain(Action::Kp, val as f32);
}
PidSettings::Ki => {
self.settings.gain(Action::Ki, val as f32);
}
PidSettings::Kd => {
self.settings.gain(Action::Kd, val as f32);
}
PidSettings::Min => {
self.pid_out_min = ElectricCurrent::new::<ampere>(val);
}
PidSettings::Max => {
self.pid_out_max = ElectricCurrent::new::<ampere>(val);
}
}
self.update_pid_settings();
}
pub fn set_pid_period(&mut self, period: f32){
self.settings.period(period);
self.pid = self.settings.build().unwrap().into();
}
pub fn update_pid_settings(&mut self){
self.pid = self.settings.build().unwrap().into();
self.pid.set_max(self.pid_out_max.get::<ampere>() as f32);
self.pid.set_min(self.pid_out_min.get::<ampere>() as f32);
}
pub fn set_pid_setpoint(&mut self, temperature: ThermodynamicTemperature){
self.set_point = temperature;
}
pub fn get_pid_setpoint(&mut self) -> ThermodynamicTemperature {
self.set_point
}
pub fn set_sh_t0(&mut self, t0: ThermodynamicTemperature){
self.sh.t0 = t0
}
pub fn set_sh_r0(&mut self, r0: ElectricalResistance){
self.sh.r0 = r0
}
pub fn set_sh_beta(&mut self, beta: f64){
self.sh.b = beta
}
pub fn set_adc_calibration(&mut self, adc_cal: ad7172::ChannelCalibration){
self.adc_calibration = adc_cal;
}
pub fn set_pid_engaged(&mut self, pid_engaged: bool){
self.pid_engaged = pid_engaged;
}
pub fn get_pid_engaged(&mut self) -> bool {
self.pid_engaged
}
pub fn get_pid_settings(&mut self) -> Pid<f32> {
unimplemented!()
}
pub fn get_sh(&mut self) -> sh::Parameters {
unimplemented!()
}
}

2
src/thermostat/steinhart_hart.rs
View File

@ -8,7 +8,7 @@ use uom::si::{
ratio::ratio,
thermodynamic_temperature::{degree_celsius, kelvin},
};
use miniconf::Tree;
use miniconf::{Tree, TreeDeserialize};
/// Steinhart-Hart equation parameters
#[derive(Clone, Debug, PartialEq, Tree)]

90
src/thermostat/thermostat.rs
View File

@ -1,19 +1,17 @@
use core::f64::NAN;
use core::marker::PhantomData;
use crate::sys_timer;
use smoltcp::time::Instant;
use crate::{sys_timer, pid::pid};
use crate::thermostat::ad5680;
use crate::thermostat::max1968::{MAX1968, AdcReadTarget, PwmPinsEnum};
use crate::thermostat::ad7172;
use crate::thermostat::pid_state::{PidState, PidSettings};
use crate::thermostat::pid_state::PidState;
use crate::thermostat::steinhart_hart;
use idsp::iir::Pid;
use log::debug;
use uom::si::{
electric_current::ampere,
electric_potential::volt,
electrical_resistance::ohm,
thermodynamic_temperature::degree_celsius,
f64::{ThermodynamicTemperature, ElectricCurrent, ElectricPotential, ElectricalResistance},
f64::{ElectricCurrent, ElectricPotential, ElectricalResistance, Time, ThermodynamicTemperature},
ratio::ratio,
};
use miniconf::Tree;
@ -115,7 +113,7 @@ impl Thermostat{
pub fn setup(&mut self){
self.tec_setup();
let t_adc_ch0_cal = self.t_adc_setup();
self.pid_ctrl_ch0.set_adc_calibration(t_adc_ch0_cal) ;
self.pid_ctrl_ch0.adc_calibration = t_adc_ch0_cal;
}
fn tec_setup(&mut self) {
@ -139,28 +137,25 @@ impl Thermostat{
adc_calibration0
}
pub fn poll_adc_and_update_pid(&mut self) -> bool {
self.ad7172.data_ready().unwrap().map(|_ch| {
pub fn poll_adc(&mut self, instant: Instant) -> Option<u8> {
self.ad7172.data_ready().unwrap().map(|channel| {
let data = self.ad7172.read_data().unwrap();
let state: &mut PidState = &mut self.pid_ctrl_ch0;
state.update(data);
debug!("state.get_pid_engaged(): {:?}", state.get_pid_engaged());
if state.get_pid_engaged() {
state.update(instant, data);
match state.update_pid() {
Some(pid_output) => {
Some(pid_output) if state.pid_engaged => {
// Forward PID output to i_set DAC
self.set_i(ElectricCurrent::new::<ampere>(pid_output));
debug!("Temperature Set Point: {:?} degree", self.pid_ctrl_ch0.get_pid_setpoint().get::<degree_celsius>());
self.power_up();
}
None => { }
}
} else {
None if state.pid_engaged => {
self.power_down();
}
debug!("Temperature: {:?} degree", self.get_temperature().get::<degree_celsius>());
true
});
false
_ => {}
}
channel
})
}
pub fn power_up(&mut self){
@ -169,8 +164,6 @@ impl Thermostat{
pub fn power_down(&mut self){
self.max1968.power_down();
self.pid_ctrl_ch0.reset_pid_state();
self.set_i(ElectricCurrent::new::<ampere>(0.0));
}
fn set_center_pt(&mut self, value: ElectricPotential){
@ -266,17 +259,18 @@ impl Thermostat{
}
}
pub fn set_pid_engaged(&mut self, val: bool) {
self.pid_ctrl_ch0.set_pid_engaged(val);
pub fn pid_engaged(&mut self) -> bool {
if self.pid_ctrl_ch0.pid_engaged {
return true;
}
pub fn get_pid_engaged(&mut self) -> bool {
self.pid_ctrl_ch0.get_pid_engaged()
false
}
pub fn get_status_report(&mut self) -> StatusReport {
StatusReport {
pid_engaged: self.get_pid_engaged(),
pid_update_ts: self.pid_ctrl_ch0.get_update_ts(),
pid_update_interval: self.pid_ctrl_ch0.get_update_interval(),
pid_engaged: self.pid_engaged(),
temperature: self.pid_ctrl_ch0.get_temperature(),
i_set: self.tec_setting.i_set,
tec_i: self.get_tec_i(),
@ -285,21 +279,12 @@ impl Thermostat{
}
}
pub fn get_temperature(&mut self) -> ThermodynamicTemperature {
match self.pid_ctrl_ch0.get_temperature() {
Some(val) => {
val
}
None => { ThermodynamicTemperature::new::<degree_celsius>(NAN) }
}
}
pub fn get_pid_settings(&mut self) -> Pid<f32> {
self.pid_ctrl_ch0.get_pid_settings()
pub fn get_pid_settings(&mut self) -> pid::Controller {
self.pid_ctrl_ch0.pid.clone()
}
pub fn get_steinhart_hart(&mut self) -> steinhart_hart::Parameters {
self.pid_ctrl_ch0.get_sh()
self.pid_ctrl_ch0.sh.clone()
}
pub fn get_tec_settings(&mut self) -> TecSettingSummary {
@ -316,29 +301,12 @@ impl Thermostat{
self.max1968.get_calibrated_vdda()
}
pub fn set_pid(&mut self, param: PidSettings, val: f64){
self.pid_ctrl_ch0.set_pid_params(param, val);
}
pub fn set_sh_beta(&mut self, beta: f64) {
self.pid_ctrl_ch0.set_sh_beta(beta);
}
pub fn set_sh_r0(&mut self, r0: ElectricalResistance) {
self.pid_ctrl_ch0.set_sh_r0(r0);
}
pub fn set_sh_t0(&mut self, t0: ThermodynamicTemperature) {
self.pid_ctrl_ch0.set_sh_t0(t0);
}
pub fn set_temperature_setpoint(&mut self, t: ThermodynamicTemperature) {
self.pid_ctrl_ch0.set_pid_setpoint(t);
}
}
#[derive(Tree, Debug)]
#[derive(Tree)]
pub struct StatusReport {
pid_update_ts: Time,
pid_update_interval: Time,
pid_engaged: bool,
temperature: Option<ThermodynamicTemperature>,
i_set: ElectricCurrent,