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

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.
This commit is contained in:
atse 2023-08-25 17:34:07 +08:00
parent bd9ae997ae
commit 069d791802
10 changed files with 74 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
README.md
View File

@ -111,8 +111,8 @@ formatted as line-delimited JSON.
| `pid <0/1> kd <value>` | Set differential gain |
| `pid <0/1> output_min <amp>` | Set mininum output |
| `pid <0/1> output_max <amp>` | Set maximum output |
| `s-h` | Show Steinhart-Hart equation parameters |
| `s-h <0/1> <t0/b/r0> <value>` | Set Steinhart-Hart parameter for a channel |
| `b-p` | Show B-Parameter equation parameters |
| `b-p <0/1> <t0/b/r0> <value>` | Set B-Parameter for a channel |
| `postfilter` | Show postfilter settings |
| `postfilter <0/1> off` | Disable postfilter |
| `postfilter <0/1> rate <rate>` | Set postfilter output data rate |
@ -144,22 +144,22 @@ output will be truncated when USB buffers are full.
Connect the thermistor with the SENS pins of the
device. Temperature-depending resistance is measured by the AD7172
ADC. To prepare conversion to a temperature, set the Beta parameters
for the Steinhart-Hart equation.
ADC. To prepare conversion to a temperature, set the parameters
for the B-Parameter equation.
Set the base temperature in degrees celsius for the channel 0 thermistor:
```
s-h 0 t0 20
b-p 0 t0 20
```
Set the resistance in Ohms measured at the base temperature t0:
```
s-h 0 r0 10000
b-p 0 r0 10000
```
Set the Beta parameter:
```
s-h 0 b 3800
b-p 0 b 3800
```
### 50/60 Hz filtering
@ -260,7 +260,7 @@ with the following keys.
| `interval` | Seconds | Time elapsed since last report update on channel |
| `adc` | Volts | AD7172 input |
| `sens` | Ohms | Thermistor resistance derived from `adc` |
| `temperature` | Degrees Celsius | Steinhart-Hart conversion result derived from `sens` |
| `temperature` | Degrees Celsius | B-Parameter conversion result derived from `sens` |
| `pid_engaged` | Boolean | `true` if in closed-loop mode |
| `i_set` | Amperes | TEC output current |
| `dac_value` | Volts | AD5680 output derived from `i_set` |

4
pytec/example.py
View File

@ -1,11 +1,11 @@
from pytec.client import Client
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_output())
print(tec.get_pid())
print(tec.get_output())
print(tec.get_postfilter())
print(tec.get_steinhart_hart())
print(tec.get_b_parameter())
for data in tec.report_mode():
print(data)

8
pytec/pytec/client.py
View File

@ -92,14 +92,14 @@ class Client:
"""
return self._get_conf("pid")
def get_steinhart_hart(self):
"""Retrieve Steinhart-Hart parameters for resistance to temperature conversion
def get_b_parameter(self):
"""Retrieve B-Parameter equation parameters for resistance to temperature conversion
Example::
[{'params': {'b': 3800.0, 'r0': 10000.0, 't0': 298.15}, 'channel': 0},
{'params': {'b': 3800.0, 'r0': 10000.0, 't0': 298.15}, 'channel': 1}]
"""
return self._get_conf("s-h")
return self._get_conf("b-p")
def get_postfilter(self):
"""Retrieve DAC postfilter configuration
@ -146,7 +146,7 @@ class Client:
Examples::
tec.set_param("output", 0, "max_v", 2.0)
tec.set_param("pid", 1, "output_max", 2.5)
tec.set_param("s-h", 0, "t0", 20.0)
tec.set_param("b-p", 0, "t0", 20.0)
tec.set_param("center", 0, "vref")
tec.set_param("postfilter", 1, 21)

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

@ -8,14 +8,14 @@ use uom::si::{
thermodynamic_temperature::{degree_celsius, kelvin},
};
/// Steinhart-Hart equation parameters
/// B-Parameter equation parameters
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Parameters {
/// Base temperature
pub t0: ThermodynamicTemperature,
/// Resistance at base temperature
/// Thermistor resistance at base temperature
pub r0: ElectricalResistance,
/// Beta
/// Beta (average slope of the function ln R vs. 1/T)
pub b: TemperatureInterval,
}

10
src/channel_state.rs
View File

@ -1,8 +1,8 @@
use crate::{
ad7172,
ad7172, b_parameter as bp,
command_parser::{CenterPoint, Polarity},
config::PwmLimits,
pid, steinhart_hart as sh,
pid,
};
use num_traits::Zero;
use smoltcp::time::{Duration, Instant};
@ -32,7 +32,7 @@ pub struct ChannelState {
pub pwm_limits: PwmLimits,
pub pid_engaged: bool,
pub pid: pid::Controller,
pub sh: sh::Parameters,
pub bp: bp::Parameters,
pub polarity: Polarity,
}
@ -54,7 +54,7 @@ impl ChannelState {
},
pid_engaged: false,
pid: pid::Controller::new(pid::Parameters::default()),
sh: sh::Parameters::default(),
bp: bp::Parameters::default(),
polarity: Polarity::Normal,
}
}
@ -100,7 +100,7 @@ impl ChannelState {
pub fn get_temperature(&self) -> Option<ThermodynamicTemperature> {
let r = self.get_sens()?;
let temperature = self.sh.get_temperature(r);
let temperature = self.bp.get_temperature(r);
Some(temperature)
}
}

17
src/channels.rs
View File

@ -1,12 +1,11 @@
use crate::timer::sleep;
use crate::{
ad5680, ad7172,
ad5680, ad7172, b_parameter,
channel::{Channel, Channel0, Channel1},
channel_state::ChannelState,
command_handler::JsonBuffer,
command_parser::{CenterPoint, Polarity, PwmPin},
pins::{self, Channel0VRef, Channel1VRef},
steinhart_hart,
};
use core::marker::PhantomData;
use heapless::{consts::U2, Vec};
@ -558,17 +557,17 @@ impl Channels {
serde_json_core::to_vec(&summaries)
}
fn steinhart_hart_summary(&mut self, channel: usize) -> SteinhartHartSummary {
let params = self.channel_state(channel).sh.clone();
SteinhartHartSummary { channel, params }
fn b_parameter_summary(&mut self, channel: usize) -> BParameterSummary {
let params = self.channel_state(channel).bp.clone();
BParameterSummary { channel, params }
}
pub fn steinhart_hart_summaries_json(
pub fn b_parameter_summaries_json(
&mut self,
) -> Result<JsonBuffer, serde_json_core::ser::Error> {
let mut summaries = Vec::<_, U2>::new();
for channel in 0..CHANNELS {
let _ = summaries.push(self.steinhart_hart_summary(channel));
let _ = summaries.push(self.b_parameter_summary(channel));
}
serde_json_core::to_vec(&summaries)
}
@ -647,7 +646,7 @@ pub struct PostFilterSummary {
}
#[derive(Serialize)]
pub struct SteinhartHartSummary {
pub struct BParameterSummary {
channel: usize,
params: steinhart_hart::Parameters,
params: b_parameter::Parameters,
}

33
src/command_handler.rs
View File

@ -2,7 +2,7 @@ use super::{
ad7172,
channels::{Channels, CHANNELS},
command_parser::{
CenterPoint, Command, Ipv4Config, PidParameter, Polarity, PwmPin, ShParameter, ShowCommand,
BpParameter, CenterPoint, Command, Ipv4Config, PidParameter, Polarity, PwmPin, ShowCommand,
},
config::ChannelConfig,
dfu,
@ -113,16 +113,13 @@ impl Handler {
Ok(Handler::Handled)
}
fn show_steinhart_hart(
socket: &mut TcpSocket,
channels: &mut Channels,
) -> Result<Handler, Error> {
match channels.steinhart_hart_summaries_json() {
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 steinhart-hart summaries: {:?}", e);
error!("unable to serialize b parameter summaries: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
return Err(Error::Report);
}
@ -241,19 +238,19 @@ impl Handler {
Ok(Handler::Handled)
}
fn set_steinhart_hart(
fn set_b_parameter(
socket: &mut TcpSocket,
channels: &mut Channels,
channel: usize,
parameter: ShParameter,
parameter: BpParameter,
value: f64,
) -> Result<Handler, Error> {
let sh = &mut channels.channel_state(channel).sh;
use super::command_parser::ShParameter::*;
let bp = &mut channels.channel_state(channel).bp;
use super::command_parser::BpParameter::*;
match parameter {
T0 => sh.t0 = ThermodynamicTemperature::new::<degree_celsius>(value),
B => sh.b = TemperatureInterval::new::<kelvin>(value),
R0 => sh.r0 = ElectricalResistance::new::<ohm>(value),
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)
@ -480,9 +477,7 @@ impl Handler {
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::SteinhartHart) => {
Handler::show_steinhart_hart(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),
@ -502,11 +497,11 @@ impl Handler {
parameter,
value,
} => Handler::set_pid(socket, channels, channel, parameter, value),
Command::SteinhartHart {
Command::BParameter {
channel,
parameter,
value,
} => Handler::set_steinhart_hart(socket, channels, channel, parameter, value),
} => Handler::set_b_parameter(socket, channels, channel, parameter, value),
Command::PostFilter {
channel,
rate: None,

48
src/command_parser.rs
View File

@ -93,7 +93,7 @@ pub enum ShowCommand {
Input,
Output,
Pid,
SteinhartHart,
BParameter,
PostFilter,
Ipv4,
}
@ -108,9 +108,9 @@ pub enum PidParameter {
OutputMax,
}
/// Steinhart-Hart equation parameter
/// B-Parameter equation parameter
#[derive(Debug, Clone, PartialEq)]
pub enum ShParameter {
pub enum BpParameter {
T0,
B,
R0,
@ -172,9 +172,9 @@ pub enum Command {
parameter: PidParameter,
value: f64,
},
SteinhartHart {
BParameter {
channel: usize,
parameter: ShParameter,
parameter: BpParameter,
value: f64,
},
PostFilter {
@ -366,18 +366,18 @@ fn pid(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
))(input)
}
/// `s-h <0-1> <parameter> <value>`
fn steinhart_hart_parameter(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
/// `b-p <0-1> <parameter> <value>`
fn b_parameter_parameter(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
let (input, channel) = channel(input)?;
let (input, _) = whitespace(input)?;
let (input, parameter) = alt((
value(ShParameter::T0, tag("t0")),
value(ShParameter::B, tag("b")),
value(ShParameter::R0, tag("r0")),
value(BpParameter::T0, tag("t0")),
value(BpParameter::B, tag("b")),
value(BpParameter::R0, tag("r0")),
))(input)?;
let (input, _) = whitespace(input)?;
let (input, value) = float(input)?;
let result = value.map(|value| Command::SteinhartHart {
let result = value.map(|value| Command::BParameter {
channel,
parameter,
value,
@ -385,12 +385,12 @@ fn steinhart_hart_parameter(input: &[u8]) -> IResult<&[u8], Result<Command, Erro
Ok((input, result))
}
/// `s-h` | `s-h <steinhart_hart_parameter>`
fn steinhart_hart(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
let (input, _) = tag("s-h")(input)?;
/// `b-p` | `b-p <b_parameter_parameter>`
fn b_parameter(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
let (input, _) = tag("b-p")(input)?;
alt((
preceded(whitespace, steinhart_hart_parameter),
value(Ok(Command::Show(ShowCommand::SteinhartHart)), end),
preceded(whitespace, b_parameter_parameter),
value(Ok(Command::Show(ShowCommand::BParameter)), end),
))(input)
}
@ -572,7 +572,7 @@ fn command(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
output,
center_point,
pid,
steinhart_hart,
b_parameter,
postfilter,
value(Ok(Command::Dfu), tag("dfu")),
fan,
@ -753,19 +753,19 @@ mod test {
}
#[test]
fn parse_steinhart_hart() {
let command = Command::parse(b"s-h");
assert_eq!(command, Ok(Command::Show(ShowCommand::SteinhartHart)));
fn parse_b_parameter() {
let command = Command::parse(b"b-p");
assert_eq!(command, Ok(Command::Show(ShowCommand::BParameter)));
}
#[test]
fn parse_steinhart_hart_set() {
let command = Command::parse(b"s-h 1 t0 23.05");
fn parse_b_parameter_set() {
let command = Command::parse(b"b-p 1 t0 23.05");
assert_eq!(
command,
Ok(Command::SteinhartHart {
Ok(Command::BParameter {
channel: 1,
parameter: ShParameter::T0,
parameter: BpParameter::T0,
value: 23.05,
})
);

9
src/config.rs
View File

@ -1,8 +1,9 @@
use crate::{
ad7172::PostFilter,
b_parameter,
channels::Channels,
command_parser::{CenterPoint, Polarity},
pid, steinhart_hart,
pid,
};
use num_traits::Zero;
use serde::{Deserialize, Serialize};
@ -16,7 +17,7 @@ pub struct ChannelConfig {
pid_engaged: bool,
i_set: ElectricCurrent,
polarity: Polarity,
sh: steinhart_hart::Parameters,
bp: b_parameter::Parameters,
pwm: PwmLimits,
/// uses variant `PostFilter::Invalid` instead of `None` to save space
adc_postfilter: PostFilter,
@ -45,7 +46,7 @@ impl ChannelConfig {
pid_engaged: state.pid_engaged,
i_set,
polarity: state.polarity.clone(),
sh: state.sh.clone(),
bp: state.bp.clone(),
pwm,
adc_postfilter,
}
@ -57,7 +58,7 @@ impl ChannelConfig {
state.pid.parameters = self.pid.clone();
state.pid.target = self.pid_target.into();
state.pid_engaged = self.pid_engaged;
state.sh = self.sh.clone();
state.bp = self.bp.clone();
self.pwm.apply(channels, channel);

2
src/main.rs
View File

@ -35,9 +35,9 @@ mod session;
use session::{Session, SessionInput};
mod command_parser;
use command_parser::Ipv4Config;
mod b_parameter;
mod channels;
mod pid;
mod steinhart_hart;
mod timer;
use channels::{Channels, CHANNELS};
mod channel;