104 lines
3.5 KiB
Rust
Executable file
104 lines
3.5 KiB
Rust
Executable file
#![cfg_attr(not(test), no_main)]
|
|
#![cfg_attr(not(test), no_std)]
|
|
|
|
#[cfg(not(test))]
|
|
extern crate panic_halt;
|
|
|
|
use hal::adc::{Adc, Ready, VRef, VTemp};
|
|
use hal::calibration::{VtempCal30, VtempCal130};
|
|
use hal::{pac, prelude::*, rcc::Config};
|
|
|
|
use defmt::{debug, info};
|
|
use defmt_rtt as _; // global logger
|
|
|
|
#[cfg_attr(not(test), cortex_m_rt::entry)] // this is the entrypoint unless testing
|
|
fn main() -> ! {
|
|
let dp = pac::Peripherals::take().unwrap();
|
|
let cp = cortex_m::Peripherals::take().unwrap();
|
|
|
|
let mut rcc = dp.RCC.freeze(Config::hsi16());
|
|
let mut adc: Adc<_> = dp.ADC.constrain(&mut rcc);
|
|
|
|
let mut delay = cp.SYST.delay(rcc.clocks);
|
|
|
|
// NOTE: TSEN bit must be enabled for reading the temperature
|
|
VTemp.enable(&mut adc);
|
|
VRef.enable(&mut adc);
|
|
|
|
// reference temperatures from the chips readonly memory
|
|
// [Source](https://www.st.com/resource/en/datasheet/stm32l053r8.pdf),
|
|
// Table 6 in Secion 3.13 "Temperature sensor"
|
|
//
|
|
// More and better info in the large 1000+ page sheet "Ultra-low-power
|
|
// STM32L0x3 advanced Arm®-based 32-bit MCUs" (RM0367), 14.9
|
|
//
|
|
// This is basically calibration data
|
|
info!(
|
|
"reading calibration data... If this is the last thing you hear from me something has gone terribly wrong"
|
|
);
|
|
let vref_cal = hal::calibration::VrefintCal::get().read();
|
|
let tsense_cal1 = (30, VtempCal30::get().read());
|
|
let tsense_cal2 = (130, VtempCal130::get().read());
|
|
info!("tsense_cal1: {:?}", (30, tsense_cal1));
|
|
info!("tsense_cal2: {:?}", (130, tsense_cal2));
|
|
|
|
// read a few values into void, maybe this will help get that thing started
|
|
for _ in 0..20 {
|
|
let _ = read_temp_mv(&mut adc, 1.0);
|
|
delay.delay_ms(10_u16);
|
|
}
|
|
|
|
let vref_actual: u16 = adc.read(&mut VRef).unwrap();
|
|
let vref_factor = vref_cal as f32 / vref_actual as f32;
|
|
info!(
|
|
"vref actual={} calibration={} => factor={}",
|
|
vref_actual, vref_cal, vref_factor
|
|
);
|
|
|
|
delay.delay_ms(10_u16);
|
|
|
|
let mut temp_c;
|
|
let mut temp_mv;
|
|
loop {
|
|
temp_mv = read_temp_mv(&mut adc, vref_factor);
|
|
temp_c = temp_mv_to_c(temp_mv, tsense_cal1, tsense_cal2);
|
|
info!("Temperature: {:03}mv, {:04}°C", temp_mv, temp_c as i32);
|
|
delay.delay_ms(500_u16);
|
|
}
|
|
}
|
|
|
|
fn read_temp_mv(adc: &mut Adc<Ready>, vref_factor: f32) -> f32 {
|
|
let bare: f32 = adc.read(&mut VTemp).expect("could not read with adc");
|
|
bare * vref_factor
|
|
}
|
|
|
|
// This unholy abomination is from the datasheet and does not actually look so bad if it's written
|
|
// in Math instead of Rust.
|
|
fn temp_mv_to_c(temp: f32, ts_cal_1: (i32, u16), ts_cal_2: (i32, u16)) -> f32 {
|
|
((ts_cal_2.0 as f32 - ts_cal_1.0 as f32) / (ts_cal_2.1 as f32 - ts_cal_1.1 as f32))
|
|
* (temp - ts_cal_1.1 as f32)
|
|
+ ts_cal_1.0 as f32
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
// run these tests: cargo test --example=temperature --target=x86_64-unknown-linux-gnu
|
|
use super::temp_mv_to_c;
|
|
|
|
#[test]
|
|
fn test_mv_to_c() {
|
|
// values read out from my board as logged
|
|
// after flashing and running
|
|
//
|
|
// First is the temperature for that calibratoin, second is the measured voltage at that
|
|
// temperature
|
|
let calibration_data = [(30, 673), (130, 912)];
|
|
for caldat in calibration_data {
|
|
let degrees: f32 =
|
|
temp_mv_to_c(caldat.1 as f32, calibration_data[0], calibration_data[1]);
|
|
assert_eq!(caldat.0 as f32, degrees);
|
|
dbg!(caldat);
|
|
dbg!(degrees);
|
|
}
|
|
}
|
|
}
|