add pump current configuration

rust/src/main.rs

@@ -1,3 +1,4 @@
+use crate::config::PlantConfig;
 use crate::{
     config::BoardVersion::INITIAL,
     hal::{PlantHal, HAL, PLANT_COUNT},
@@ -76,6 +77,17 @@ struct LightState {
 struct PumpInfo {
     enabled: bool,
     pump_ineffective: bool,
+    median_current_ma: u16,
+    max_current_ma: u16,
+    min_current_ma: u16,
+}
+
+#[derive(Serialize)]
+pub struct PumpResult {
+    median_current_ma: u16,
+    max_current_ma: u16,
+    min_current_ma: u16,
+    error: bool,
 }
 
 #[derive(Serialize, Deserialize, Debug, PartialEq)]
@@ -225,6 +237,8 @@ fn safe_main() -> anyhow::Result<()> {
         try_connect_wifi_sntp_mqtt(&mut board)
     } else {
         println!("No wifi configured");
+        //the current sensors require this amount to stabilize, in case of wifi this is already handles for sure;
+        board.board_hal.get_esp().delay.delay_ms(100);
         NetworkMode::OFFLINE
     };
 
@@ -395,14 +409,20 @@ fn safe_main() -> anyhow::Result<()> {
                 board.board_hal.get_esp().last_pump_time(plant_id);
                 //state.active = true;
 
-                pump_info(&mut board, plant_id, true, pump_ineffective);
+                pump_info(&mut board, plant_id, true, pump_ineffective, 0, 0, 0, false);
 
-                if !dry_run {
-                    board.board_hal.pump(plant_id, true)?;
-                    Delay::new_default().delay_ms(1000 * plant_config.pump_time_s as u32);
-                    board.board_hal.pump(plant_id, false)?;
-                }
-                pump_info(&mut board, plant_id, false, pump_ineffective);
+                let result = do_secure_pump(&mut board, plant_id, plant_config, dry_run)?;
+                board.board_hal.pump(plant_id, false)?;
+                pump_info(
+                    &mut board,
+                    plant_id,
+                    false,
+                    pump_ineffective,
+                    result.median_current_ma,
+                    result.max_current_ma,
+                    result.min_current_ma,
+                    result.error,
+                );
             } else if !state.pump_in_timeout(plant_config, &timezone_time) {
                 // plant does not need to be watered and is not in timeout
                 // -> reset consecutive pump count
@@ -556,6 +576,92 @@ fn safe_main() -> anyhow::Result<()> {
         .deep_sleep(1000 * 1000 * 60 * deep_sleep_duration_minutes as u64);
 }
 
+pub fn do_secure_pump(
+    board: &mut MutexGuard<HAL>,
+    plant_id: usize,
+    plant_config: &PlantConfig,
+    dry_run: bool,
+) -> anyhow::Result<PumpResult> {
+    let mut current_collector = vec![0_u16; plant_config.pump_time_s.into()];
+    let mut error = false;
+    let mut first_error = true;
+    if !dry_run {
+        board.board_hal.pump(plant_id, true)?;
+        Delay::new_default().delay_ms(2);
+        for step in 0..plant_config.pump_time_s as usize {
+            let current = board.board_hal.pump_current(plant_id);
+            match current {
+                Ok(current) => {
+                    let current_ma = current.as_milliamperes() as u16;
+                    current_collector[step] = current_ma;
+                    let high_current = current_ma > plant_config.max_pump_current_ma;
+                    if high_current {
+                        if first_error {
+                            log(
+                                LogMessage::PumpOverCurrent,
+                                plant_id as u32 + 1,
+                                current_ma as u32,
+                                plant_config.max_pump_current_ma.to_string().as_str(),
+                                step.to_string().as_str(),
+                            );
+                            board.board_hal.general_fault(true);
+                            board.board_hal.fault(plant_id, true)?;
+                            if !plant_config.ignore_current_error {
+                                error = true;
+                                break;
+                            }
+                            first_error = false;
+                        }
+                    }
+                    let low_current = current_ma < plant_config.min_pump_current_ma;
+                    if low_current {
+                        if first_error {
+                            log(
+                                LogMessage::PumpOpenLoopCurrent,
+                                plant_id as u32 + 1,
+                                current_ma as u32,
+                                plant_config.min_pump_current_ma.to_string().as_str(),
+                                step.to_string().as_str(),
+                            );
+                            board.board_hal.general_fault(true);
+                            board.board_hal.fault(plant_id, true)?;
+                            if !plant_config.ignore_current_error {
+                                error = true;
+                                break;
+                            }
+                            first_error = false;
+                        }
+                    }
+                }
+                Err(err) => {
+                    if !plant_config.ignore_current_error {
+                        println!("Error getting pump current: {}", err);
+                        log(
+                            LogMessage::PumpMissingSensorCurrent,
+                            plant_id as u32,
+                            0,
+                            "",
+                            "",
+                        );
+                        error = true;
+                        break;
+                    } else {
+                        //eg v3 without a sensor ends here, do not spam
+                    }
+                }
+            }
+            Delay::new_default().delay_ms(1000);
+        }
+    }
+    current_collector.sort();
+    Ok(PumpResult {
+        median_current_ma: current_collector[current_collector.len() / 2],
+        max_current_ma: current_collector[current_collector.len() - 1],
+        min_current_ma: current_collector[0],
+        error,
+    })
+}
+
 fn update_charge_indicator(board: &mut MutexGuard<HAL>) {
     //we have mppt controller, ask it for charging current
     if let Ok(current) = board.board_hal.get_mptt_current() {
@@ -711,10 +817,17 @@ fn pump_info(
     plant_id: usize,
     pump_active: bool,
     pump_ineffective: bool,
+    median_current_ma: u16,
+    max_current_ma: u16,
+    min_current_ma: u16,
+    error: bool,
 ) {
     let pump_info = PumpInfo {
         enabled: pump_active,
         pump_ineffective,
+        median_current_ma: median_current_ma,
+        max_current_ma: max_current_ma,
+        min_current_ma: min_current_ma,
     };
     let pump_topic = format!("/pump{}", plant_id + 1);
     match serde_json::to_string(&pump_info) {