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

Rename all Steinhart-Hart references to B-param

Browse Source 
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 fcb5cf1d4e
commit 298746c338
10 changed files with 71 additions and 71 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
@ -259,7 +259,7 @@ with the following keys.
| `time` | Seconds | Temperature measurement time |
| `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_pwm())
print(tec.get_pid())
print(tec.get_pwm())
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("pwm", 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)

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

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

8
src/channel_state.rs
View File

@ -17,7 +17,7 @@ use crate::{
ad7172,
pid,
config::PwmLimits,
steinhart_hart as sh,
b_parameter as bp,
command_parser::{CenterPoint, Polarity},
};
@ -36,7 +36,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,
}
@ -58,7 +58,7 @@ impl ChannelState {
},
pid_engaged: false,
pid: pid::Controller::new(pid::Parameters::default()),
sh: sh::Parameters::default(),
bp: bp::Parameters::default(),
polarity: Polarity::Normal,
}
}
@ -105,7 +105,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)
}
}

16
src/channels.rs
View File

@ -20,7 +20,7 @@ use crate::{
command_parser::{CenterPoint, PwmPin, Polarity},
command_handler::JsonBuffer,
pins::{self, Channel0VRef, Channel1VRef},
steinhart_hart,
b_parameter,
};
use crate::timer::sleep;
@ -541,15 +541,15 @@ 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(&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();
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)
}
@ -630,7 +630,7 @@ pub struct PostFilterSummary {
}
#[derive(Serialize)]
pub struct SteinhartHartSummary {
pub struct BParameterSummary {
channel: usize,
params: steinhart_hart::Parameters,
params: b_parameter::Parameters,
}

24
src/command_handler.rs
View File

@ -11,7 +11,7 @@ use super::{
CenterPoint,
PidParameter,
PwmPin,
ShParameter,
BpParameter,
Polarity
},
ad7172,
@ -129,13 +129,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::ReportError);
}
@ -234,13 +234,13 @@ impl Handler {
Ok(Handler::Handled)
}
fn set_steinhart_hart (socket: &mut TcpSocket, channels: &mut Channels, channel: usize, parameter: ShParameter, value: f64) -> Result<Handler, Error> {
let sh = &mut channels.channel_state(channel).sh;
use super::command_parser::ShParameter::*;
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 => sh.t0 = ThermodynamicTemperature::new::<degree_celsius>(value),
B => sh.b = value,
R0 => sh.r0 = ElectricalResistance::new::<ohm>(value),
T0 => bp.t0 = ThermodynamicTemperature::new::<degree_celsius>(value),
B => bp.b = value,
R0 => bp.r0 = ElectricalResistance::new::<ohm>(value),
}
send_line(socket, b"{}");
Ok(Handler::Handled)
@ -414,7 +414,7 @@ impl Handler {
Command::Show(ShowCommand::Input) => Handler::show_report(socket, channels),
Command::Show(ShowCommand::Pid) => Handler::show_pid(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::Ipv4) => Handler::show_ipv4(socket, ipv4_config),
Command::PwmPid { channel } => Handler::engage_pid(socket, channels, channel),
@ -422,7 +422,7 @@ impl Handler {
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::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: Some(rate) } => Handler::set_post_filter(socket, channels, channel, rate),
Command::Load { channel } => Handler::load_channel(socket, channels, store, channel),

48
src/command_parser.rs
View File

@ -98,7 +98,7 @@ pub enum ShowCommand {
Input,
Pwm,
Pid,
SteinhartHart,
BParameter,
PostFilter,
Ipv4,
}
@ -113,9 +113,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,
@ -177,9 +177,9 @@ pub enum Command {
parameter: PidParameter,
value: f64,
},
SteinhartHart {
BParameter {
channel: usize,
parameter: ShParameter,
parameter: BpParameter,
value: f64,
},
PostFilter {
@ -402,31 +402,31 @@ 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"))
alt((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 { channel, parameter, value });
.map(|value| Command::BParameter { channel, parameter, value });
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
b_parameter_parameter
),
value(Ok(Command::Show(ShowCommand::SteinhartHart)), end)
value(Ok(Command::Show(ShowCommand::BParameter)), end)
))(input)
}
@ -596,7 +596,7 @@ fn command(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
pwm,
center_point,
pid,
steinhart_hart,
b_parameter,
postfilter,
value(Ok(Command::Dfu), tag("dfu")),
fan,
@ -758,17 +758,17 @@ 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");
assert_eq!(command, Ok(Command::SteinhartHart {
fn parse_b_parameter_set() {
let command = Command::parse(b"b-p 1 t0 23.05");
assert_eq!(command, Ok(Command::BParameter {
channel: 1,
parameter: ShParameter::T0,
parameter: BpParameter::T0,
value: 23.05,
}));
}

8
src/config.rs
View File

@ -10,7 +10,7 @@ use crate::{
channels::Channels,
command_parser::{CenterPoint, Polarity},
pid,
steinhart_hart,
b_parameter,
};
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@ -21,7 +21,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,
@ -48,7 +48,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,
}
@ -60,7 +60,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

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