C3MA/PlantCtrl
5
0
Fork 0
Code Issues 8 Pull Requests Packages Projects Releases Wiki Activity

chore: 📎 + fmt

Browse Source
This commit is contained in:
ju6ge
2025-10-18 20:40:38 +02:00
parent 6357ec773f
commit 1db3f7af64
26 changed files with 548 additions and 578 deletions
Download Patch File Download Diff File Expand all files Collapse all files

198
Software/MainBoard/rust/src/main.rs
View File

@@ -16,13 +16,13 @@ use esp_backtrace as _;
use crate::config::{NetworkConfig, PlantConfig};
use crate::fat_error::FatResult;
use crate::hal::esp::MQTT_STAY_ALIVE;
use crate::hal::{esp_time, TIME_ACCESS};
use crate::hal::PROGRESS_ACTIVE;
use crate::hal::{esp_time, TIME_ACCESS};
use crate::log::{log, LOG_ACCESS};
use crate::tank::{determine_tank_state, TankError, TankState, WATER_FROZEN_THRESH};
use crate::webserver::http_server;
use crate::{
config::BoardVersion::INITIAL,
config::BoardVersion::Initial,
hal::{PlantHal, HAL, PLANT_COUNT},
};
use ::log::{info, warn};
@@ -136,18 +136,18 @@ pub struct PumpResult {
#[derive(Serialize, Debug, PartialEq)]
enum SntpMode {
OFFLINE,
SYNC { current: DateTime<Utc> },
Offline,
Sync { current: DateTime<Utc> },
}
#[derive(Serialize, Debug, PartialEq)]
enum NetworkMode {
WIFI {
Wifi {
sntp: SntpMode,
mqtt: bool,
ip_address: String,
},
OFFLINE,
Offline,
}
async fn safe_main(spawner: Spawner) -> FatResult<()> {
@@ -172,7 +172,7 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
value
}
Err(err) => {
info!("rtc module error: {:?}", err);
info!("rtc module error: {err:?}");
board.board_hal.general_fault(true).await;
esp_time().await
}
@@ -187,7 +187,7 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
.log(LogMessage::YearInplausibleForceConfig, 0, 0, "", "")
.await;
}
info!("cur is {}", cur);
info!("cur is {cur}");
update_charge_indicator(&mut board).await;
if board.board_hal.get_esp().get_restart_to_conf() {
LOG_ACCESS
@@ -228,7 +228,7 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
info!("no mode override");
}
if board.board_hal.get_config().hardware.board == INITIAL
if board.board_hal.get_config().hardware.board == Initial
&& board.board_hal.get_config().network.ssid.is_none()
{
info!("No wifi configured, starting initial config mode");
@@ -249,10 +249,10 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
info!("No wifi configured");
//the current sensors require this amount to stabilize, in the case of Wi-Fi this is already handled due to connect timings;
Timer::after_millis(100).await;
NetworkMode::OFFLINE
NetworkMode::Offline
};
if matches!(network_mode, NetworkMode::OFFLINE) && to_config {
if matches!(network_mode, NetworkMode::Offline) && to_config {
info!("Could not connect to station and config mode forced, switching to ap mode!");
let res = {
@@ -264,14 +264,14 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
stack.replace(ap_stack);
info!("Started ap, continuing")
}
Err(err) => info!("Could not start config override ap mode due to {}", err),
Err(err) => info!("Could not start config override ap mode due to {err}"),
}
}
let tz = &board.board_hal.get_config().timezone;
let timezone = match tz {
Some(tz_str) => tz_str.parse::<Tz>().unwrap_or_else(|_| {
info!("Invalid timezone '{}', falling back to UTC", tz_str);
info!("Invalid timezone '{tz_str}', falling back to UTC");
UTC
}),
None => UTC, // Fallback to UTC if no timezone is set
@@ -286,7 +286,7 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
timezone_time
);
if let NetworkMode::WIFI { ref ip_address, .. } = network_mode {
if let NetworkMode::Wifi { ref ip_address, .. } = network_mode {
publish_firmware_info(&mut board, version, ip_address, &timezone_time.to_rfc3339()).await;
publish_battery_state(&mut board).await;
let _ = publish_mppt_state(&mut board).await;
@@ -297,15 +297,15 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
.await
.log(
LogMessage::StartupInfo,
matches!(network_mode, NetworkMode::WIFI { .. }) as u32,
matches!(network_mode, NetworkMode::Wifi { .. }) as u32,
matches!(
network_mode,
NetworkMode::WIFI {
sntp: SntpMode::SYNC { .. },
NetworkMode::Wifi {
sntp: SntpMode::Sync { .. },
..
}
) as u32,
matches!(network_mode, NetworkMode::WIFI { mqtt: true, .. })
matches!(network_mode, NetworkMode::Wifi { mqtt: true, .. })
.to_string()
.as_str(),
"",
@@ -356,7 +356,7 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
LogMessage::TankSensorValueRangeError,
min as u32,
max as u32,
&format!("{}", value),
&format!("{value}"),
"",
)
.await
@@ -402,14 +402,14 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
let moisture = board.board_hal.measure_moisture_hz().await?;
let plantstate: [PlantState; PLANT_COUNT] = [
PlantState::read_hardware_state(moisture,0, &mut board).await,
PlantState::read_hardware_state(moisture,1, &mut board).await,
PlantState::read_hardware_state(moisture,2, &mut board).await,
PlantState::read_hardware_state(moisture,3, &mut board).await,
PlantState::read_hardware_state(moisture,4, &mut board).await,
PlantState::read_hardware_state(moisture,5, &mut board).await,
PlantState::read_hardware_state(moisture,6, &mut board).await,
PlantState::read_hardware_state(moisture,7, &mut board).await,
PlantState::read_hardware_state(moisture, 0, &mut board).await,
PlantState::read_hardware_state(moisture, 1, &mut board).await,
PlantState::read_hardware_state(moisture, 2, &mut board).await,
PlantState::read_hardware_state(moisture, 3, &mut board).await,
PlantState::read_hardware_state(moisture, 4, &mut board).await,
PlantState::read_hardware_state(moisture, 5, &mut board).await,
PlantState::read_hardware_state(moisture, 6, &mut board).await,
PlantState::read_hardware_state(moisture, 7, &mut board).await,
];
publish_plant_states(&mut board, &timezone_time.clone(), &plantstate).await;
@@ -507,7 +507,7 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
.await
.unwrap_or(BatteryState::Unknown);
info!("Battery state is {:?}", battery_state);
info!("Battery state is {battery_state:?}");
let mut light_state = LightState {
enabled: board.board_hal.get_config().night_lamp.enabled,
..Default::default()
@@ -573,7 +573,7 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
board.board_hal.light(false).await?;
}
info!("Lightstate is {:?}", light_state);
info!("Lightstate is {light_state:?}");
}
match &serde_json::to_string(&light_state) {
@@ -585,7 +585,7 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
.await;
}
Err(err) => {
info!("Error publishing lightstate {}", err);
info!("Error publishing lightstate {err}");
}
};
@@ -616,7 +616,7 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
.mqtt_publish("/state", "sleep")
.await;
info!("Go to sleep for {} minutes", deep_sleep_duration_minutes);
info!("Go to sleep for {deep_sleep_duration_minutes} minutes");
//determine next event
//is light out of work trigger soon?
//is battery low ??
@@ -625,7 +625,7 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
//mark_app_valid();
let stay_alive = MQTT_STAY_ALIVE.load(Ordering::Relaxed);
info!("Check stay alive, current state is {}", stay_alive);
info!("Check stay alive, current state is {stay_alive}");
if stay_alive {
let reboot_now = Arc::new(AtomicBool::new(false));
@@ -679,49 +679,45 @@ pub async fn do_secure_pump(
let current_ma = current.as_milliamperes() as u16;
current_collector[step] = current_ma;
let high_current = current_ma > plant_config.max_pump_current_ma;
if high_current {
if first_error {
log(
LogMessage::PumpOverCurrent,
plant_id as u32 + 1,
current_ma as u32,
plant_config.max_pump_current_ma.to_string().as_str(),
step.to_string().as_str(),
)
.await;
board.board_hal.general_fault(true).await;
board.board_hal.fault(plant_id, true).await?;
if !plant_config.ignore_current_error {
error = true;
break;
}
first_error = false;
if high_current && first_error {
log(
LogMessage::PumpOverCurrent,
plant_id as u32 + 1,
current_ma as u32,
plant_config.max_pump_current_ma.to_string().as_str(),
step.to_string().as_str(),
)
.await;
board.board_hal.general_fault(true).await;
board.board_hal.fault(plant_id, true).await?;
if !plant_config.ignore_current_error {
error = true;
break;
}
first_error = false;
}
let low_current = current_ma < plant_config.min_pump_current_ma;
if low_current {
if first_error {
log(
LogMessage::PumpOpenLoopCurrent,
plant_id as u32 + 1,
current_ma as u32,
plant_config.min_pump_current_ma.to_string().as_str(),
step.to_string().as_str(),
)
.await;
board.board_hal.general_fault(true).await;
board.board_hal.fault(plant_id, true).await?;
if !plant_config.ignore_current_error {
error = true;
break;
}
first_error = false;
if low_current && first_error {
log(
LogMessage::PumpOpenLoopCurrent,
plant_id as u32 + 1,
current_ma as u32,
plant_config.min_pump_current_ma.to_string().as_str(),
step.to_string().as_str(),
)
.await;
board.board_hal.general_fault(true).await;
board.board_hal.fault(plant_id, true).await?;
if !plant_config.ignore_current_error {
error = true;
break;
}
first_error = false;
}
}
Err(err) => {
if !plant_config.ignore_current_error {
info!("Error getting pump current: {}", err);
info!("Error getting pump current: {err}");
log(
LogMessage::PumpMissingSensorCurrent,
plant_id as u32,
@@ -744,10 +740,7 @@ pub async fn do_secure_pump(
board.board_hal.get_tank_sensor()?.stop_flow_meter();
let final_flow_value = board.board_hal.get_tank_sensor()?.get_flow_meter_value();
let flow_value_ml = final_flow_value as f32 * board.board_hal.get_config().tank.ml_per_pulse;
info!(
"Final flow value is {} with {} ml",
final_flow_value, flow_value_ml
);
info!("Final flow value is {final_flow_value} with {flow_value_ml} ml");
current_collector.sort();
Ok(PumpResult {
median_current_ma: current_collector[current_collector.len() / 2],
@@ -767,7 +760,8 @@ async fn update_charge_indicator(
if let Ok(current) = board.board_hal.get_mptt_current().await {
let _ = board
.board_hal
.set_charge_indicator(current.as_milliamperes() > 20_f64);
.set_charge_indicator(current.as_milliamperes() > 20_f64)
.await;
}
//fallback to battery controller and ask it instead
else if let Ok(charging) = board
@@ -776,10 +770,10 @@ async fn update_charge_indicator(
.average_current_milli_ampere()
.await
{
let _ = board.board_hal.set_charge_indicator(charging > 20);
let _ = board.board_hal.set_charge_indicator(charging > 20).await;
} else {
//who knows
let _ = board.board_hal.set_charge_indicator(false);
let _ = board.board_hal.set_charge_indicator(false).await;
}
}
@@ -792,7 +786,11 @@ async fn publish_tank_state(
&tank_state.as_mqtt_info(&board.board_hal.get_config().tank, &water_temp),
)
.unwrap();
let _ = board.board_hal.get_esp().mqtt_publish("/water", &*state);
board
.board_hal
.get_esp()
.mqtt_publish("/water", &state)
.await;
}
async fn publish_plant_states(
@@ -819,16 +817,16 @@ async fn publish_plant_states(
async fn publish_firmware_info(
board: &mut MutexGuard<'_, CriticalSectionRawMutex, HAL<'static>>,
version: VersionInfo,
ip_address: &String,
timezone_time: &String,
ip_address: &str,
timezone_time: &str,
) {
let esp = board.board_hal.get_esp();
let _ = esp.mqtt_publish("/firmware/address", ip_address).await;
let _ = esp
.mqtt_publish("/firmware/state", format!("{:?}", &version).as_str())
esp.mqtt_publish("/firmware/address", ip_address).await;
esp.mqtt_publish("/firmware/state", format!("{:?}", &version).as_str())
.await;
let _ = esp.mqtt_publish("/firmware/last_online", timezone_time);
let _ = esp.mqtt_publish("/state", "online").await;
esp.mqtt_publish("/firmware/last_online", timezone_time)
.await;
esp.mqtt_publish("/state", "online").await;
}
macro_rules! mk_static {
($t:ty,$val:expr) => {{
@@ -847,21 +845,20 @@ async fn try_connect_wifi_sntp_mqtt(
Ok(stack) => {
stack_store.replace(stack);
let sntp_mode: SntpMode = match board
.board_hal
.get_esp()
.sntp(1000 * 10, stack.clone())
.await
{
let sntp_mode: SntpMode = match board.board_hal.get_esp().sntp(1000 * 10, stack).await {
Ok(new_time) => {
info!("Using time from sntp {}", new_time.to_rfc3339());
let _ = board.board_hal.get_rtc_module().set_rtc_time(&new_time);
SntpMode::SYNC { current: new_time }
let _ = board
.board_hal
.get_rtc_module()
.set_rtc_time(&new_time)
.await;
SntpMode::Sync { current: new_time }
}
Err(err) => {
warn!("sntp error: {}", err);
warn!("sntp error: {err}");
board.board_hal.general_fault(true).await;
SntpMode::OFFLINE
SntpMode::Offline
}
};
@@ -874,23 +871,23 @@ async fn try_connect_wifi_sntp_mqtt(
true
}
Err(err) => {
warn!("Could not connect mqtt due to {}", err);
warn!("Could not connect mqtt due to {err}");
false
}
}
} else {
false
};
NetworkMode::WIFI {
NetworkMode::Wifi {
sntp: sntp_mode,
mqtt: mqtt_connected,
ip_address: stack.hardware_address().to_string(),
}
}
Err(err) => {
info!("Offline mode due to {}", err);
info!("Offline mode due to {err}");
board.board_hal.general_fault(true).await;
NetworkMode::OFFLINE
NetworkMode::Offline
}
}
}
@@ -926,7 +923,7 @@ async fn pump_info(
.await;
}
Err(err) => {
warn!("Error publishing pump state {}", err);
warn!("Error publishing pump state {err}");
}
};
}
@@ -941,10 +938,11 @@ async fn publish_mppt_state(
voltage_ma: voltage.as_millivolts() as u32,
};
if let Ok(serialized_solar_state_bytes) = serde_json::to_string(&solar_state) {
let _ = board
board
.board_hal
.get_esp()
.mqtt_publish("/mppt", &serialized_solar_state_bytes);
.mqtt_publish("/mppt", &serialized_solar_state_bytes)
.await;
}
Ok(())
}
@@ -968,7 +966,7 @@ async fn publish_battery_state(
let _ = board
.board_hal
.get_esp()
.mqtt_publish("/battery", &*value)
.mqtt_publish("/battery", &value)
.await;
}
}