finalize tank state logging

rust/src/main.rs

@@ -17,7 +17,7 @@ use esp_idf_sys::{
     esp_ota_img_states_t_ESP_OTA_IMG_VALID, vTaskDelay,
 };
 use esp_ota::{mark_app_valid, rollback_and_reboot};
-use log::log;
+use log::{log, LogMessage};
 use once_cell::sync::Lazy;
 use plant_hal::{PlantCtrlBoard, PlantHal, PLANT_COUNT};
 use serde::{Deserialize, Serialize};
@@ -401,37 +401,41 @@ fn safe_main() -> anyhow::Result<()> {
     let dry_run = false;
 
     let tank_state = determine_tank_state(&mut board, &config);
-    if let Some(_err) = tank_state.got_error(&config.tank) {
-        //TODO log error state to serial
-        //log(
-        //LogMessage::SensorTankRaw,
-        //raw_value_mv as u32,
-        //percent as u32,
-        //"",
-        //"",
-        //);
-    } else if tank_state.warn_level(&config.tank).is_ok_and(|warn| warn) {
-        //TODO(judge) enable logging again, might require returning level as well
-        //println!(
-            //"Low water, current percent is {}, minimum warn level is {}",
-            //percent as u8, config.tank.tank_warn_percent
-        //);
-         board.general_fault(true);
-    } else if tank_state.enough_water(&config.tank).is_ok_and(|enough| enough) {
-        //TODO(judge) enable logging again, might require returning level as well
-        //println!(
-            //"Enough water, current percent is {}, minimum empty level is {}",
-            //percent as u8, config.tank.tank_empty_percent
-        //);
-    } else {
-        if let Ok(_left_ml) = tank_state.left_ml(&config.tank) {
-            //TODO(judge) enable logging again, might require returning level as well
-            //println!(
-                //"Tank sensor returned mv {} as {}% leaving {} ml useable",
-                //rv.raw, percent as u8, rv.left_ml
-            //);
+
+    if tank_state.is_enabled() {
+        if let Some(err) = tank_state.got_error(&config.tank) {
+            match err {
+                TankError::SensorDisabled => { /* unreachable */ }
+                TankError::SensorMissing(raw_value_mv) => log(
+                    LogMessage::TankSensorMissing,
+                    raw_value_mv as u32,
+                    0,
+                    "",
+                    "",
+                ),
+                TankError::SensorValueError { value, min, max } => log(
+                    LogMessage::TankSensorValueRangeError,
+                    min as u32,
+                    max as u32,
+                    &format!("{}", value),
+                    "",
+                ),
+                TankError::BoardError(err) => log(
+                    LogMessage::TankSensorBoardError,
+                    0,
+                    0,
+                    "",
+                    &format!("{}", &err.to_string()),
+                ),
+            }
+            // disabled can not trigger this because of wrapping if is_enabled
+            board.general_fault(true);
+        } else if tank_state.warn_level(&config.tank).is_ok_and(|warn| warn) {
+            log(LogMessage::TankWaterLevelLow, 0, 0, "", "");
+            board.general_fault(true);
         }
     }
+
     let mut water_frozen = false;
 
     let mut attempt = 1;
@@ -440,14 +444,14 @@ fn safe_main() -> anyhow::Result<()> {
         match &temp {
             Ok(res) => {
                 println!("Water temp is {}", res);
-                break temp
+                break temp;
             }
             Err(err) => {
                 println!("Could not get water temp {} attempt {}", err, attempt)
             }
         }
         if attempt == 5 {
-            break temp
+            break temp;
         }
         attempt += 1;
     };
@@ -682,14 +686,12 @@ fn determine_state_target_moisture_for_plant(
         match tank_state.enough_water(&config.tank) {
             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
-                    // that no water should flow if there was an error?
+                    state.no_water = true;
                 }
-            },
-            Ok(enough_water) => {
-                state.no_water = !enough_water
-            },
+            }
+            // when no tank error, if plant should be watered depends on if enough water is in tank
+            // no_water behaves inversly to enough_water
+            Ok(enough_water) => state.no_water = !enough_water,
         }
     }
     let duration = TimeDelta::try_minutes(plant_config.pump_cooldown_min as i64).unwrap();
@@ -750,10 +752,10 @@ fn determine_state_timer_only_for_plant(
                         if !config.tank.tank_allow_pumping_if_sensor_error {
                             state.do_water = true;
                         }
-                    },
+                    }
                     Ok(enough_water) => {
                         state.no_water = !enough_water;
-                    },
+                    }
                 }
             }
         }
@@ -801,10 +803,10 @@ fn determine_state_timer_and_deadzone_for_plant(
                         if !config.tank.tank_allow_pumping_if_sensor_error {
                             state.do_water = true;
                         }
-                    },
+                    }
                     Ok(enough_water) => {
                         state.no_water = !enough_water;
-                    },
+                    }
                 }
             }
         }