rust/src/main.rs

@@ -401,32 +401,41 @@ fn safe_main() -> anyhow::Result<()> {
     let dry_run = false;
 
     let tank_state = determine_tank_state(&mut board, &config);
+    let mut tank_state_mqtt = TankStateMQTT {
+        enough_water: tank_state.enough_water,
+        left_ml: tank_state.left_ml,
+        warn_level: tank_state.warn_level,
+        sensor_error: tank_state.sensor_error,
+        raw: tank_state.raw,
+        water_frozen: "".to_owned(),
+    };
     let mut water_frozen = false;
 
-    let mut attempt = 1;
+    let mut temp: Option<f32> = None;
-    let water_temp: Result<f32, anyhow::Error> = loop {
+    for _attempt in 0..5 {
-        let temp = board.water_temperature_c();
+        let water_temperature = board.water_temperature_c();
-        match &temp {
+        match water_temperature {
             Ok(res) => {
-                println!("Water temp is {}", res);
+                temp = Some(res);
-                break temp
+                break;
             }
             Err(err) => {
-                println!("Could not get water temp {} attempt {}", err, attempt)
+                println!("Could not get water temp {} attempt {}", err, _attempt)
             }
         }
-        if attempt == 5 {
-            break temp
     }
-        attempt += 1;
+    match temp {
-    };
+        Some(res) => {
-    if let Ok(res) = water_temp {
+            println!("Water temp is {}", res);
-        if res < WATER_FROZEN_THRESH {
+            if res < 4_f32 {
                 water_frozen = true;
             }
+            tank_state_mqtt.water_frozen = water_frozen.to_string();
+        }
+        None => tank_state_mqtt.water_frozen = "tank sensor error".to_owned(),
     }
 
-    match serde_json::to_string(&tank_state.as_mqtt_info(&config.tank, water_temp)) {
+    match serde_json::to_string(&tank_state_mqtt) {
         Ok(state) => {
             let _ = board.mqtt_publish(&config, "/water", state.as_bytes());
         }
@@ -602,7 +611,7 @@ fn determine_state_target_moisture_for_plant(
     plant: usize,
     state: &mut PlantState,
     config: &PlantControllerConfig,
-    tank_state: &TankState,
+    tank_state: &TankInfo,
     cur: DateTime<Tz>,
 ) {
     let plant_config = &config.plants[plant];
@@ -648,17 +657,10 @@ fn determine_state_target_moisture_for_plant(
 
     if a_low || b_low {
         state.dry = true;
-        match tank_state.enough_water(&config.tank) {
+        if tank_state.sensor_error && !config.tank.tank_allow_pumping_if_sensor_error {
-            Err(_tank_err) => {
-                if !config.tank.tank_allow_pumping_if_sensor_error {
             //ignore is ok
-                    // wtf does this meen, shouldn't something happen if the configuration specifies
+        } else if !tank_state.enough_water {
-                    // that no water should flow if there was an error?
+            state.no_water = true;
-                }
-            },
-            Ok(enough_water) => {
-                state.no_water = !enough_water
-            },
         }
     }
     let duration = TimeDelta::try_minutes(plant_config.pump_cooldown_min as i64).unwrap();
@@ -699,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];
@@ -714,15 +716,10 @@ fn determine_state_timer_only_for_plant(
                 state.next_pump = Some(europe_time);
                 state.cooldown = true;
             } else {
-                match tank_state.enough_water(&config.tank) {
+                if tank_state.sensor_error && !config.tank.tank_allow_pumping_if_sensor_error {
-                    Err(_tank_err) => {
-                        if !config.tank.tank_allow_pumping_if_sensor_error {
                     state.do_water = true;
-                        }
+                } else if !tank_state.enough_water {
-                    },
+                    state.no_water = true;
-                    Ok(enough_water) => {
-                        state.no_water = !enough_water;
-                    },
                 }
             }
         }
@@ -742,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];
@@ -765,15 +762,10 @@ fn determine_state_timer_and_deadzone_for_plant(
                 state.out_of_work_hour = true;
             }
             if !state.cooldown && !state.out_of_work_hour {
-                match tank_state.enough_water(&config.tank) {
+                if tank_state.sensor_error && !config.tank.tank_allow_pumping_if_sensor_error {
-                    Err(_tank_err) => {
-                        if !config.tank.tank_allow_pumping_if_sensor_error {
                     state.do_water = true;
-                        }
+                } else if !tank_state.enough_water {
-                    },
+                    state.no_water = true;
-                    Ok(enough_water) => {
-                        state.no_water = !enough_water;
-                    },
                 }
             }
         }
@@ -791,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<'_>>,
 ) {

rust/src/plant_hal.rs

@@ -472,7 +472,7 @@ impl PlantCtrlBoard<'_> {
     }
 
     /// return median tank sensor value in milli volt
-    pub fn tank_sensor_voltage(&mut self) -> Result<f32> {
+    pub fn tank_sensor_voltage(&mut self) -> Result<u16> {
         let delay = Delay::new_default();
         self.tank_power.set_high()?;
         //let stabilize

rust/src/tank.rs

@@ -1,25 +1,37 @@
-use serde::Serialize;
+use crate::config::{self, PlantControllerConfig, TankConfig};
-
-use crate::{config::{PlantControllerConfig, TankConfig}, plant_hal::PlantCtrlBoard};
 
 const OPEN_TANK_VOLTAGE: f32 = 3.0;
-pub const WATER_FROZEN_THRESH: f32 = 4.0;
 
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, PartialEq, Default)]
+/// State data for water tank
+///
+/// TODO unify with TankStateMQTT
+pub struct TankInfo {
+    /// 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,
+}
+
 pub enum TankError {
     SensorDisabled,
     SensorMissing(f32),
     SensorValueError { value: f32, min: f32, max: f32 },
-    BoardError(String)
 }
 
 pub enum TankState {
-    TankSensorPresent(f32),
+    TankSensorPresent(u16),
-    TankSensorError(TankError),
     TankSensorDisabled,
 }
 
-fn raw_volatge_to_divider_percent(raw_value_mv: f32) -> Result<f32, TankError> {
+fn raw_volatge_to_divider_percent(raw_value_mv: u16) -> Result<f32, TankError> {
     if raw_value_mv > OPEN_TANK_VOLTAGE {
         return Err(TankError::SensorMissing(raw_value_mv));
     }
@@ -39,19 +51,19 @@ fn raw_volatge_to_divider_percent(raw_value_mv: f32) -> Result<f32, TankError> {
 }
 
 fn raw_voltage_to_tank_fill_percent(
-    raw_value_mv: f32,
+    raw_value_mv: u16,
     config: &TankConfig,
 ) -> Result<f32, TankError> {
     let divider_percent = raw_volatge_to_divider_percent(raw_value_mv)?;
-    if divider_percent < config.tank_empty_percent.into() || divider_percent > config.tank_full_percent.into() {
+    if s < config.tank_empty_percent || s > config.tank_full_percent {
         return Err(TankError::SensorValueError {
             value: divider_percent,
-            min: config.tank_empty_percent.into(),
+            min: config.tank_empty_percent,
-            max: config.tank_full_percent.into(),
+            max: config.tank_full_percent,
         });
     }
-    Ok((divider_percent - f32::from(config.tank_empty_percent)) * 100.
+    Ok((divider_percent - config.tank_empty_percent) * 100
-        / f32::from(config.tank_full_percent - config.tank_empty_percent))
+        / (config.tank_full_percent - config.tank_empty_percent))
 }
 
 
@@ -59,9 +71,8 @@ impl TankState {
     pub fn left_ml(&self, config: &TankConfig) -> Result<f32, TankError> {
         match self {
             TankState::TankSensorDisabled => Err(TankError::SensorDisabled),
-            TankState::TankSensorError(err) => Err(err.clone()),
             TankState::TankSensorPresent(raw_value_mv) => {
-                let tank_fill_percent = raw_voltage_to_tank_fill_percent(*raw_value_mv, config)?;
+                let tank_fill_percent = raw_voltage_to_tank_fill_percent(raw_value_mv, config)?;
                 //TODO(judge) move logging to more sensible place
                 //println!(
                     //"Tank sensor returned mv {} as {}% leaving {} ml useable",
@@ -74,10 +85,9 @@ impl TankState {
     pub fn enough_water(&self, config: &TankConfig) -> Result<bool, TankError> {
         match self {
             TankState::TankSensorDisabled => Err(TankError::SensorDisabled),
-            TankState::TankSensorError(err) => Err(err.clone()),
             TankState::TankSensorPresent(raw_value_mv) => {
-                let tank_fill_percent = raw_voltage_to_tank_fill_percent(*raw_value_mv, config)?;
+                let tank_fill_percent = raw_voltage_to_tank_fill_percent(raw_value_mv, config)?;
-                if tank_fill_percent > config.tank_empty_percent.into() {
+                if tank_fill_percent > config.tank_empty_percent {
                     //TODO(judge) move logging to more sensible place
                     //println!(
                         //"Enough water, current percent is {}, minimum empty level is {}",
@@ -94,10 +104,9 @@ impl TankState {
     pub fn warn_level(&self, config: &TankConfig) -> Result<bool, TankError> {
         match self {
             TankState::TankSensorDisabled => Err(TankError::SensorDisabled),
-            TankState::TankSensorError(err) => Err(err.clone()),
             TankState::TankSensorPresent(raw_value_mv) => {
-                let tank_fill_percent = raw_voltage_to_tank_fill_percent(*raw_value_mv, config)?;
+                let tank_fill_percent = raw_voltage_to_tank_fill_percent(raw_value_mv, config)?;
-                if tank_fill_percent < config.tank_warn_percent.into() {
+                if tank_fill_percent < config.tank_warn_percent {
                     //TODO(judge) move logging to more sensible place
                     //println!(
                         //"Low water, current percent is {}, minimum warn level is {}",
@@ -112,32 +121,16 @@ impl TankState {
             },
         }
     }
-
-    pub fn as_mqtt_info(&self, config: &TankConfig, water_temp: Result<f32, anyhow::Error>) -> TankInfo {
-        let mut tank_err: Option<TankError> = None;
-        let left_ml = match self.left_ml(config) {
-            Err(err) => { tank_err = Some(err); None },
-            Ok(left_ml) => Some(left_ml),
-        };
-        let enough_water = self.enough_water(config).unwrap_or(false); //NOTE: is this correct if there is an error assume not enough water?
-        let warn_level = self.warn_level(config).unwrap_or(false); //NOTE: should no warn level be triggered if there is an error?
-        let raw = match self {
-            TankState::TankSensorDisabled
-            | TankState::TankSensorError(_) => None,
-            TankState::TankSensorPresent(raw_value_mv) => Some(*raw_value_mv),
-        };
-
-        TankInfo {
-            enough_water,
-            warn_level,
-            left_ml,
-            sensor_error: tank_err,
-            raw,
-            water_frozen: water_temp.as_ref().is_ok_and(|temp| *temp < WATER_FROZEN_THRESH),
-            water_temp: water_temp.as_ref().copied().ok(),
-            temp_sensor_error: water_temp.err().map(|err| err.to_string())
-        }
 }
+
+#[derive(Serialize)]
+pub struct TankStateMQTT {
+    enough_water: bool,
+    warn_level: bool,
+    left_ml: u32,
+    sensor_error: bool,
+    raw: u16,
+    water_frozen: String,
 }
 
 pub fn determine_tank_state(
@@ -145,33 +138,9 @@ pub fn determine_tank_state(
     config: &PlantControllerConfig,
 ) -> TankState {
     if config.tank.tank_sensor_enabled {
-        match board.tank_sensor_voltage() {
+        let raw_sensor_value_mv = board.tank_sensor_voltage();
-            Ok(raw_sensor_value_mv) => TankState::TankSensorPresent(raw_sensor_value_mv),
+        TankState::TankSensorPresent(raw_sensor_value_mv)
-            Err(err) => TankState::TankSensorError(TankError::BoardError(err.to_string()))
-        }
-
     } else {
         TankState::TankSensorDisabled
     }
 }
-
-#[derive(Debug, Serialize)]
-/// Information structure send to mqtt for monitoring purposes
-pub struct TankInfo {
-    /// 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: Option<f32>,
-    /// if there is was an issue with the water level sensor
-    /// TODO merge with left_ml as Result<u32, error_type>
-    sensor_error: Option<TankError>,
-    /// raw water sensor value
-    raw: Option<f32>,
-    /// water in tank might be frozen
-    water_frozen: bool,
-    /// water temperature
-    water_temp: Option<f32>,
-    temp_sensor_error: Option<String>,
-}