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 6cd6a6a2c2
commit d7462e6791
10 changed files with 71 additions and 71 deletions

View File

@ -114,8 +114,8 @@ formatted as line-delimited JSON.
| `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 |
| `s-h` | Show Steinhart-Hart equation parameters | | `b-p` | Show B-Parameter equation parameters |
| `s-h <0/1> <t0/b/r0> <value>` | Set Steinhart-Hart parameter for a channel | | `b-p <0/1> <t0/b/r0> <value>` | Set B-Parameter for a channel |
| `postfilter` | Show postfilter settings | | `postfilter` | Show postfilter settings |
| `postfilter <0/1> off` | Disable postfilter | | `postfilter <0/1> off` | Disable postfilter |
| `postfilter <0/1> rate <rate>` | Set postfilter output data rate | | `postfilter <0/1> rate <rate>` | Set postfilter output data rate |
@ -147,22 +147,22 @@ output will be truncated when USB buffers are full.
Connect the thermistor with the SENS pins of the Connect the thermistor with the SENS pins of the
device. Temperature-depending resistance is measured by the AD7172 device. Temperature-depending resistance is measured by the AD7172
ADC. To prepare conversion to a temperature, set the 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
@ -261,7 +261,7 @@ with the following keys.
| `time` | Seconds | Temperature measurement time | | `time` | Seconds | Temperature measurement time |
| `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) | | `vref` | Volts | MAX1968 VREF (1.5 V) |

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_pwm())
print(tec.get_pid()) print(tec.get_pid())
print(tec.get_pwm()) print(tec.get_pwm())
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)

View File

@ -89,14 +89,14 @@ class Client:
""" """
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
@ -143,7 +143,7 @@ class Client:
Examples:: Examples::
tec.set_param("pwm", 0, "max_v", 2.0) tec.set_param("pwm", 0, "max_v", 2.0)
tec.set_param("pid", 1, "output_max", 2.5) tec.set_param("pid", 1, "output_max", 2.5)
tec.set_param("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)

View File

@ -10,15 +10,15 @@ use uom::si::{
}; };
use serde::{Deserialize, Serialize}; 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 /// B, the average slope of the function ln R vs. 1/T
pub b: f64, pub b: ThermodynamicTemperature,
} }
impl Parameters { impl Parameters {

View File

@ -14,7 +14,7 @@ use uom::si::{
use crate::{ use crate::{
ad7172, ad7172,
pid, pid,
steinhart_hart as sh, b_parameter as bp,
command_parser::CenterPoint, command_parser::CenterPoint,
}; };
@ -31,7 +31,7 @@ pub struct ChannelState {
pub dac_value: ElectricPotential, pub dac_value: ElectricPotential,
pub pid_engaged: bool, pub pid_engaged: bool,
pub pid: pid::Controller, pub pid: pid::Controller,
pub sh: sh::Parameters, pub bp: bp::Parameters,
} }
impl ChannelState { impl ChannelState {
@ -46,7 +46,7 @@ impl ChannelState {
dac_value: ElectricPotential::new::<volt>(0.0), dac_value: ElectricPotential::new::<volt>(0.0),
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(),
} }
} }
@ -92,7 +92,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)
} }
} }

View File

@ -19,7 +19,7 @@ use crate::{
command_parser::{CenterPoint, PwmPin}, command_parser::{CenterPoint, PwmPin},
command_handler::JsonBuffer, command_handler::JsonBuffer,
pins, pins,
steinhart_hart, b_parameter,
}; };
pub const CHANNELS: usize = 2; pub const CHANNELS: usize = 2;
@ -511,15 +511,15 @@ 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)
} }
@ -595,7 +595,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,
} }

View File

@ -11,7 +11,7 @@ use super::{
CenterPoint, CenterPoint,
PidParameter, PidParameter,
PwmPin, PwmPin,
ShParameter BpParameter
}, },
ad7172, ad7172,
CHANNEL_CONFIG_KEY, CHANNEL_CONFIG_KEY,
@ -139,13 +139,13 @@ impl Handler {
Ok(Handler::Handled) Ok(Handler::Handled)
} }
fn show_steinhart_hart(socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> { fn show_b_parameter(socket: &mut TcpSocket, channels: &mut Channels) -> Result<Handler, Error> {
match channels.steinhart_hart_summaries_json() { match channels.b_parameter_summaries_json() {
Ok(buf) => { Ok(buf) => {
send_line(socket, &buf); send_line(socket, &buf);
} }
Err(e) => { Err(e) => {
error!("unable to serialize steinhart-hart summaries: {:?}", e); error!("unable to serialize b parameter summaries: {:?}", e);
let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e); let _ = writeln!(socket, "{{\"error\":\"{:?}\"}}", e);
return Err(Error::ReportError); return Err(Error::ReportError);
} }
@ -238,13 +238,13 @@ impl Handler {
Ok(Handler::Handled) Ok(Handler::Handled)
} }
fn set_steinhart_hart (socket: &mut TcpSocket, channels: &mut Channels, channel: usize, parameter: ShParameter, value: f64) -> Result<Handler, Error> { fn set_b_parameter (socket: &mut TcpSocket, channels: &mut Channels, channel: usize, parameter: BpParameter, value: f64) -> Result<Handler, Error> {
let sh = &mut channels.channel_state(channel).sh; let bp = &mut channels.channel_state(channel).bp;
use super::command_parser::ShParameter::*; use super::command_parser::BpParameter::*;
match parameter { match parameter {
T0 => sh.t0 = ThermodynamicTemperature::new::<degree_celsius>(value), T0 => bp.t0 = ThermodynamicTemperature::new::<degree_celsius>(value),
B => sh.b = value, B => bp.b = value,
R0 => sh.r0 = ElectricalResistance::new::<ohm>(value), R0 => bp.r0 = ElectricalResistance::new::<ohm>(value),
} }
send_line(socket, b"{}"); send_line(socket, b"{}");
Ok(Handler::Handled) Ok(Handler::Handled)
@ -420,14 +420,14 @@ impl Handler {
Command::Show(ShowCommand::Input) => Handler::show_report(socket, channels), Command::Show(ShowCommand::Input) => Handler::show_report(socket, channels),
Command::Show(ShowCommand::Pid) => Handler::show_pid(socket, channels), Command::Show(ShowCommand::Pid) => Handler::show_pid(socket, channels),
Command::Show(ShowCommand::Pwm) => Handler::show_pwm(socket, channels), Command::Show(ShowCommand::Pwm) => 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::PostFilter) => Handler::show_post_filter(socket, channels),
Command::Show(ShowCommand::Ipv4) => Handler::show_ipv4(socket, ipv4_config), Command::Show(ShowCommand::Ipv4) => Handler::show_ipv4(socket, ipv4_config),
Command::PwmPid { channel } => Handler::engage_pid(socket, channels, channel), Command::PwmPid { channel } => Handler::engage_pid(socket, channels, channel),
Command::Pwm { channel, pin, value } => Handler::set_pwm(socket, channels, channel, pin, value), Command::Pwm { channel, pin, value } => Handler::set_pwm(socket, channels, channel, pin, value),
Command::CenterPoint { channel, center } => Handler::set_center_point(socket, channels, channel, center), 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::Pid { channel, parameter, value } => Handler::set_pid(socket, channels, channel, parameter, value),
Command::SteinhartHart { channel, parameter, value } => Handler::set_steinhart_hart(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: None } => Handler::reset_post_filter(socket, channels, channel),
Command::PostFilter { channel, rate: Some(rate) } => Handler::set_post_filter(socket, channels, channel, rate), Command::PostFilter { channel, rate: Some(rate) } => Handler::set_post_filter(socket, channels, channel, rate),
Command::Load { channel } => Handler::load_channel(socket, channels, store, channel), Command::Load { channel } => Handler::load_channel(socket, channels, store, channel),

View File

@ -99,7 +99,7 @@ pub enum ShowCommand {
Reporting, Reporting,
Pwm, Pwm,
Pid, Pid,
SteinhartHart, BParameter,
PostFilter, PostFilter,
Ipv4, Ipv4,
} }
@ -114,9 +114,9 @@ pub enum PidParameter {
OutputMax, OutputMax,
} }
/// 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,
@ -169,9 +169,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 {
@ -400,31 +400,31 @@ fn pid(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
))(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((value(ShParameter::T0, tag("t0")), alt((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::SteinhartHart { channel, parameter, value }); .map(|value| Command::BParameter { 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, whitespace,
steinhart_hart_parameter b_parameter_parameter
), ),
value(Ok(Command::Show(ShowCommand::SteinhartHart)), end) value(Ok(Command::Show(ShowCommand::BParameter)), end)
))(input) ))(input)
} }
@ -594,7 +594,7 @@ fn command(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
pwm, pwm,
center_point, center_point,
pid, pid,
steinhart_hart, b_parameter,
postfilter, postfilter,
value(Ok(Command::Dfu), tag("dfu")), value(Ok(Command::Dfu), tag("dfu")),
fan, fan,
@ -765,17 +765,17 @@ mod test {
} }
#[test] #[test]
fn parse_steinhart_hart() { fn parse_b_parameter() {
let command = Command::parse(b"s-h"); let command = Command::parse(b"b-p");
assert_eq!(command, Ok(Command::Show(ShowCommand::SteinhartHart))); assert_eq!(command, Ok(Command::Show(ShowCommand::BParameter)));
} }
#[test] #[test]
fn parse_steinhart_hart_set() { fn parse_b_parameter_set() {
let command = Command::parse(b"s-h 1 t0 23.05"); let command = Command::parse(b"b-p 1 t0 23.05");
assert_eq!(command, Ok(Command::SteinhartHart { assert_eq!(command, Ok(Command::BParameter {
channel: 1, channel: 1,
parameter: ShParameter::T0, parameter: BpParameter::T0,
value: 23.05, value: 23.05,
})); }));
} }

View File

@ -9,7 +9,7 @@ use crate::{
channels::Channels, channels::Channels,
command_parser::CenterPoint, command_parser::CenterPoint,
pid, pid,
steinhart_hart, b_parameter,
}; };
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@ -18,7 +18,7 @@ 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, 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,
@ -38,7 +38,7 @@ impl ChannelConfig {
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(), bp: state.bp.clone(),
pwm, pwm,
adc_postfilter, adc_postfilter,
} }
@ -50,7 +50,7 @@ impl ChannelConfig {
state.pid.parameters = self.pid.clone(); state.pid.parameters = self.pid.clone();
state.pid.target = self.pid_target.into(); state.pid.target = self.pid_target.into();
state.pid_engaged = self.pid_engaged; state.pid_engaged = self.pid_engaged;
state.sh = self.sh.clone(); state.bp = self.bp.clone();
self.pwm.apply(channels, channel); self.pwm.apply(channels, channel);

View File

@ -41,7 +41,7 @@ mod command_parser;
use command_parser::Ipv4Config; use command_parser::Ipv4Config;
mod timer; mod timer;
mod pid; mod pid;
mod steinhart_hart; mod b_parameter;
mod channels; mod channels;
use channels::{CHANNELS, Channels}; use channels::{CHANNELS, Channels};
mod channel; mod channel;