forked from M-Labs/thermostat
atse
069d791802
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.
281 lines
9.5 KiB
Rust
281 lines
9.5 KiB
Rust
#![cfg_attr(not(test), no_std)]
|
|
#![cfg_attr(not(test), no_main)]
|
|
#![cfg_attr(test, allow(unused))]
|
|
// TODO: #![deny(warnings, unused)]
|
|
|
|
#[cfg(not(any(feature = "semihosting", test)))]
|
|
use panic_halt as _;
|
|
#[cfg(all(feature = "semihosting", not(test)))]
|
|
use panic_semihosting as _;
|
|
|
|
use cortex_m::asm::wfi;
|
|
use cortex_m_rt::entry;
|
|
use log::{error, info, warn};
|
|
use smoltcp::{socket::TcpSocket, time::Instant, wire::EthernetAddress};
|
|
use stm32f4xx_hal::{
|
|
hal::watchdog::{Watchdog, WatchdogEnable},
|
|
rcc::RccExt,
|
|
stm32::{CorePeripherals, Peripherals, SCB},
|
|
time::{MegaHertz, U32Ext},
|
|
watchdog::IndependentWatchdog,
|
|
};
|
|
|
|
mod init_log;
|
|
use init_log::init_log;
|
|
mod leds;
|
|
mod pins;
|
|
mod usb;
|
|
use pins::Pins;
|
|
mod ad5680;
|
|
mod ad7172;
|
|
mod net;
|
|
mod server;
|
|
use server::Server;
|
|
mod session;
|
|
use session::{Session, SessionInput};
|
|
mod command_parser;
|
|
use command_parser::Ipv4Config;
|
|
mod b_parameter;
|
|
mod channels;
|
|
mod pid;
|
|
mod timer;
|
|
use channels::{Channels, CHANNELS};
|
|
mod channel;
|
|
mod channel_state;
|
|
mod config;
|
|
use config::ChannelConfig;
|
|
mod command_handler;
|
|
mod dfu;
|
|
mod flash_store;
|
|
use command_handler::Handler;
|
|
mod fan_ctrl;
|
|
use fan_ctrl::FanCtrl;
|
|
mod hw_rev;
|
|
|
|
const HSE: MegaHertz = MegaHertz(8);
|
|
#[cfg(not(feature = "semihosting"))]
|
|
const WATCHDOG_INTERVAL: u32 = 1_000;
|
|
#[cfg(feature = "semihosting")]
|
|
const WATCHDOG_INTERVAL: u32 = 30_000;
|
|
|
|
const CHANNEL_CONFIG_KEY: [&str; 2] = ["ch0", "ch1"];
|
|
|
|
const TCP_PORT: u16 = 23;
|
|
|
|
fn send_line(socket: &mut TcpSocket, data: &[u8]) -> bool {
|
|
let send_free = socket.send_capacity() - socket.send_queue();
|
|
if data.len() > send_free + 1 {
|
|
// Not enough buffer space, skip report for now,
|
|
// instead of sending incomplete line
|
|
warn!(
|
|
"TCP socket has only {}/{} needed {}",
|
|
send_free + 1,
|
|
socket.send_capacity(),
|
|
data.len(),
|
|
);
|
|
} else {
|
|
match socket.send_slice(data) {
|
|
Ok(sent) if sent == data.len() => {
|
|
let _ = socket.send_slice(b"\n");
|
|
// success
|
|
return true;
|
|
}
|
|
Ok(sent) => warn!("sent only {}/{} bytes", sent, data.len()),
|
|
Err(e) => error!("error sending line: {:?}", e),
|
|
}
|
|
}
|
|
// not success
|
|
false
|
|
}
|
|
|
|
/// Initialization and main loop
|
|
#[cfg(not(test))]
|
|
#[entry]
|
|
fn main() -> ! {
|
|
init_log();
|
|
info!("thermostat");
|
|
|
|
let mut cp = CorePeripherals::take().unwrap();
|
|
cp.SCB.enable_icache();
|
|
cp.SCB.enable_dcache(&mut cp.CPUID);
|
|
|
|
let dp = Peripherals::take().unwrap();
|
|
let clocks = dp
|
|
.RCC
|
|
.constrain()
|
|
.cfgr
|
|
.use_hse(HSE)
|
|
.sysclk(168.mhz())
|
|
.hclk(168.mhz())
|
|
.pclk1(32.mhz())
|
|
.pclk2(64.mhz())
|
|
.freeze();
|
|
|
|
let mut wd = IndependentWatchdog::new(dp.IWDG);
|
|
wd.start(WATCHDOG_INTERVAL.ms());
|
|
wd.feed();
|
|
|
|
timer::setup(cp.SYST, clocks);
|
|
|
|
let (pins, mut leds, mut eeprom, eth_pins, usb, fan, hwrev, hw_settings) = Pins::setup(
|
|
clocks,
|
|
(dp.TIM1, dp.TIM3, dp.TIM8),
|
|
(
|
|
dp.GPIOA, dp.GPIOB, dp.GPIOC, dp.GPIOD, dp.GPIOE, dp.GPIOF, dp.GPIOG,
|
|
),
|
|
dp.I2C1,
|
|
(dp.SPI2, dp.SPI4, dp.SPI5),
|
|
dp.ADC1,
|
|
(dp.OTG_FS_GLOBAL, dp.OTG_FS_DEVICE, dp.OTG_FS_PWRCLK),
|
|
);
|
|
|
|
leds.r1.on();
|
|
leds.g3.off();
|
|
leds.g4.off();
|
|
|
|
usb::State::setup(usb);
|
|
|
|
let mut store = flash_store::store(dp.FLASH);
|
|
|
|
let mut channels = Channels::new(pins);
|
|
for (c, key) in CHANNEL_CONFIG_KEY.iter().enumerate().take(CHANNELS) {
|
|
match store.read_value::<ChannelConfig>(key) {
|
|
Ok(Some(config)) => config.apply(&mut channels, c),
|
|
Ok(None) => error!("flash config not found for channel {}", c),
|
|
Err(e) => error!("unable to load config {} from flash: {:?}", c, e),
|
|
}
|
|
}
|
|
|
|
let mut fan_ctrl = FanCtrl::new(fan, hw_settings);
|
|
|
|
// default net config:
|
|
let mut ipv4_config = Ipv4Config {
|
|
address: [192, 168, 1, 26],
|
|
mask_len: 24,
|
|
gateway: None,
|
|
};
|
|
match store.read_value("ipv4") {
|
|
Ok(Some(config)) => ipv4_config = config,
|
|
Ok(None) => {}
|
|
Err(e) => error!("cannot read ipv4 config: {:?}", e),
|
|
}
|
|
|
|
// EEPROM ships with a read-only EUI-48 identifier
|
|
let mut eui48 = [0; 6];
|
|
eeprom.read_data(0xFA, &mut eui48).unwrap();
|
|
let hwaddr = EthernetAddress(eui48);
|
|
info!("EEPROM MAC address: {}", hwaddr);
|
|
|
|
net::run(
|
|
clocks,
|
|
dp.ETHERNET_MAC,
|
|
dp.ETHERNET_DMA,
|
|
eth_pins,
|
|
hwaddr,
|
|
ipv4_config.clone(),
|
|
|iface| {
|
|
Server::<Session>::run(iface, |server| {
|
|
leds.r1.off();
|
|
let mut should_reset = false;
|
|
|
|
loop {
|
|
let mut new_ipv4_config = None;
|
|
let instant = Instant::from_millis(i64::from(timer::now()));
|
|
channels.poll_adc(instant);
|
|
|
|
fan_ctrl.cycle(channels.current_abs_max_tec_i());
|
|
|
|
if channels.pid_engaged() {
|
|
leds.g3.on();
|
|
} else {
|
|
leds.g3.off();
|
|
}
|
|
|
|
let instant = Instant::from_millis(i64::from(timer::now()));
|
|
cortex_m::interrupt::free(net::clear_pending);
|
|
server.poll(instant).unwrap_or_else(|e| {
|
|
warn!("poll: {:?}", e);
|
|
});
|
|
|
|
if !should_reset {
|
|
// TCP protocol handling
|
|
server.for_each(|mut socket, session| {
|
|
if !socket.is_active() {
|
|
let _ = socket.listen(TCP_PORT);
|
|
session.reset();
|
|
} else if socket.may_send() && !socket.may_recv() {
|
|
socket.close()
|
|
} else if socket.can_send() && socket.can_recv() {
|
|
match socket.recv(|buf| session.feed(buf)) {
|
|
// SessionInput::Nothing happens when the line reader parses a string of characters that is not
|
|
// followed by a newline character. Could be due to partial commands not terminated with newline,
|
|
// socket RX ring buffer wraps around, or when the command is sent as seperate TCP packets etc.
|
|
// Do nothing and feed more data to the line reader in the next loop cycle.
|
|
Ok(SessionInput::Nothing) => {}
|
|
Ok(SessionInput::Command(command)) => {
|
|
match Handler::handle_command(
|
|
command,
|
|
&mut socket,
|
|
&mut channels,
|
|
&mut store,
|
|
&mut ipv4_config,
|
|
&mut fan_ctrl,
|
|
hwrev,
|
|
) {
|
|
Ok(Handler::NewIPV4(ip)) => new_ipv4_config = Some(ip),
|
|
Ok(Handler::Handled) => {}
|
|
Ok(Handler::CloseSocket) => socket.close(),
|
|
Ok(Handler::Reset) => should_reset = true,
|
|
Err(_) => {}
|
|
}
|
|
}
|
|
Ok(SessionInput::Error(e)) => {
|
|
error!("session input: {:?}", e);
|
|
send_line(&mut socket, b"{ \"error\": \"invalid input\" }");
|
|
}
|
|
Err(_) => socket.close(),
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
// Should reset, close all TCP sockets.
|
|
let mut any_socket_alive = false;
|
|
server.for_each(|mut socket, _| {
|
|
if socket.is_active() {
|
|
socket.abort();
|
|
any_socket_alive = true;
|
|
}
|
|
});
|
|
// Must let loop run for one more cycle to poll server for RST to be sent,
|
|
// this makes sure system does not reset right after socket.abort() is called.
|
|
if !any_socket_alive {
|
|
SCB::sys_reset();
|
|
}
|
|
}
|
|
|
|
// Apply new IPv4 address/gateway
|
|
if let Some(config) = new_ipv4_config.take() {
|
|
server.set_ipv4_config(config.clone());
|
|
ipv4_config = config;
|
|
};
|
|
|
|
// Update watchdog
|
|
wd.feed();
|
|
|
|
leds.g4.off();
|
|
cortex_m::interrupt::free(|cs| {
|
|
if !net::is_pending(cs) {
|
|
// Wait for interrupts
|
|
// (Ethernet, SysTick, or USB)
|
|
wfi();
|
|
}
|
|
});
|
|
leds.g4.on();
|
|
}
|
|
});
|
|
},
|
|
);
|
|
|
|
unreachable!()
|
|
}
|