adjustments for 3.0 pcb

board/PlantCtrlESP32.kicad_prl

@@ -68,7 +68,7 @@
       39,
       40
     ],
-    "visible_layers": "ffc7055_fffffff8",
+    "visible_layers": "ffc7055_ffffffff",
     "zone_display_mode": 1
   },
   "git": {

rust/sdkconfig.defaults

@@ -1,5 +1,5 @@
 # Rust often needs a bit of an extra main task stack size compared to C (the default is 3K)
-CONFIG_ESP_MAIN_TASK_STACK_SIZE=25000
+CONFIG_ESP_MAIN_TASK_STACK_SIZE=50000
 
 # Use this to set FreeRTOS kernel tick frequency to 1000 Hz (100 Hz by default).
 # This allows to use 1 ms granuality for thread sleeps (10 ms by default).

rust/src/config.rs

@@ -60,7 +60,6 @@ pub struct Plant {
     pub pump_hour_start: u8,
     pub pump_hour_end: u8,
     pub sensor_b: bool,
-    pub sensor_p: bool,
 }
 impl Default for Plant {
     fn default() -> Self {
@@ -71,8 +70,7 @@ impl Default for Plant {
             pump_hour_start: 8,
             pump_hour_end: 20,
             mode: Mode::OFF,
-            sensor_b: false,
-            sensor_p: false,
+            sensor_b: false
         }
     }
 }

rust/src/main.rs

@@ -1,8 +1,13 @@
-use std::sync::{atomic::AtomicBool, Arc, Mutex};
+use std::{
+    fmt::Display,
+    sync::{atomic::AtomicBool, Arc, Mutex},
+};
 
-use chrono::{DateTime, Datelike, TimeDelta, Timelike};
+use anyhow::Result;
+use chrono::{DateTime, Datelike, TimeDelta, Timelike, Utc};
 use chrono_tz::{Europe::Berlin, Tz};
 
+use config::Mode;
 use esp_idf_hal::delay::Delay;
 use esp_idf_sys::{
     esp_deep_sleep, esp_ota_get_app_partition_count, esp_ota_get_running_partition,
@@ -41,7 +46,7 @@ mod webserver {
     pub mod webserver;
 }
 
-#[derive(Serialize, Deserialize, Copy, Clone, Debug, PartialEq)]
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
 enum OnlineMode {
     Offline,
     Wifi,
@@ -49,7 +54,7 @@ enum OnlineMode {
     Online,
 }
 
-#[derive(Serialize, Deserialize, Copy, Clone, Debug, PartialEq)]
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
 enum WaitType {
     InitialConfig,
     FlashError,
@@ -57,7 +62,7 @@ enum WaitType {
     StayAlive,
 }
 
-#[derive(Serialize, Deserialize, Copy, Clone, Debug, PartialEq, Default)]
+#[derive(Serialize, Deserialize, Debug, PartialEq, Default)]
 struct LightState {
     active: bool,
     out_of_work_hour: bool,
@@ -65,15 +70,13 @@ struct LightState {
     is_day: bool,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Default)]
+#[derive(Debug, PartialEq, Default)]
 struct PlantState {
     a: Option<u8>,
     b: Option<u8>,
-    p: Option<u8>,
     consecutive_pump_count: u32,
     after_p: Option<u8>,
     do_water: bool,
-    frozen: bool,
     dry: bool,
     active: bool,
     pump_error: bool,
@@ -82,25 +85,60 @@ struct PlantState {
     no_water: bool,
     sensor_error_a: Option<SensorError>,
     sensor_error_b: Option<SensorError>,
-    sensor_error_p: Option<SensorError>,
     out_of_work_hour: bool,
     next_pump: Option<DateTime<Tz>>,
 }
 
-#[derive(Serialize, Deserialize, Copy, Clone, Debug, PartialEq)]
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
 enum SensorError {
     Unknown,
     ShortCircuit { hz: f32, max: f32 },
     OpenCircuit { hz: f32, min: f32 },
 }
 
-#[derive(Serialize, Deserialize, Copy, Clone, Debug, PartialEq, Default)]
+#[derive(Debug, PartialEq, Default)]
 struct TankState {
     enough_water: bool,
+    warn_level: bool,
     left_ml: u32,
     sensor_error: bool,
     raw: u16,
 }
+#[derive(Serialize)]
+struct TankStateMQTT {
+    enough_water: bool,
+    warn_level: bool,
+    left_ml: u32,
+    sensor_error: bool,
+    raw: u16,
+    water_frozen: String,
+}
+
+#[derive(Serialize)]
+struct PlantStateMQTT<'a> {
+    a: &'a str,
+    b: &'a str,
+    mode: &'a str,
+    consecutive_pump_count: u32,
+    dry: bool,
+    active: bool,
+    pump_error: bool,
+    not_effective: bool,
+    cooldown: bool,
+    out_of_work_hour: bool,
+    last_pump: &'a str,
+    next_pump: &'a str,
+}
+#[derive(Serialize)]
+struct BatteryState<'a> {
+    voltage_milli_volt: &'a str,
+    current_milli_ampere: &'a str,
+    cycle_count: &'a str,
+    design_milli_ampere: &'a str,
+    remaining_milli_ampere: &'a str,
+    state_of_charge: &'a str,
+    state_of_health: &'a str,
+}
 
 fn safe_main() -> anyhow::Result<()> {
     // It is necessary to call this function once. Otherwise some patches to the runtime
@@ -128,7 +166,7 @@ fn safe_main() -> anyhow::Result<()> {
     );
 
     let count = unsafe { esp_ota_get_app_partition_count() };
-    println!("Partition count is {}", count);
+    println!("Partit    ion count is {}", count);
     let mut ota_state: esp_ota_img_states_t = 0;
     let running_partition = unsafe { esp_ota_get_running_partition() };
     let address = unsafe { (*running_partition).address };
@@ -156,7 +194,7 @@ fn safe_main() -> anyhow::Result<()> {
 
     println!("Board hal init");
     let mut board: std::sync::MutexGuard<'_, PlantCtrlBoard<'_>> = BOARD_ACCESS.lock().unwrap();
-
+    board.general_fault(false);
     println!("Mounting filesystem");
     board.mount_file_system()?;
     let free_space = board.file_system_size()?;
@@ -323,26 +361,16 @@ fn safe_main() -> anyhow::Result<()> {
     }
 
     let tank_state = determine_tank_state(&mut board, &config);
-    if online_mode == OnlineMode::Online {
-        if tank_state.sensor_error {
-            let _ = board.mqtt_publish(&config, "/water/ml", "error".to_string().as_bytes());
-        } else {
-            let _ = board.mqtt_publish(
-                &config,
-                "/water/ml",
-                tank_state.left_ml.to_string().as_bytes(),
-            );
-            let _ = board.mqtt_publish(
-                &config,
-                "/water/enough_water",
-                tank_state.enough_water.to_string().as_bytes(),
-            );
-            let _ =
-                board.mqtt_publish(&config, "/water/raw", tank_state.raw.to_string().as_bytes());
-        }
-    }
-
+    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 temp: Option<f32> = None;
     for _attempt in 0..5 {
         let water_temperature = board.water_temperature_c();
@@ -362,21 +390,25 @@ fn safe_main() -> anyhow::Result<()> {
             if res < 4_f32 {
                 water_frozen = true;
             }
-            if online_mode == OnlineMode::Online {
-                let _ =
-                    board.mqtt_publish(&config, "/water/temperature", res.to_string().as_bytes());
-            }
-        }
-        None => {
-            if online_mode == OnlineMode::Online {
-                let _ = board.mqtt_publish(&config, "/water/temperature", "Error".as_bytes());
-            }
+            tank_state_mqtt.water_frozen = water_frozen.to_string();
         }
+        None => tank_state_mqtt.water_frozen = "tank sensor error".to_owned(),
     }
 
-    let mut plantstate = [PlantState {
+    if online_mode == OnlineMode::Online {
+        match serde_json::to_string(&tank_state_mqtt) {
+            Ok(state) => {
+                let _ = board.mqtt_publish(&config, "/water", state.as_bytes());
+            }
+            Err(err) => {
+                println!("Error publishing tankstate {}", err);
+            }
+        };
+    }
+
+    let mut plantstate: [PlantState; PLANT_COUNT] = core::array::from_fn(|_| PlantState {
         ..Default::default()
-    }; PLANT_COUNT];
+    });
     let plant_to_pump = determine_next_plant(
         &mut plantstate,
         europe_time,
@@ -388,12 +420,7 @@ fn safe_main() -> anyhow::Result<()> {
 
     let stay_alive = STAY_ALIVE.load(std::sync::atomic::Ordering::Relaxed);
     println!("Check stay alive, current state is {}", stay_alive);
-    if stay_alive {
-        drop(board);
-        let reboot_now = Arc::new(AtomicBool::new(false));
-        let _webserver = httpd(reboot_now.clone());
-        wait_infinity(WaitType::StayAlive, reboot_now.clone());
-    }
+
     let mut did_pump = false;
     match plant_to_pump {
         Some(plant) => {
@@ -407,71 +434,23 @@ fn safe_main() -> anyhow::Result<()> {
 
             let plant_config = config.plants[plant];
 
-            if plant_config.sensor_p {
-                match map_range_moisture(
-                    board.measure_moisture_hz(plant, plant_hal::Sensor::PUMP)? as f32,
-                ) {
-                    Ok(p) => state.p = Some(p),
-                    Err(err) => {
-                        board.fault(plant, true);
-                        state.sensor_error_p = Some(err);
-                    }
-                }
-            }
-
             println!(
                 "Trying to pump for {}s with pump {} now",
                 plant_config.pump_time_s, plant
             );
-            did_pump = true;
-            board.any_pump(true)?;
-            board.store_last_pump_time(plant, cur);
-            board.pump(plant, true)?;
-            board.last_pump_time(plant);
-            state.active = true;
-            for _ in 0..plant_config.pump_time_s {
-                unsafe { vTaskDelay(CONFIG_FREERTOS_HZ) };
-                if plant_config.sensor_p {
-                    let moist = map_range_moisture(
-                        board.measure_moisture_hz(plant, plant_hal::Sensor::PUMP)? as f32,
-                    );
-                    if online_mode == OnlineMode::Online {
-                        let _ = board.mqtt_publish(
-                            &config,
-                            format!("/plant{}/Sensor P after", plant + 1).as_str(),
-                            option_to_string(moist.ok()).as_bytes(),
-                        );
-                    }
-                } else {
-                    if online_mode == OnlineMode::Online {
-                        let _ = board.mqtt_publish(
-                            &config,
-                            format!("/plant{}/Sensor P after", plant + 1).as_str(),
-                            "disabled".as_bytes(),
-                        );
-                    }
+            if !stay_alive {
+                did_pump = true;
+                board.any_pump(true)?;
+                board.store_last_pump_time(plant, cur);
+                board.pump(plant, true)?;
+                board.last_pump_time(plant);
+                state.active = true;
+                for _ in 0..plant_config.pump_time_s {
+                    unsafe { vTaskDelay(CONFIG_FREERTOS_HZ) };
+                    //info message or something?
                 }
-            }
 
-            board.pump(plant, false)?;
-            if plant_config.sensor_p {
-                match map_range_moisture(
-                    board.measure_moisture_hz(plant, plant_hal::Sensor::PUMP)? as f32,
-                ) {
-                    Ok(p) => state.after_p = Some(p),
-                    Err(err) => {
-                        board.fault(plant, true);
-                        state.sensor_error_p = Some(err);
-                    }
-                }
-                if state.after_p.is_none()
-                    || state.p.is_none()
-                    || state.after_p.unwrap() < state.p.unwrap() + 5
-                {
-                    state.pump_error = true;
-                    board.fault(plant, true);
-                    //mqtt sync pump error value
-                }
+                board.pump(plant, false)?;
             }
         }
         None => {
@@ -487,7 +466,7 @@ fn safe_main() -> anyhow::Result<()> {
     let is_day = board.is_day();
     light_state.is_day = is_day;
     light_state.out_of_work_hour = !in_time_range(
-        europe_time,
+        &europe_time,
         config.night_lamp_hour_start,
         config.night_lamp_hour_end,
     );
@@ -528,7 +507,7 @@ fn safe_main() -> anyhow::Result<()> {
     if online_mode == OnlineMode::Online {
         match serde_json::to_string(&light_state) {
             Ok(state) => {
-                let _ = board.mqtt_publish(&config, "/light/active", state.as_bytes());
+                let _ = board.mqtt_publish(&config, "/light", state.as_bytes());
             }
             Err(err) => {
                 println!("Error publishing lightstate {}", err);
@@ -569,6 +548,13 @@ fn safe_main() -> anyhow::Result<()> {
     //is deep sleep
     mark_app_valid();
 
+    if stay_alive {
+        drop(board);
+        let reboot_now = Arc::new(AtomicBool::new(false));
+        let _webserver = httpd(reboot_now.clone());
+        wait_infinity(WaitType::StayAlive, reboot_now.clone());
+    }
+
     unsafe { esp_deep_sleep(1000 * 1000 * 60 * deep_sleep_duration_minutes as u64) };
 }
 
@@ -576,116 +562,21 @@ fn publish_battery_state(
     board: &mut std::sync::MutexGuard<'_, PlantCtrlBoard<'_>>,
     config: &Config,
 ) {
-    match board.voltage_milli_volt() {
-        Ok(v) => {
-            let _ = board.mqtt_publish(
-                &config,
-                "/battery/voltage_milli_volt",
-                v.to_string().as_bytes(),
-            );
-        }
-        Err(err) => {
-            let _ = board.mqtt_publish(&config, "/battery/voltage_milli_volt", "-1".as_bytes());
-            let _ = board.mqtt_publish(&config, "/errorlog", format!("{:?}", err).as_bytes());
-        }
+    let bat = BatteryState {
+        voltage_milli_volt: &to_string(&board.voltage_milli_volt()),
+        current_milli_ampere: &to_string(&board.average_current_milli_ampere()),
+        cycle_count: &to_string(&board.cycle_count()),
+        design_milli_ampere: &to_string(&board.design_milli_ampere_hour()),
+        remaining_milli_ampere: &to_string(&board.remaining_milli_ampere_hour()),
+        state_of_charge: &to_string(&board.state_charge_percent()),
+        state_of_health: &to_string(&board.state_health_percent()),
     };
-    match board.average_current_milli_ampere() {
-        Ok(v) => {
-            let _ = board.mqtt_publish(
-                &config,
-                "/battery/average_current_milli_ampere",
-                v.to_string().as_bytes(),
-            );
+    match serde_json::to_string(&bat) {
+        Ok(state) => {
+            let _ = board.mqtt_publish(&config, "/battery", state.as_bytes());
         }
         Err(err) => {
-            let _ = board.mqtt_publish(
-                &config,
-                "/battery/average_current_milli_ampere",
-                "-1".as_bytes(),
-            );
-            let _ = board.mqtt_publish(&config, "/errorlog", format!("{:?}", err).as_bytes());
-        }
-    };
-    match board.cycle_count() {
-        Ok(v) => {
-            let _ = board.mqtt_publish(&config, "/battery/cycle_count", v.to_string().as_bytes());
-        }
-        Err(err) => {
-            let _ = board.mqtt_publish(&config, "/battery/cycle_count", "-1".as_bytes());
-            let _ = board.mqtt_publish(&config, "/errorlog", format!("{:?}", err).as_bytes());
-        }
-    };
-    match board.design_milli_ampere_hour() {
-        Ok(v) => {
-            let _ = board.mqtt_publish(
-                &config,
-                "/battery/design_milli_ampere_hour",
-                v.to_string().as_bytes(),
-            );
-        }
-        Err(err) => {
-            let _ = board.mqtt_publish(
-                &config,
-                "/battery/design_milli_ampere_hour",
-                "-1".as_bytes(),
-            );
-            let _ = board.mqtt_publish(&config, "/errorlog", format!("{:?}", err).as_bytes());
-        }
-    };
-    match board.max_milli_ampere_hour() {
-        Ok(v) => {
-            let _ = board.mqtt_publish(
-                &config,
-                "/battery/max_milli_ampere_hour",
-                v.to_string().as_bytes(),
-            );
-        }
-        Err(err) => {
-            let _ = board.mqtt_publish(&config, "/battery/max_milli_ampere_hour", "-1".as_bytes());
-            let _ = board.mqtt_publish(&config, "/errorlog", format!("{:?}", err).as_bytes());
-        }
-    };
-    match board.remaining_milli_ampere_hour() {
-        Ok(v) => {
-            let _ = board.mqtt_publish(
-                &config,
-                "/battery/remaining_milli_ampere_hour",
-                v.to_string().as_bytes(),
-            );
-        }
-        Err(err) => {
-            let _ = board.mqtt_publish(
-                &config,
-                "/battery/remaining_milli_ampere_hour",
-                "-1".as_bytes(),
-            );
-            let _ = board.mqtt_publish(&config, "/errorlog", format!("{:?}", err).as_bytes());
-        }
-    };
-    match board.state_charge_percent() {
-        Ok(v) => {
-            let _ = board.mqtt_publish(
-                &config,
-                "/battery/state_charge_percent",
-                v.to_string().as_bytes(),
-            );
-        }
-        Err(err) => {
-            let _ = board.mqtt_publish(&config, "/battery/state_charge_percent", "-1".as_bytes());
-            let _ = board.mqtt_publish(&config, "/errorlog", format!("{:?}", err).as_bytes());
-        }
-    };
-    match board.state_health_percent() {
-        Ok(v) => {
-            let _ = board.mqtt_publish(
-                &config,
-                "/battery/state_health_percent",
-                v.to_string().as_bytes(),
-            );
-        }
-        Err(err) => {
-            let _ = board.mqtt_publish(&config, "/battery/state_health_percent", "-1".as_bytes());
-            let _ = board.mqtt_publish(&config, "/errorlog", format!("{:?}", err).as_bytes());
+            println!("Error publishing battery_state {}", err);
         }
     };
 }
@@ -722,6 +613,7 @@ fn determine_tank_state(
                         "Low water, current percent is {}, minimum warn level is {}",
                         percent as u8, config.tank_warn_percent
                     );
+                    rv.warn_level = true;
                 }
                 if config.tank_empty_percent < percent as u8 {
                     println!(
@@ -743,6 +635,7 @@ fn determine_tank_state(
         return rv;
     }
     return TankState {
+        warn_level: false,
         enough_water: true,
         left_ml: 1337,
         sensor_error: false,
@@ -750,64 +643,18 @@ fn determine_tank_state(
     };
 }
 
-fn map_range(from_range: (f32, f32), s: f32) -> anyhow::Result<f32> {
-    if s < from_range.0 {
-        anyhow::bail!(
-            "Value out of range, min {} but current is {}",
-            from_range.0,
-            s
-        );
-    }
-    if s > from_range.1 {
-        anyhow::bail!(
-            "Value out of range, max {} but current is {}",
-            from_range.1,
-            s
-        );
-    }
-    return Ok(TO.0 + (s - from_range.0) * (TO.1 - TO.0) / (from_range.1 - from_range.0));
-}
-
-fn map_range_moisture(s: f32) -> Result<u8, SensorError> {
-    if s < FROM.0 {
-        return Err(SensorError::OpenCircuit { hz: s, min: FROM.0 });
-    }
-    if s > FROM.1 {
-        return Err(SensorError::ShortCircuit { hz: s, max: FROM.1 });
-    }
-    let tmp = TO.0 + (s - FROM.0) * (TO.1 - TO.0) / (FROM.1 - FROM.0);
-
-    return Ok(tmp as u8);
-}
-
-fn in_time_range(cur: DateTime<Tz>, start: u8, end: u8) -> bool {
-    let curhour = cur.hour() as u8;
-    //eg 10-14
-    if start < end {
-        return curhour > start && curhour < end;
-    } else {
-        //eg 20-05
-        return curhour > start || curhour < end;
-    }
-}
-
-fn option_to_string(value: Option<u8>) -> String {
-    match value {
-        Some(v) => v.to_string(),
-        None => "Error".to_owned(),
-    }
-}
-
 fn determine_state_target_moisture_for_plant(
     board: &mut std::sync::MutexGuard<'_, PlantCtrlBoard<'_>>,
     plant: usize,
     state: &mut PlantState,
     config: &Config,
     tank_state: &TankState,
-    water_frozen: bool,
     cur: DateTime<Tz>,
 ) {
     let plant_config = &config.plants[plant];
+    if plant_config.mode == Mode::OFF {
+        return;
+    }
     match board.measure_moisture_hz(plant, plant_hal::Sensor::A) {
         Ok(a) => {
             let mapped = map_range_moisture(a as f32);
@@ -873,21 +720,14 @@ fn determine_state_target_moisture_for_plant(
     }
 
     if !in_time_range(
-        cur,
+        &cur,
         plant_config.pump_hour_start,
         plant_config.pump_hour_end,
     ) {
         state.out_of_work_hour = true;
     }
-    if water_frozen {
-        state.frozen = true;
-    }
     if state.dry && !state.no_water && !state.cooldown && !state.out_of_work_hour {
-        if water_frozen {
-            state.frozen = true;
-        } else {
-            state.do_water = true;
-        }
+        state.do_water = true;
     }
 }
 
@@ -897,7 +737,6 @@ fn determine_state_timer_only_for_plant(
     state: &mut PlantState,
     config: &Config,
     tank_state: &TankState,
-    water_frozen: bool,
     cur: DateTime<Tz>,
 ) {
     let plant_config = &config.plants[plant];
@@ -912,14 +751,10 @@ fn determine_state_timer_only_for_plant(
                 state.next_pump = Some(europe_time);
                 state.cooldown = true;
             } else {
-                if water_frozen {
-                    state.frozen = true;
-                } else {
-                    if tank_state.sensor_error && !config.tank_allow_pumping_if_sensor_error {
-                        state.do_water = true;
-                    } else if !tank_state.enough_water {
-                        state.no_water = true;
-                    }
+                if tank_state.sensor_error && !config.tank_allow_pumping_if_sensor_error {
+                    state.do_water = true;
+                } else if !tank_state.enough_water {
+                    state.no_water = true;
                 }
             }
         }
@@ -940,7 +775,6 @@ fn determine_state_timer_and_deadzone_for_plant(
     state: &mut PlantState,
     config: &Config,
     tank_state: &TankState,
-    water_frozen: bool,
     cur: DateTime<Tz>,
 ) {
     let plant_config = &config.plants[plant];
@@ -956,21 +790,17 @@ fn determine_state_timer_and_deadzone_for_plant(
                 state.cooldown = true;
             }
             if !in_time_range(
-                cur,
+                &cur,
                 plant_config.pump_hour_start,
                 plant_config.pump_hour_end,
             ) {
                 state.out_of_work_hour = true;
             }
             if !state.cooldown && !state.out_of_work_hour {
-                if water_frozen {
-                    state.frozen = true;
-                } else {
-                    if tank_state.sensor_error && !config.tank_allow_pumping_if_sensor_error {
-                        state.do_water = true;
-                    } else if !tank_state.enough_water {
-                        state.no_water = true;
-                    }
+                if tank_state.sensor_error && !config.tank_allow_pumping_if_sensor_error {
+                    state.do_water = true;
+                } else if !tank_state.enough_water {
+                    state.no_water = true;
                 }
             }
         }
@@ -1000,43 +830,20 @@ fn determine_next_plant(
             config::Mode::OFF => {}
             config::Mode::TargetMoisture => {
                 determine_state_target_moisture_for_plant(
-                    board,
-                    plant,
-                    state,
-                    config,
-                    tank_state,
-                    water_frozen,
-                    cur,
+                    board, plant, state, config, tank_state, cur,
                 );
             }
             config::Mode::TimerOnly => {
-                determine_state_timer_only_for_plant(
-                    board,
-                    plant,
-                    state,
-                    config,
-                    tank_state,
-                    water_frozen,
-                    cur,
-                );
+                determine_state_timer_only_for_plant(board, plant, state, config, tank_state, cur);
             }
             config::Mode::TimerAndDeadzone => {
                 determine_state_timer_and_deadzone_for_plant(
-                    board,
-                    plant,
-                    state,
-                    config,
-                    tank_state,
-                    water_frozen,
-                    cur,
+                    board, plant, state, config, tank_state, cur,
                 );
             }
         }
 
-        if state.sensor_error_a.is_some()
-            || state.sensor_error_b.is_some()
-            || state.sensor_error_p.is_some()
-        {
+        if state.sensor_error_a.is_some() || state.sensor_error_b.is_some() {
             board.fault(plant, true);
         }
         if !state.dry {
@@ -1051,8 +858,10 @@ fn determine_next_plant(
             "Checking for water plant {} with state {}",
             plant, state.do_water
         );
-        if state.do_water {
-            return Some(plant);
+        if !water_frozen {
+            if state.do_water {
+                return Some(plant);
+            }
         }
     }
     println!("No plant needs water");
@@ -1068,155 +877,38 @@ fn update_plant_state(
         let state = &plantstate[plant];
         let plant_config = config.plants[plant];
 
-        let _ = board.mqtt_publish(
-            &config,
-            format!("/plant{}/mode", plant + 1).as_str(),
-            match plant_config.mode {
-                config::Mode::OFF => "OFF".as_bytes(),
-                config::Mode::TargetMoisture => "TargetMoisture".as_bytes(),
-                config::Mode::TimerOnly => "TimerOnly".as_bytes(),
-                config::Mode::TimerAndDeadzone => "TimerAndDeadzone".as_bytes(),
-            },
-        );
+        let mode = format!("{:?}", plant_config.mode);
 
-        let last_time = board.last_pump_time(plant);
-        match last_time {
-            Some(last_time) => {
-                let europe_time = last_time.with_timezone(&Berlin);
-                if europe_time.year() > 2023 {
-                    let time = europe_time.to_rfc3339();
-                    let _ = board.mqtt_publish(
-                        &config,
-                        format!("/plant{}/last pump", plant + 1).as_str(),
-                        time.as_bytes(),
-                    );
-                } else {
-                    let _ = board.mqtt_publish(
-                        &config,
-                        format!("/plant{}/last pump", plant + 1).as_str(),
-                        "N/A".as_bytes(),
-                    );
-                }
-            }
-            None => {
-                let _ = board.mqtt_publish(
-                    &config,
-                    format!("/plant{}/last pump", plant + 1).as_str(),
-                    "N/A".as_bytes(),
-                );
-            }
-        }
+        let plant_dto = PlantStateMQTT {
+            a: &sensor_to_string(
+                &state.a,
+                &state.sensor_error_a,
+                plant_config.mode != Mode::OFF,
+            ),
+            b: &sensor_to_string(&state.b, &state.sensor_error_b, plant_config.sensor_b),
+            active: state.active,
+            mode: &mode,
+            last_pump: &time_to_string_utc(board.last_pump_time(plant)),
+            next_pump: &time_to_string(state.next_pump),
+            consecutive_pump_count: state.consecutive_pump_count,
+            cooldown: state.cooldown,
+            dry: state.dry,
+            not_effective: state.not_effective,
+            out_of_work_hour: state.out_of_work_hour,
+            pump_error: state.pump_error,
+        };
 
-        match state.next_pump {
-            Some(next) => {
-                let time = next.to_rfc3339();
-                let _ = board.mqtt_publish(
-                    &config,
-                    format!("/plant{}/next pump", plant + 1).as_str(),
-                    time.as_bytes(),
-                );
+        match serde_json::to_string(&plant_dto) {
+            Ok(state) => {
+                let plant_topic = format!("/plant{}", plant + 1);
+                let _ = board.mqtt_publish(&config, &plant_topic, state.as_bytes());
+                //reduce speed as else messages will be dropped
+                Delay::new_default().delay_ms(200);
             }
-            None => {
-                let _ = board.mqtt_publish(
-                    &config,
-                    format!("/plant{}/next pump", plant + 1).as_str(),
-                    "N/A".as_bytes(),
-                );
+            Err(err) => {
+                println!("Error publishing lightstate {}", err);
             }
-        }
-        let _ = board.mqtt_publish(
-            config,
-            format!("/plant{}/active", plant + 1).as_str(),
-            state.active.to_string().as_bytes(),
-        );
-        let _ = board.mqtt_publish(
-            config,
-            format!("/plant{}/Sensor A", plant + 1).as_str(),
-            option_to_string(state.a).as_bytes(),
-        );
-        if plant_config.sensor_b {
-            let _ = board.mqtt_publish(
-                config,
-                format!("/plant{}/Sensor B", plant + 1).as_str(),
-                option_to_string(state.b).as_bytes(),
-            );
-        } else {
-            let _ = board.mqtt_publish(
-                config,
-                format!("/plant{}/Sensor B", plant + 1).as_str(),
-                "disabled".as_bytes(),
-            );
-        }
-
-        if plant_config.sensor_p {
-            let _ = board.mqtt_publish(
-                config,
-                format!("/plant{}/Sensor P before", plant + 1).as_str(),
-                option_to_string(state.p).as_bytes(),
-            );
-            let _ = board.mqtt_publish(
-                config,
-                format!("/plant{}/Sensor P after", plant + 1).as_str(),
-                option_to_string(state.after_p).as_bytes(),
-            );
-        } else {
-            let _ = board.mqtt_publish(
-                config,
-                format!("/plant{}/Sensor P before", plant + 1).as_str(),
-                "disabled".as_bytes(),
-            );
-            let _ = board.mqtt_publish(
-                config,
-                format!("/plant{}/Sensor P after", plant + 1).as_str(),
-                "disabled".as_bytes(),
-            );
-        }
-
-        let _ = board.mqtt_publish(
-            config,
-            format!("/plant{}/Should water", plant + 1).as_str(),
-            state.do_water.to_string().as_bytes(),
-        );
-        let _ = board.mqtt_publish(
-            config,
-            format!("/plant{}/Is frozen", plant + 1).as_str(),
-            state.frozen.to_string().as_bytes(),
-        );
-        let _ = board.mqtt_publish(
-            config,
-            format!("/plant{}/Is dry", plant + 1).as_str(),
-            state.dry.to_string().as_bytes(),
-        );
-        let _ = board.mqtt_publish(
-            config,
-            format!("/plant{}/Pump Error", plant + 1).as_str(),
-            state.pump_error.to_string().as_bytes(),
-        );
-        let _ = board.mqtt_publish(
-            config,
-            format!("/plant{}/Pump Ineffective", plant + 1).as_str(),
-            state.not_effective.to_string().as_bytes(),
-        );
-        let _ = board.mqtt_publish(
-            config,
-            format!("/plant{}/Is in Cooldown", plant + 1).as_str(),
-            state.cooldown.to_string().as_bytes(),
-        );
-        let _ = board.mqtt_publish(
-            config,
-            format!("/plant{}/No Water", plant + 1).as_str(),
-            state.no_water.to_string().as_bytes(),
-        );
-        let _ = board.mqtt_publish(
-            config,
-            format!("/plant{}/Out of Work Hour", plant + 1).as_str(),
-            state.out_of_work_hour.to_string().as_bytes(),
-        );
-        let _ = board.mqtt_publish(
-            config,
-            format!("/plant{}/consecutive pump count", plant + 1).as_str(),
-            state.consecutive_pump_count.to_string().as_bytes(),
-        );
+        };
     }
 }
 
@@ -1274,7 +966,87 @@ fn main() {
         }
     }
 }
-//error codes
-//error_reading_config_after_upgrade
-//error_no_config_after_upgrade
-//error_tank_sensor_fault
+
+fn time_to_string_utc(value_option: Option<DateTime<Utc>>) -> String {
+    let converted = value_option.and_then(|utc| Some(utc.with_timezone(&Berlin)));
+    return time_to_string(converted);
+}
+
+fn time_to_string(value_option: Option<DateTime<Tz>>) -> String {
+    match value_option {
+        Some(value) => {
+            let europe_time = value.with_timezone(&Berlin);
+            if europe_time.year() > 2023 {
+                return europe_time.to_rfc3339();
+            } else {
+                //initial value of 0 in rtc memory
+                return "N/A".to_owned();
+            }
+        }
+        None => return "N/A".to_owned(),
+    };
+}
+
+fn sensor_to_string(value: &Option<u8>, error: &Option<SensorError>, enabled: bool) -> String {
+    if enabled {
+        match error {
+            Some(error) => return format!("{:?}", error),
+            None => match value {
+                Some(v) => return v.to_string(),
+                None => return "Error".to_owned(),
+            },
+        }
+    } else {
+        return "disabled".to_owned();
+    };
+}
+
+fn to_string<T: Display>(value: &Result<T>) -> String {
+    return match value {
+        Ok(v) => v.to_string(),
+        Err(err) => {
+            format!("{:?}", err)
+        }
+    };
+}
+
+fn map_range(from_range: (f32, f32), s: f32) -> anyhow::Result<f32> {
+    if s < from_range.0 {
+        anyhow::bail!(
+            "Value out of range, min {} but current is {}",
+            from_range.0,
+            s
+        );
+    }
+    if s > from_range.1 {
+        anyhow::bail!(
+            "Value out of range, max {} but current is {}",
+            from_range.1,
+            s
+        );
+    }
+    return Ok(TO.0 + (s - from_range.0) * (TO.1 - TO.0) / (from_range.1 - from_range.0));
+}
+
+fn map_range_moisture(s: f32) -> Result<u8, SensorError> {
+    if s < FROM.0 {
+        return Err(SensorError::OpenCircuit { hz: s, min: FROM.0 });
+    }
+    if s > FROM.1 {
+        return Err(SensorError::ShortCircuit { hz: s, max: FROM.1 });
+    }
+    let tmp = TO.0 + (s - FROM.0) * (TO.1 - TO.0) / (FROM.1 - FROM.0);
+
+    return Ok(tmp as u8);
+}
+
+fn in_time_range(cur: &DateTime<Tz>, start: u8, end: u8) -> bool {
+    let curhour = cur.hour() as u8;
+    //eg 10-14
+    if start < end {
+        return curhour > start && curhour < end;
+    } else {
+        //eg 20-05
+        return curhour > start || curhour < end;
+    }
+}

rust/src/plant_hal.rs

@@ -1,5 +1,5 @@
 use bq34z100::{Bq34Z100Error, Bq34z100g1, Bq34z100g1Driver};
-//mod config;
+
 use chrono_tz::Europe::Berlin;
 use embedded_svc::wifi::{
     AccessPointConfiguration, AccessPointInfo, AuthMethod, ClientConfiguration, Configuration,
@@ -17,7 +17,7 @@ use esp_idf_svc::mqtt::client::{EspMqttClient, LwtConfiguration, MqttClientConfi
 use esp_idf_svc::nvs::EspDefaultNvsPartition;
 use esp_idf_svc::wifi::config::{ScanConfig, ScanType};
 use esp_idf_svc::wifi::EspWifi;
-use measurements::{Frequency, Temperature};
+use measurements::Temperature;
 use plant_ctrl2::sipo::ShiftRegister40;
 
 use anyhow::anyhow;
@@ -50,13 +50,8 @@ use one_wire_bus::OneWire;
 use crate::config::{self, Config, WifiConfig};
 use crate::STAY_ALIVE;
 
+//Only support for 8 right now!
 pub const PLANT_COUNT: usize = 8;
-const PINS_PER_PLANT: usize = 5;
-const PLANT_PUMP_OFFSET: usize = 0;
-const PLANT_FAULT_OFFSET: usize = 1;
-const PLANT_MOIST_PUMP_OFFSET: usize = 2;
-const PLANT_MOIST_A_OFFSET: usize = 3;
-const PLANT_MOIST_B_OFFSET: usize = 4;
 
 const SPIFFS_PARTITION_NAME: &str = "storage";
 const WIFI_CONFIG_FILE: &str = "/spiffs/wifi.cfg";
@@ -64,6 +59,51 @@ const CONFIG_FILE: &str = "/spiffs/config.cfg";
 
 const TANK_MULTI_SAMPLE: usize = 11;
 
+const PUMP8_BIT: usize = 0;
+const PUMP1_BIT: usize = 1;
+const PUMP2_BIT: usize = 2;
+const PUMP3_BIT: usize = 3;
+const PUMP4_BIT: usize = 4;
+const PUMP5_BIT: usize = 5;
+const PUMP6_BIT: usize = 6;
+const PUMP7_BIT: usize = 7;
+
+const MS_0: usize = 8;
+const MS_4: usize = 9;
+const MS_2: usize = 10;
+const MS_3: usize = 11;
+const SENSOR_ON: usize = 12;
+const MS_1: usize = 13;
+//unused 14
+//unused 15
+
+const FAULT_3: usize = 16;
+const FAULT_8: usize = 17;
+const FAULT_7: usize = 18;
+const FAULT_6: usize = 19;
+const FAULT_5: usize = 20;
+const FAULT_4: usize = 21;
+const FAULT_1: usize = 22;
+const FAULT_2: usize = 23;
+
+const SENSOR_A_1: u8 = 7;
+const SENSOR_A_2: u8 = 6;
+const SENSOR_A_3: u8 = 5;
+const SENSOR_A_4: u8 = 4;
+const SENSOR_A_5: u8 = 3;
+const SENSOR_A_6: u8 = 2;
+const SENSOR_A_7: u8 = 1;
+const SENSOR_A_8: u8 = 0;
+
+const SENSOR_B_1: u8 = 8;
+const SENSOR_B_2: u8 = 9;
+const SENSOR_B_3: u8 = 10;
+const SENSOR_B_4: u8 = 11;
+const SENSOR_B_5: u8 = 12;
+const SENSOR_B_6: u8 = 13;
+const SENSOR_B_7: u8 = 14;
+const SENSOR_B_8: u8 = 15;
+
 #[link_section = ".rtc.data"]
 static mut LAST_WATERING_TIMESTAMP: [i64; PLANT_COUNT] = [0; PLANT_COUNT];
 #[link_section = ".rtc.data"]
@@ -88,7 +128,6 @@ pub enum ClearConfigType {
 pub enum Sensor {
     A,
     B,
-    PUMP,
 }
 pub trait PlantCtrlBoardInteraction {
     fn time(&mut self) -> Result<chrono::DateTime<Utc>>;
@@ -125,7 +164,7 @@ pub trait PlantCtrlBoardInteraction {
     //keep state during deepsleep
     fn light(&mut self, enable: bool) -> Result<()>;
 
-    fn measure_moisture_hz(&self, plant: usize, sensor: Sensor) -> Result<i32>;
+    fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> Result<i32>;
     fn pump(&self, plant: usize, enable: bool) -> Result<()>;
     fn last_pump_time(&self, plant: usize) -> Option<chrono::DateTime<Utc>>;
     fn store_last_pump_time(&mut self, plant: usize, time: chrono::DateTime<Utc>);
@@ -149,6 +188,8 @@ pub trait PlantCtrlBoardInteraction {
     fn is_wifi_config_file_existant(&mut self) -> bool;
     fn mqtt(&mut self, config: &Config) -> Result<()>;
     fn mqtt_publish(&mut self, config: &Config, subtopic: &str, message: &[u8]) -> Result<()>;
+
+    fn sensor_multiplexer(&mut self, n: u8) -> Result<()>;
 }
 
 pub trait CreatePlantHal<'a> {
@@ -266,7 +307,17 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
     }
 
     fn pump(&self, plant: usize, enable: bool) -> Result<()> {
-        let index = plant * PINS_PER_PLANT + PLANT_PUMP_OFFSET;
+        let index = match plant {
+            0 => PUMP1_BIT,
+            1 => PUMP2_BIT,
+            2 => PUMP3_BIT,
+            3 => PUMP4_BIT,
+            4 => PUMP5_BIT,
+            5 => PUMP6_BIT,
+            6 => PUMP7_BIT,
+            7 => PUMP8_BIT,
+            _ => bail!("Invalid pump {plant}",),
+        };
         //currently infailable error, keep for future as result anyway
         self.shift_register.decompose()[index].set_state(enable.into())?;
         Ok(())
@@ -296,7 +347,17 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
     }
 
     fn fault(&self, plant: usize, enable: bool) {
-        let index = plant * PINS_PER_PLANT + PLANT_FAULT_OFFSET;
+        let index = match plant {
+            0 => FAULT_1,
+            1 => FAULT_2,
+            2 => FAULT_3,
+            3 => FAULT_4,
+            4 => FAULT_5,
+            5 => FAULT_6,
+            6 => FAULT_7,
+            7 => FAULT_8,
+            _ => panic!("Invalid plant id {}", plant)
+        };
         self.shift_register.decompose()[index]
             .set_state(enable.into())
             .unwrap()
@@ -338,28 +399,58 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
         self.time()
     }
 
-    fn measure_moisture_hz(&self, plant: usize, sensor: Sensor) -> Result<i32> {
+    fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> Result<i32> {
         self.signal_counter.counter_pause()?;
         self.signal_counter.counter_clear()?;
-        //
-        let offset = match sensor {
-            Sensor::A => PLANT_MOIST_A_OFFSET,
-            Sensor::B => PLANT_MOIST_B_OFFSET,
-            Sensor::PUMP => PLANT_MOIST_PUMP_OFFSET,
+        //Disable all
+        self.shift_register.decompose()[SENSOR_ON]
+            .set_high()
+            .unwrap();
+
+
+        let sensor_channel = match sensor {
+            Sensor::A => match plant {
+                0 => SENSOR_A_1,
+                1 => SENSOR_A_2,
+                2 => SENSOR_A_3,
+                3 => SENSOR_A_4,
+                4 => SENSOR_A_5,
+                5 => SENSOR_A_6,
+                6 => SENSOR_A_7,
+                7 => SENSOR_A_8,
+                _ => bail!("Invalid plant id {}", plant)
+            },
+            Sensor::B => match plant {
+                0 => SENSOR_B_1,
+                1 => SENSOR_B_2,
+                2 => SENSOR_B_3,
+                3 => SENSOR_B_4,
+                4 => SENSOR_B_5,
+                5 => SENSOR_B_6,
+                6 => SENSOR_B_7,
+                7 => SENSOR_B_8,
+                _ => bail!("Invalid plant id {}", plant)
+            },
         };
-        let index = plant * PINS_PER_PLANT + offset;
+
+        self.sensor_multiplexer(sensor_channel)?;
+
+        self.shift_register.decompose()[SENSOR_ON]
+            .set_low()
+            .unwrap();
 
         let delay = Delay::new_default();
         let measurement = 100;
         let factor = 1000 as f32 / measurement as f32;
 
-        self.shift_register.decompose()[index].set_high().unwrap();
         //give some time to stabilize
         delay.delay_ms(10);
         self.signal_counter.counter_resume()?;
         delay.delay_ms(measurement);
         self.signal_counter.counter_pause()?;
-        self.shift_register.decompose()[index].set_low().unwrap();
+        self.shift_register.decompose()[SENSOR_ON]
+            .set_high()
+            .unwrap();
         let unscaled = self.signal_counter.get_counter_value()? as i32;
         let hz = (unscaled as f32 * factor) as i32;
         println!("Measuring {:?} @ {} with {}", sensor, plant, hz);
@@ -367,7 +458,9 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
     }
 
     fn general_fault(&mut self, enable: bool) {
+        unsafe { gpio_hold_dis(self.general_fault.pin()) };
         self.general_fault.set_state(enable.into()).unwrap();
+        unsafe { gpio_hold_en(self.general_fault.pin()) };
     }
 
     fn wifi_ap(&mut self) -> Result<()> {
@@ -603,10 +696,6 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
         for i in 0..8 {
             self.measure_moisture_hz(i, Sensor::B)?;
         }
-        for i in 0..8 {
-            self.measure_moisture_hz(i, Sensor::PUMP)?;
-        }
-
         Ok(())
     }
 
@@ -801,7 +890,7 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
                 };
             }
             None => {
-                bail!("No mqtt client, aborting publish");
+                bail!("No mqtt client");
             }
         }
     }
@@ -885,6 +974,37 @@ impl PlantCtrlBoardInteraction for PlantCtrlBoard<'_> {
             None => bail!("Error reading State of Health bq34z100 not found"),
         }
     }
+
+    fn sensor_multiplexer(&mut self, n: u8) -> Result<()> {
+        assert!(n < 16);
+        let is_bit_set = |b: u8| -> bool { n & (1 << b) != 0 };
+
+        let pin_0 = &mut self.shift_register.decompose()[MS_0];
+        let pin_1 = &mut self.shift_register.decompose()[MS_1];
+        let pin_2 = &mut self.shift_register.decompose()[MS_2];
+        let pin_3 = &mut self.shift_register.decompose()[MS_3];
+        if is_bit_set(0) {
+            pin_0.set_high()?;
+        } else {
+            pin_0.set_low()?;
+        }
+        if is_bit_set(1) {
+            pin_1.set_high()?;
+        } else {
+            pin_1.set_low()?;
+        }
+        if is_bit_set(2) {
+            pin_2.set_high()?;
+        } else {
+            pin_2.set_low()?;
+        }
+        if is_bit_set(3) {
+            pin_3.set_high()?;
+        } else {
+            pin_3.set_low()?;
+        }
+        Ok(())
+    }
 }
 
 fn print_battery(
@@ -986,8 +1106,11 @@ impl CreatePlantHal<'_> for PlantHal {
 
         let mut one_wire_pin = PinDriver::input_output_od(peripherals.pins.gpio18)?;
         one_wire_pin.set_pull(Pull::Floating).unwrap();
-        //TODO make to none if not possible to init
 
+        //disable all
+        let ms4 = &mut shift_register.decompose()[MS_4];
+        ms4.set_high()?;
+        
         //init,reset rtc memory depending on cause
         let reasons = ResetReason::get();
         let reset_store = match reasons {