From d4a4c1b5732df59af6a9a6c609bc57aafc1c43cc Mon Sep 17 00:00:00 2001
From: ju6ge <judge@felixrichter.tech>
Date: Sun, 10 May 2026 14:04:57 +0200
Subject: [PATCH] refctor: TankInfo structure (consistent layout)

- fix: use tagged enum serialization for TankError
- fix: rename TankInfo fields for consistent naming (volume_ml, pct, water_temp_c)
- renamed some fields for better clarity on contained value
---
 Software/MainBoard/rust/src/main.rs |  6 ++---
 Software/MainBoard/rust/src/tank.rs | 36 +++++++++++++++--------------
 2 files changed, 22 insertions(+), 20 deletions(-)

diff --git a/Software/MainBoard/rust/src/main.rs b/Software/MainBoard/rust/src/main.rs
index a9248cc..291a409 100644
--- a/Software/MainBoard/rust/src/main.rs
+++ b/Software/MainBoard/rust/src/main.rs
@@ -324,7 +324,7 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
         if let Some(err) = tank_state.got_error(&board.board_hal.get_config().tank) {
             match err {
                 TankError::SensorDisabled => { /* unreachable */ }
-                TankError::SensorMissing(raw_value_mv) => log(
+                TankError::SensorMissing { raw_mv: raw_value_mv } => log(
                     LogMessage::TankSensorMissing,
                     raw_value_mv as u32,
                     0,
@@ -338,8 +338,8 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
                     &format!("{value}"),
                     "",
                 ),
-                TankError::BoardError(err) => {
-                    log(LogMessage::TankSensorBoardError, 0, 0, "", &err.to_string())
+                TankError::BoardError { message: err } => {
+                    log(LogMessage::TankSensorBoardError, 0, 0, "", &err)
                 }
             }
             // disabled cannot trigger this because of wrapping if is_enabled
diff --git a/Software/MainBoard/rust/src/tank.rs b/Software/MainBoard/rust/src/tank.rs
index 49a30de..e6d7c2e 100644
--- a/Software/MainBoard/rust/src/tank.rs
+++ b/Software/MainBoard/rust/src/tank.rs
@@ -10,11 +10,12 @@ const OPEN_TANK_VOLTAGE: f32 = 3.0;
 pub const WATER_FROZEN_THRESH: f32 = 4.0;
 
 #[derive(Debug, Clone, Serialize)]
+#[serde(tag = "kind")]
 pub enum TankError {
     SensorDisabled,
-    SensorMissing(f32),
+    SensorMissing { raw_mv: f32 },
     SensorValueError { value: f32, min: f32, max: f32 },
-    BoardError(String),
+    BoardError { message: String },
 }
 
 pub enum TankState {
@@ -25,7 +26,7 @@ pub enum TankState {
 
 fn raw_voltage_to_divider_percent(raw_value_mv: f32) -> Result<f32, TankError> {
     if raw_value_mv > OPEN_TANK_VOLTAGE {
-        return Err(TankError::SensorMissing(raw_value_mv));
+        return Err(TankError::SensorMissing { raw_mv: raw_value_mv });
     }
 
     let r2 = raw_value_mv * 50.0 / (3.3 - raw_value_mv);
@@ -141,15 +142,15 @@ impl TankState {
         TankInfo {
             enough_water,
             warn_level,
-            left_ml,
+            volume_ml: left_ml,
             sensor_error: tank_err,
-            raw,
+            fill_raw_v: raw,
             water_frozen: water_temp
                 .as_ref()
                 .is_ok_and(|temp| *temp < WATER_FROZEN_THRESH),
-            water_temp: water_temp.as_ref().copied().ok(),
+            water_temp_c: water_temp.as_ref().copied().ok(),
             temp_sensor_error: water_temp.as_ref().err().map(|err| err.to_string()),
-            percent,
+            fill_pct: percent,
         }
     }
 }
@@ -158,12 +159,13 @@ pub async fn determine_tank_state(
     board: &mut MutexGuard<'static, CriticalSectionRawMutex, HAL<'static>>,
 ) -> TankState {
     if board.board_hal.get_config().tank.tank_sensor_enabled {
-        match board.board_hal.get_tank_sensor() {
-            Ok(sensor) => match sensor.tank_sensor_voltage().await {
-                Ok(raw_sensor_value_mv) => TankState::Present(raw_sensor_value_mv),
-                Err(err) => TankState::Error(TankError::BoardError(err.to_string())),
-            },
-            Err(err) => TankState::Error(TankError::BoardError(err.to_string())),
+        match board
+            .board_hal
+            .get_tank_sensor()
+            .and_then(|f| core::prelude::v1::Ok(f.tank_sensor_voltage()))
+        {
+            Ok(raw_sensor_value_mv) => TankState::Present(raw_sensor_value_mv.await.unwrap()),
+            Err(err) => TankState::Error(TankError::BoardError { message: err.to_string() }),
         }
     } else {
         TankState::Disabled
@@ -178,16 +180,16 @@ pub struct TankInfo {
     /// warning that water needs to be refilled soon
     pub(crate) warn_level: bool,
     /// estimation how many ml are still in the tank
-    pub(crate) left_ml: Option<f32>,
+    pub(crate) volume_ml: Option<f32>,
     /// if there is an issue with the water level sensor
     pub(crate) sensor_error: Option<TankError>,
     /// raw water sensor value
-    pub(crate) raw: Option<f32>,
+    pub(crate) fill_raw_v: Option<f32>,
     /// percent value
-    pub(crate) percent: Option<f32>,
+    pub(crate) fill_pct: Option<f32>,
     /// water in the tank might be frozen
     pub(crate) water_frozen: bool,
     /// water temperature
-    pub(crate) water_temp: Option<f32>,
+    pub(crate) water_temp_c: Option<f32>,
     pub(crate) temp_sensor_error: Option<String>,
 }