C3MA/PlantCtrl
6
0
Fork 0
Code Issues 7 Pull Requests Packages Projects Releases Wiki Activity

clippy: fix clippy warnings

Browse Source
This commit is contained in:
Empire Phoenix
2026-05-25 20:11:58 +02:00
parent 7078af5713
commit 7679fa09dc
11 changed files with 48 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
Software/MainBoard/rust/src/hal/esp.rs
View File

@@ -1,23 +1,17 @@
use crate::bail;
use crate::config::{NetworkConfig, PlantControllerConfig};
use crate::config::{PlantControllerConfig};
use crate::hal::savegame_manager::SavegameManager;
use crate::hal::PLANT_COUNT;
use crate::log::{log, LogMessage};
use chrono::{DateTime, Utc};
use crate::fat_error::{ContextExt, FatError, FatResult};
use crate::fat_error::{FatError, FatResult};
use crate::hal::shared_flash::MutexFlashStorage;
use alloc::string::ToString;
use alloc::sync::Arc;
use alloc::{format, string::String, vec, vec::Vec};
use core::net::{IpAddr, Ipv4Addr, SocketAddr};
use core::sync::atomic::Ordering;
use embassy_executor::Spawner;
use embassy_net::{DhcpConfig, IpAddress, Ipv4Cidr, Runner, Stack, StackResources, StaticConfigV4};
use alloc::{string::String, vec, vec::Vec};
use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
use embassy_sync::mutex::Mutex;
use embassy_sync::once_lock::OnceLock;
use embassy_time::{Duration, Timer, WithTimeout};
use embedded_storage::nor_flash::{check_erase, NorFlash, ReadNorFlash, RmwNorFlashStorage};
use esp_bootloader_esp_idf::ota::OtaImageState::Valid;
use esp_bootloader_esp_idf::ota::{Ota, OtaImageState};
@@ -31,15 +25,11 @@ use esp_hal::rtc_cntl::{
use esp_hal::system::software_reset;
use esp_hal::uart::Uart;
use esp_hal::Blocking;
use esp_println::println;
use esp_radio::wifi::ap::{AccessPointConfig, AccessPointInfo};
use esp_radio::wifi::ap::{AccessPointInfo};
use esp_radio::wifi::scan::{ScanConfig, ScanTypeConfig};
use esp_radio::wifi::sta::StationConfig;
use esp_radio::wifi::{AuthenticationMethod, Config, Interface, WifiController};
use log::{error, info, warn};
use portable_atomic::AtomicBool;
use esp_radio::wifi::{Interface, WifiController};
use log::{error, info};
use crate::network::{net_task, run_dhcp};
#[esp_hal::ram(unstable(rtc_fast), unstable(persistent))]
static mut LAST_WATERING_TIMESTAMP: [i64; PLANT_COUNT] = [0; PLANT_COUNT];

2
Software/MainBoard/rust/src/hal/mod.rs
View File

@@ -141,7 +141,7 @@ pub struct HAL<'a> {
#[async_trait(?Send)]
pub trait BoardInteraction<'a> {
fn get_tank_sensor(&mut self) -> Result<&mut TankSensor<'a>, FatError>;
fn get_tank_sensor(&mut self) -> &mut TankSensor<'a>;
fn get_esp(&mut self) -> &mut Esp<'a>;
fn get_config(&mut self) -> &PlantControllerConfig;
fn get_battery_monitor(&mut self) -> &mut Box<dyn BatteryInteraction + Send>;

4
Software/MainBoard/rust/src/hal/v4_hal.rs
View File

@@ -300,8 +300,8 @@ pub(crate) async fn create_v4(
#[async_trait(?Send)]
impl<'a> BoardInteraction<'a> for V4<'a> {
fn get_tank_sensor(&mut self) -> Result<&mut TankSensor<'a>, FatError> {
Ok(&mut self.tank_sensor)
fn get_tank_sensor(&mut self) -> &mut TankSensor<'a> {
&mut self.tank_sensor
}
fn get_esp(&mut self) -> &mut Esp<'a> {

11
Software/MainBoard/rust/src/hal/water.rs
View File

@@ -7,10 +7,10 @@ use esp_hal::delay::Delay;
use esp_hal::gpio::{DriveMode, Flex, Input, InputConfig, Output, OutputConfig, Pull};
use esp_hal::pcnt::channel::CtrlMode::Keep;
use esp_hal::pcnt::channel::EdgeMode::{Hold, Increment};
use esp_hal::pcnt::unit::Unit;
use esp_hal::pcnt::unit::{Unit};
use esp_hal::peripherals::GPIO5;
use esp_hal::Async;
use log::info;
use log::{error, info};
use onewire::{ds18b20, Device, DeviceSearch, OneWire, DS18B20};
use portable_atomic::{AtomicUsize, Ordering};
@@ -61,7 +61,12 @@ impl<'a> TankSensor<'a> {
info!("tank: pcnt high limit ok");
// Reject pulses shorter than ~12.8 µs (1023 APB cycles @ 80 MHz) to suppress EMI noise
// on the sensor cable. Real flow pulses are in the millisecond range.
pcnt1.set_filter(Some(1023)).unwrap();
match pcnt1.set_filter(Some(1023)) {
Ok(_) => {}
Err(err) => {
error!("tank: failed to set pcnt filter: {:?}", err);
}
}
let ch0 = &pcnt1.channel0;
ch0.set_edge_signal(flow_sensor.peripheral_input());

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

@@ -15,23 +15,23 @@ esp_bootloader_esp_idf::esp_app_desc!();
use esp_backtrace as _;
use crate::hal::PROGRESS_ACTIVE;
use crate::config::{NetworkConfig, PlantConfig, PlantControllerConfig};
use crate::config::{PlantConfig, PlantControllerConfig};
use crate::fat_error::{ContextExt, FatResult};
use crate::log::log;
use crate::tank::{determine_tank_state, TankError, TankState, WATER_FROZEN_THRESH};
use crate::tank::{determine_tank_state, TankError, WATER_FROZEN_THRESH};
use crate::webserver::http_server;
use crate::{
config::BoardVersion::Initial,
hal::{PlantHal, HAL, PLANT_COUNT},
};
use ::log::{error, info, warn};
use ::log::{error, info};
use alloc::borrow::ToOwned;
use alloc::string::{String, ToString};
use alloc::sync::Arc;
use alloc::vec::Vec;
use alloc::{format, vec};
use chrono::{DateTime, Datelike, Timelike, Utc};
use chrono::{DateTime, Datelike, Timelike};
use chrono_tz::Tz::{self, UTC};
use core::sync::atomic::{AtomicBool, Ordering};
use embassy_executor::Spawner;
@@ -42,8 +42,8 @@ use embassy_sync::once_lock::OnceLock;
use embassy_time::{Duration, Instant, Timer};
use esp_hal::rom::ets_delay_us;
use esp_hal::system::software_reset;
use esp_println::{logger, println};
use hal::battery::{BatteryError, BatteryInfo, BatteryState};
use esp_println::{println};
use hal::battery::{BatteryState};
use log::LogMessage;
use option_lock::OptionLock;
use plant_state::PlantState;
@@ -275,7 +275,7 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
);
if let network::NetworkMode::WIFI { ref ip_address, .. } = network_mode {
mqtt::publish_firmware_info(&mut board, version, ip_address, &timezone_time.to_rfc3339()).await;
mqtt::publish_firmware_info(version, ip_address, &timezone_time.to_rfc3339()).await;
mqtt::publish_battery_state(&mut board).await.unwrap_or_else(|e| {
error!("Error publishing battery state {e}");
});
@@ -354,10 +354,7 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
}
let mut water_frozen = false;
let water_temp: FatResult<f32> = match board.board_hal.get_tank_sensor() {
Ok(sensor) => sensor.water_temperature_c().await,
Err(e) => Err(e),
};
let water_temp: FatResult<f32> = board.board_hal.get_tank_sensor().water_temperature_c().await;
if let Ok(res) = water_temp {
if res < WATER_FROZEN_THRESH {
@@ -437,7 +434,6 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
//state.active = true;
mqtt::pump_info(
&mut board,
plant_id,
true,
pump_ineffective,
@@ -455,7 +451,6 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
Ok(state) => {
overcurrent_results[plant_id] = state.overcurrent_ma;
mqtt::pump_info(
&mut board,
plant_id,
false,
pump_ineffective,
@@ -470,7 +465,6 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
}
Err(err) => {
mqtt::pump_info(
&mut board,
plant_id,
false,
pump_ineffective,
@@ -743,13 +737,13 @@ pub async fn do_secure_pump(
}
}
board.board_hal.get_tank_sensor()?.reset_flow_meter();
board.board_hal.get_tank_sensor()?.start_flow_meter();
board.board_hal.get_tank_sensor().reset_flow_meter();
board.board_hal.get_tank_sensor().start_flow_meter();
board.board_hal.pump(plant_id, true).await?;
for step in 0..steps_in_50ms {
let step_start = Instant::now();
let flow_value = board.board_hal.get_tank_sensor()?.get_full_flow_count();
let flow_value = board.board_hal.get_tank_sensor().get_full_flow_count();
flow_collector[step] = flow_value;
let flow_value_ml = flow_value as f32 * board.board_hal.get_config().tank.ml_per_pulse;
@@ -860,8 +854,8 @@ pub async fn do_secure_pump(
//noticable dummy value
pump_time_ms = 1337;
}
board.board_hal.get_tank_sensor()?.stop_flow_meter();
let final_flow_value = board.board_hal.get_tank_sensor()?.get_full_flow_count();
board.board_hal.get_tank_sensor().stop_flow_meter();
let final_flow_value = board.board_hal.get_tank_sensor().get_full_flow_count();
let flow_value_ml = final_flow_value as f32 * board.board_hal.get_config().tank.ml_per_pulse;
info!("Final flow value is {final_flow_value} with {flow_value_ml} ml");
current_collector.sort();

13
Software/MainBoard/rust/src/mqtt.rs
View File

@@ -17,7 +17,7 @@ use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
use embassy_sync::mutex::MutexGuard;
use embassy_sync::once_lock::OnceLock;
use embassy_time::{Duration, Timer, WithTimeout};
use log::{info, warn};
use log::{error, info, warn};
use mcutie::{
Error, McutieBuilder, McutieReceiver, McutieTask, MqttMessage, PublishDisplay, Publishable,
QoS, Topic,
@@ -266,7 +266,7 @@ pub async fn publish_tank_state(
let state = serde_json::to_string(
&tank_state.as_mqtt_info(&board.board_hal.get_config().tank, &water_temp),
)?;
let _ = publish("/water", &*state).await;
let _ = publish("/water", &state).await;
Ok(())
}
@@ -288,13 +288,16 @@ pub async fn publish_plant_states(
}
pub async fn publish_firmware_info(
board: &mut MutexGuard<'_, CriticalSectionRawMutex, HAL<'static>>,
version: VersionInfo,
ip_address: &str,
timezone_time: &str,
) {
publish("/firmware/address", ip_address).await;
publish("/firmware/state", &serde_json::to_string(&version).unwrap()).await;
let version = &serde_json::to_string(&version);
match version {
Ok(version_str) => publish("/firmware/state", version_str).await,
Err(e) => error!("Failed to serialize version info: {}", e),
}
publish("/firmware/last_online", timezone_time).await;
publish("/state", "online").await;
}
@@ -312,8 +315,8 @@ pub struct PumpInfo {
pub flow_ml: f32,
}
#[allow(clippy::too_many_arguments)]
pub async fn pump_info(
board: &mut MutexGuard<'_, CriticalSectionRawMutex, HAL<'static>>,
plant_id: usize,
pump_active: bool,
pump_ineffective: bool,

4
Software/MainBoard/rust/src/network.rs
View File

@@ -1,7 +1,7 @@
use crate::bail;
use crate::config::NetworkConfig;
use crate::fat_error::{ContextExt, FatError, FatResult};
use crate::hal::{PlantHal, HAL};
use crate::hal::{HAL};
use crate::mqtt;
use crate::util::mk_static;
use alloc::string::{String, ToString};
@@ -142,12 +142,14 @@ pub async fn sntp(max_wait_ms: u32, stack: Stack<'_>) -> FatResult<DateTime<Utc>
}
#[derive(Serialize, Debug, PartialEq)]
#[allow(clippy::upper_case_acronyms)]
pub enum SntpMode {
OFFLINE,
SYNC { current: DateTime<Utc> },
}
#[derive(Serialize, Debug, PartialEq)]
#[allow(clippy::upper_case_acronyms)]
pub enum NetworkMode {
WIFI {
sntp: SntpMode,

4
Software/MainBoard/rust/src/plant_state.rs
View File

@@ -1,6 +1,5 @@
use crate::hal::Moistures;
use crate::{config::PlantConfig, hal::HAL, in_time_range};
use alloc::string::String;
use chrono::{DateTime, TimeDelta, Utc};
use chrono_tz::Tz;
use serde::{Deserialize, Serialize};
@@ -14,8 +13,7 @@ pub enum MoistureSensorError {
MissingMessage,
NotExpectedMessage { hz: f32 },
ShortCircuit { hz: f32, max: f32 },
OpenLoop { hz: f32, min: f32 },
BoardError { message: String },
OpenLoop { hz: f32, min: f32 }
}
#[derive(Debug, PartialEq, Serialize)]

7
Software/MainBoard/rust/src/tank.rs
View File

@@ -161,10 +161,11 @@ pub async fn determine_tank_state(
if board.board_hal.get_config().tank.tank_sensor_enabled {
match board
.board_hal
.get_tank_sensor()
.and_then(|f| core::prelude::v1::Ok(f.tank_sensor_voltage()))
.get_tank_sensor().tank_sensor_voltage().await
{
Ok(raw_sensor_value_mv) => TankState::Present(raw_sensor_value_mv.await.unwrap()),
Ok(raw_sensor_value_mv) => {
TankState::Present(raw_sensor_value_mv)
},
Err(err) => TankState::Error(TankError::BoardError { message: err.to_string() }),
}
} else {

2
Software/MainBoard/rust/src/util.rs
View File

@@ -2,7 +2,7 @@ macro_rules! mk_static {
($t:ty,$val:expr) => {{
static STATIC_CELL: static_cell::StaticCell<$t> = static_cell::StaticCell::new();
#[deny(unused_attributes)]
let x = STATIC_CELL.uninit().write(($val));
let x = STATIC_CELL.uninit().write($val);
x
}};
}

5
Software/MainBoard/rust/src/webserver/get_json.rs
View File

@@ -80,10 +80,7 @@ where
{
let mut board = BOARD_ACCESS.get().await.lock().await;
let tank_state = determine_tank_state(&mut board).await;
//should be multisampled
let sensor = board.board_hal.get_tank_sensor()?;
let water_temp: FatResult<f32> = sensor.water_temperature_c().await;
let water_temp: FatResult<f32> = board.board_hal.get_tank_sensor().water_temperature_c().await;
Ok(Some(serde_json::to_string(&tank_state.as_mqtt_info(
&board.board_hal.get_config().tank,
&water_temp,