WIP refactor tank state code

rust/src/main.rs

@@ -26,6 +26,9 @@ use crate::{config::PlantControllerConfig, webserver::webserver::httpd};
 mod config;
 mod log;
 pub mod plant_hal;
+mod tank;
+
+use tank::*;
 
 const TIME_ZONE: Tz = Berlin;
 
@@ -125,34 +128,6 @@ enum SensorError {
     OpenCircuit { hz: f32, min: f32 },
 }
 
-#[derive(Debug, PartialEq, Default)]
-/// State data for water tank
-///
-/// TODO unify with TankStateMQTT
-struct TankState {
-    /// is there enough water in the tank
-    enough_water: bool,
-    /// warning that water needs to be refilled soon
-    warn_level: bool,
-    /// estimation how many ml are still in tank
-    left_ml: u32,
-    /// if there is was an issue with the water level sensor
-    /// TODO merge with left_ml as Result<u32, error_type>
-    sensor_error: bool,
-    /// raw water sensor value
-    raw: u16,
-}
-
-#[derive(Serialize)]
-struct TankStateMQTT {
-    enough_water: bool,
-    warn_level: bool,
-    left_ml: u32,
-    sensor_error: bool,
-    raw: u16,
-    water_frozen: String,
-}
-
 #[derive(Serialize)]
 struct PlantStateMQTT<'a> {
     a: &'a str,
@@ -631,74 +606,12 @@ fn publish_battery_state(
     };
 }
 
-fn determine_tank_state(
-    board: &mut std::sync::MutexGuard<'_, PlantCtrlBoard<'_>>,
-    config: &PlantControllerConfig,
-) -> TankState {
-    if config.tank.tank_sensor_enabled {
-        let mut rv: TankState = TankState {
-            ..Default::default()
-        };
-        let success = board
-            .tank_sensor_percent()
-            .and_then(|raw| {
-                rv.raw = raw;
-                return map_range(
-                    (
-                        config.tank.tank_empty_percent as f32,
-                        config.tank.tank_full_percent as f32,
-                    ),
-                    raw as f32,
-                );
-            })
-            .and_then(|percent| {
-                rv.left_ml = ((percent * config.tank.tank_useable_ml as f32) / 100_f32) as u32;
-                println!(
-                    "Tank sensor returned mv {} as {}% leaving {} ml useable",
-                    rv.raw, percent as u8, rv.left_ml
-                );
-                if config.tank.tank_warn_percent > percent as u8 {
-                    board.general_fault(true);
-                    println!(
-                        "Low water, current percent is {}, minimum warn level is {}",
-                        percent as u8, config.tank.tank_warn_percent
-                    );
-                    rv.warn_level = true;
-                }
-                if config.tank.tank_empty_percent < percent as u8 {
-                    println!(
-                        "Enough water, current percent is {}, minimum empty level is {}",
-                        percent as u8, config.tank.tank_empty_percent
-                    );
-                    rv.enough_water = true;
-                }
-                return Ok(());
-            });
-        match success {
-            Err(err) => {
-                println!("Could not determine tank value due to {}", err);
-                board.general_fault(true);
-                rv.sensor_error = true;
-            }
-            Ok(_) => {}
-        }
-        return rv;
-    }
-    return TankState {
-        warn_level: false,
-        enough_water: true,
-        left_ml: 1337,
-        sensor_error: false,
-        raw: 0,
-    };
-}
-
 fn determine_state_target_moisture_for_plant(
     board: &mut std::sync::MutexGuard<'_, PlantCtrlBoard<'_>>,
     plant: usize,
     state: &mut PlantState,
     config: &PlantControllerConfig,
-    tank_state: &TankState,
+    tank_state: &TankInfo,
     cur: DateTime<Tz>,
 ) {
     let plant_config = &config.plants[plant];
@@ -788,7 +701,7 @@ fn determine_state_timer_only_for_plant(
     plant: usize,
     state: &mut PlantState,
     config: &PlantControllerConfig,
-    tank_state: &TankState,
+    tank_state: &TankInfo,
     cur: DateTime<Tz>,
 ) {
     let plant_config = &config.plants[plant];
@@ -826,7 +739,7 @@ fn determine_state_timer_and_deadzone_for_plant(
     plant: usize,
     state: &mut PlantState,
     config: &PlantControllerConfig,
-    tank_state: &TankState,
+    tank_state: &TankInfo,
     cur: DateTime<Tz>,
 ) {
     let plant_config = &config.plants[plant];
@@ -870,7 +783,7 @@ fn determine_state_timer_and_deadzone_for_plant(
 fn determine_plant_state(
     plantstate: &mut [PlantState; PLANT_COUNT],
     cur: DateTime<Tz>,
-    tank_state: &TankState,
+    tank_state: &TankInfo,
     config: &PlantControllerConfig,
     board: &mut std::sync::MutexGuard<'_, PlantCtrlBoard<'_>>,
 ) {
@@ -1051,24 +964,6 @@ fn to_string<T: Display>(value: Result<T>) -> String {
     };
 }
 
-fn map_range(from_range: (f32, f32), s: f32) -> anyhow::Result<f32> {
-    if s < from_range.0 {
-        anyhow::bail!(
-            "Value out of range, min {} but current is {}",
-            from_range.0,
-            s
-        );
-    }
-    if s > from_range.1 {
-        anyhow::bail!(
-            "Value out of range, max {} but current is {}",
-            from_range.1,
-            s
-        );
-    }
-    return Ok(TO.0 + (s - from_range.0) * (TO.1 - TO.0) / (from_range.1 - from_range.0));
-}
-
 fn map_range_moisture(s: f32) -> Result<u8, SensorError> {
     if s < FROM.0 {
         return Err(SensorError::OpenCircuit { hz: s, min: FROM.0 });