streamline tank state mqtt information structure

rust/src/tank.rs

@@ -1,34 +1,21 @@
-use crate::{config::{self, PlantControllerConfig, TankConfig}, plant_hal::PlantCtrlBoard};
+use serde::Serialize;
+
+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, 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,
-}
-
+#[derive(Debug, Clone, Serialize)]
 pub enum TankError {
     SensorDisabled,
     SensorMissing(f32),
     SensorValueError { value: f32, min: f32, max: f32 },
-    BoardError(anyhow::Error)
+    BoardError(String)
 }
 
 pub enum TankState {
     TankSensorPresent(f32),
+    TankSensorError(TankError),
     TankSensorDisabled,
 }
 
@@ -72,6 +59,7 @@ 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)?;
                 //TODO(judge) move logging to more sensible place
@@ -86,6 +74,7 @@ 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)?;
                 if tank_fill_percent > config.tank_empty_percent.into() {
@@ -105,6 +94,7 @@ 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)?;
                 if tank_fill_percent < config.tank_warn_percent.into() {
@@ -126,30 +116,69 @@ impl TankState {
     pub fn got_error(&self, config: &TankConfig) -> Option<TankError> {
         match self {
             TankState::TankSensorPresent(raw_value_mv) => raw_voltage_to_tank_fill_percent(*raw_value_mv, config).err(),
+            TankState::TankSensorError(err) => Some(err.clone()),
             TankState::TankSensorDisabled => Some(TankError::SensorDisabled),
         }
     }
 
-}
+    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),
+        };
 
-#[derive(serde::Serialize)]
-pub struct TankStateMQTT {
-    enough_water: bool,
-    warn_level: bool,
-    left_ml: u32,
-    sensor_error: bool,
-    raw: u16,
-    water_frozen: String,
+        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())
+        }
+    }
 }
 
 pub fn determine_tank_state(
     board: &mut std::sync::MutexGuard<'_, PlantCtrlBoard<'_>>,
     config: &PlantControllerConfig,
-) -> Result<TankState, TankError> {
+) -> TankState {
     if config.tank.tank_sensor_enabled {
-        let raw_sensor_value_mv = board.tank_sensor_voltage().map_err(|err| TankError::BoardError(err))?;
-        Ok(TankState::TankSensorPresent(raw_sensor_value_mv))
+        match board.tank_sensor_voltage() {
+            Ok(raw_sensor_value_mv) => TankState::TankSensorPresent(raw_sensor_value_mv),
+            Err(err) => TankState::TankSensorError(TankError::BoardError(err.to_string()))
+        }
+
     } else {
-        Ok(TankState::TankSensorDisabled)
+        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
+    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>,
+}