clippy: fix clippy warnings

Software/MainBoard/rust/src/hal/esp.rs

@@ -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 alloc::{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 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::{AccessPointInfo};
-use esp_radio::wifi::ap::{AccessPointConfig, AccessPointInfo};
 use esp_radio::wifi::scan::{ScanConfig, ScanTypeConfig};
-use esp_radio::wifi::sta::StationConfig;
+use esp_radio::wifi::{Interface, WifiController};
-use esp_radio::wifi::{AuthenticationMethod, Config, Interface, WifiController};
+use log::{error, info};
-use log::{error, info, warn};
-use portable_atomic::AtomicBool;
 
-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];

Software/MainBoard/rust/src/hal/mod.rs

@@ -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>;

Software/MainBoard/rust/src/hal/v4_hal.rs

@@ -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> {
+    fn get_tank_sensor(&mut self) -> &mut TankSensor<'a> {
-        Ok(&mut self.tank_sensor)
+        &mut self.tank_sensor
     }
 
     fn get_esp(&mut self) -> &mut Esp<'a> {

Software/MainBoard/rust/src/hal/water.rs

@@ -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());

Software/MainBoard/rust/src/main.rs

@@ -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 esp_println::{println};
-use hal::battery::{BatteryError, BatteryInfo, BatteryState};
+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() {
+    let water_temp: FatResult<f32> = board.board_hal.get_tank_sensor().water_temperature_c().await;
-        Ok(sensor) => sensor.water_temperature_c().await,
-        Err(e) => Err(e),
-    };
 
     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().reset_flow_meter();
-        board.board_hal.get_tank_sensor()?.start_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();
+    board.board_hal.get_tank_sensor().stop_flow_meter();
-    let final_flow_value = board.board_hal.get_tank_sensor()?.get_full_flow_count();
+    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();

Software/MainBoard/rust/src/mqtt.rs

@@ -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,

Software/MainBoard/rust/src/network.rs

@@ -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,

Software/MainBoard/rust/src/plant_state.rs

@@ -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 },
+    OpenLoop { hz: f32, min: f32 }
-    BoardError { message: String },
 }
 
 #[derive(Debug, PartialEq, Serialize)]

Software/MainBoard/rust/src/tank.rs

@@ -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()
+            .get_tank_sensor().tank_sensor_voltage().await
-            .and_then(|f| core::prelude::v1::Ok(f.tank_sensor_voltage()))
         {
-            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 {

Software/MainBoard/rust/src/util.rs

@@ -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
     }};
 }

Software/MainBoard/rust/src/webserver/get_json.rs

@@ -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 water_temp: FatResult<f32> = board.board_hal.get_tank_sensor().water_temperature_c().await;
-    let sensor = board.board_hal.get_tank_sensor()?;
-
-    let water_temp: FatResult<f32> = sensor.water_temperature_c().await;
     Ok(Some(serde_json::to_string(&tank_state.as_mqtt_info(
         &board.board_hal.get_config().tank,
         &water_temp,