cleanups

Software/MainBoard/rust/src/config.rs

@@ -0,0 +1,156 @@
+use crate::hal::PLANT_COUNT;
+use crate::plant_state::PlantWateringMode;
+use alloc::string::String;
+use core::str::FromStr;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(default)]
+pub struct NetworkConfig {
+    pub ap_ssid: heapless::String<32>,
+    pub ssid: Option<heapless::String<32>>,
+    pub password: Option<heapless::String<64>>,
+    pub mqtt_url: Option<String>,
+    pub base_topic: Option<heapless::String<64>>,
+    pub mqtt_user: Option<String>,
+    pub mqtt_password: Option<String>,
+    pub max_wait: u32,
+}
+impl Default for NetworkConfig {
+    fn default() -> Self {
+        Self {
+            ap_ssid: heapless::String::from_str("PlantCtrl Init").unwrap(),
+            ssid: None,
+            password: None,
+            mqtt_url: None,
+            base_topic: None,
+            mqtt_user: None,
+            mqtt_password: None,
+            max_wait: 10000,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(default)]
+pub struct NightLampConfig {
+    pub enabled: bool,
+    pub night_lamp_hour_start: u8,
+    pub night_lamp_hour_end: u8,
+    pub night_lamp_only_when_dark: bool,
+    pub low_soc_cutoff: u8,
+    pub low_soc_restore: u8,
+}
+impl Default for NightLampConfig {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            night_lamp_hour_start: 19,
+            night_lamp_hour_end: 2,
+            night_lamp_only_when_dark: true,
+            low_soc_cutoff: 30,
+            low_soc_restore: 50,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(default)]
+pub struct TankConfig {
+    pub tank_sensor_enabled: bool,
+    pub tank_allow_pumping_if_sensor_error: bool,
+    pub tank_useable_ml: u32,
+    pub tank_warn_percent: u8,
+    pub tank_empty_percent: u8,
+    pub tank_full_percent: u8,
+    pub ml_per_pulse: f32,
+}
+impl Default for TankConfig {
+    fn default() -> Self {
+        Self {
+            tank_sensor_enabled: false,
+            tank_allow_pumping_if_sensor_error: true,
+            tank_useable_ml: 50000,
+            tank_warn_percent: 40,
+            tank_empty_percent: 5,
+            tank_full_percent: 95,
+            ml_per_pulse: 0.0,
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Default)]
+pub enum BatteryBoardVersion {
+    #[default]
+    Disabled,
+    BQ34Z100G1,
+    WchI2cSlave,
+}
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Default)]
+pub enum BoardVersion {
+    #[default]
+    INITIAL,
+    V3,
+    V4,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Default)]
+pub struct BoardHardware {
+    pub board: BoardVersion,
+    pub battery: BatteryBoardVersion,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Default)]
+#[serde(default)]
+pub struct PlantControllerConfig {
+    pub hardware: BoardHardware,
+    pub network: NetworkConfig,
+    pub tank: TankConfig,
+    pub night_lamp: NightLampConfig,
+    pub plants: [PlantConfig; PLANT_COUNT],
+    pub timezone: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(default)]
+pub struct PlantConfig {
+    pub mode: PlantWateringMode,
+    pub target_moisture: f32,
+    pub min_moisture: f32,
+    pub pump_time_s: u16,
+    pub pump_limit_ml: u16,
+    pub pump_cooldown_min: u16,
+    pub pump_hour_start: u8,
+    pub pump_hour_end: u8,
+    pub sensor_a: bool,
+    pub sensor_b: bool,
+    pub max_consecutive_pump_count: u8,
+    pub moisture_sensor_min_frequency: Option<f32>, // Optional min frequency
+    pub moisture_sensor_max_frequency: Option<f32>, // Optional max frequency
+    pub min_pump_current_ma: u16,
+    pub max_pump_current_ma: u16,
+    pub ignore_current_error: bool,
+}
+
+impl Default for PlantConfig {
+    fn default() -> Self {
+        Self {
+            mode: PlantWateringMode::OFF,
+            target_moisture: 40.,
+            min_moisture: 30.,
+            pump_time_s: 30,
+            pump_limit_ml: 5000,
+            pump_cooldown_min: 60,
+            pump_hour_start: 9,
+            pump_hour_end: 20,
+            sensor_a: true,
+            sensor_b: false,
+            max_consecutive_pump_count: 10,
+            moisture_sensor_min_frequency: None, // No override by default
+            moisture_sensor_max_frequency: None, // No override by default
+            min_pump_current_ma: 10,
+            max_pump_current_ma: 3000,
+            ignore_current_error: true,
+        }
+    }
+}

Software/MainBoard/rust/src/fat_error.rs

@@ -0,0 +1,318 @@
+use alloc::format;
+use alloc::string::{String, ToString};
+use core::convert::Infallible;
+use core::fmt;
+use core::str::Utf8Error;
+use embassy_embedded_hal::shared_bus::I2cDeviceError;
+use embassy_executor::SpawnError;
+use embassy_sync::mutex::TryLockError;
+use embedded_storage::nor_flash::NorFlashErrorKind;
+use esp_hal::i2c::master::ConfigError;
+use esp_hal::pcnt::unit::{InvalidHighLimit, InvalidLowLimit};
+use esp_hal::twai::EspTwaiError;
+use esp_wifi::wifi::WifiError;
+use ina219::errors::{BusVoltageReadError, ShuntVoltageReadError};
+use littlefs2_core::PathError;
+use onewire::Error;
+use pca9535::ExpanderError;
+
+//All error superconstruct
+#[derive(Debug)]
+pub enum FatError {
+    OneWireError {
+        error: Error<Infallible>,
+    },
+    String {
+        error: String,
+    },
+    LittleFSError {
+        error: littlefs2_core::Error,
+    },
+    PathError {
+        error: PathError,
+    },
+    TryLockError {
+        error: TryLockError,
+    },
+    WifiError {
+        error: WifiError,
+    },
+    SerdeError {
+        error: serde_json::Error,
+    },
+    PreconditionFailed {
+        error: String,
+    },
+    NoBatteryMonitor,
+    SpawnError {
+        error: SpawnError,
+    },
+    PartitionError {
+        error: esp_bootloader_esp_idf::partitions::Error,
+    },
+    I2CConfigError {
+        error: ConfigError,
+    },
+    DS323 {
+        error: String,
+    },
+    Eeprom24x {
+        error: String,
+    },
+    ExpanderError {
+        error: String,
+    },
+    CanBusError {
+        error: EspTwaiError,
+    },
+    SNTPError {
+        error: sntpc::Error,
+    },
+}
+
+pub type FatResult<T> = Result<T, FatError>;
+
+impl fmt::Display for FatError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            FatError::SpawnError { error } => {
+                write!(f, "SpawnError {:?}", error.to_string())
+            }
+            FatError::OneWireError { error } => write!(f, "OneWireError {:?}", error),
+            FatError::String { error } => write!(f, "{}", error),
+            FatError::LittleFSError { error } => write!(f, "LittleFSError {:?}", error),
+            FatError::PathError { error } => write!(f, "PathError {:?}", error),
+            FatError::TryLockError { error } => write!(f, "TryLockError {:?}", error),
+            FatError::WifiError { error } => write!(f, "WifiError {:?}", error),
+            FatError::SerdeError { error } => write!(f, "SerdeError {:?}", error),
+            FatError::PreconditionFailed { error } => write!(f, "PreconditionFailed {:?}", error),
+            FatError::PartitionError { error } => {
+                write!(f, "PartitionError {:?}", error)
+            }
+            FatError::NoBatteryMonitor => {
+                write!(f, "No Battery Monitor")
+            }
+            FatError::I2CConfigError { error } => write!(f, "I2CConfigError {:?}", error),
+            FatError::DS323 { error } => write!(f, "DS323 {:?}", error),
+            FatError::Eeprom24x { error } => write!(f, "Eeprom24x {:?}", error),
+            FatError::ExpanderError { error } => write!(f, "ExpanderError {:?}", error),
+            FatError::CanBusError { error } => {
+                write!(f, "CanBusError {:?}", error)
+            }
+            FatError::SNTPError { error } => write!(f, "SNTPError {:?}", error),
+        }
+    }
+}
+
+#[macro_export]
+macro_rules! bail {
+    ($msg:literal $(,)?) => {
+        return $crate::fat_error::fat_bail($msg)
+    };
+    ($fmt:literal, $($arg:tt)*) => {
+        return $crate::fat_error::fat_bail(&alloc::format!($fmt, $($arg)*))
+    };
+}
+
+pub fn fat_bail<X>(message: &str) -> Result<X, FatError> {
+    Err(FatError::String {
+        error: message.to_string(),
+    })
+}
+
+pub trait ContextExt<T> {
+    fn context<C>(self, context: C) -> Result<T, FatError>
+    where
+        C: AsRef<str>;
+}
+impl<T> ContextExt<T> for Option<T> {
+    fn context<C>(self, context: C) -> Result<T, FatError>
+    where
+        C: AsRef<str>,
+    {
+        match self {
+            Some(value) => Ok(value),
+            None => Err(FatError::PreconditionFailed {
+                error: context.as_ref().to_string(),
+            }),
+        }
+    }
+}
+
+impl From<Error<Infallible>> for FatError {
+    fn from(error: Error<Infallible>) -> Self {
+        FatError::OneWireError { error }
+    }
+}
+impl From<littlefs2_core::Error> for FatError {
+    fn from(value: littlefs2_core::Error) -> Self {
+        FatError::LittleFSError { error: value }
+    }
+}
+
+impl From<PathError> for FatError {
+    fn from(value: PathError) -> Self {
+        FatError::PathError { error: value }
+    }
+}
+
+impl From<TryLockError> for FatError {
+    fn from(value: TryLockError) -> Self {
+        FatError::TryLockError { error: value }
+    }
+}
+
+impl From<WifiError> for FatError {
+    fn from(value: WifiError) -> Self {
+        FatError::WifiError { error: value }
+    }
+}
+
+impl From<serde_json::error::Error> for FatError {
+    fn from(value: serde_json::Error) -> Self {
+        FatError::SerdeError { error: value }
+    }
+}
+
+impl From<SpawnError> for FatError {
+    fn from(value: SpawnError) -> Self {
+        FatError::SpawnError { error: value }
+    }
+}
+
+impl From<esp_bootloader_esp_idf::partitions::Error> for FatError {
+    fn from(value: esp_bootloader_esp_idf::partitions::Error) -> Self {
+        FatError::PartitionError { error: value }
+    }
+}
+
+impl From<Utf8Error> for FatError {
+    fn from(value: Utf8Error) -> Self {
+        FatError::String {
+            error: value.to_string(),
+        }
+    }
+}
+
+impl<E: core::fmt::Debug> From<edge_http::io::Error<E>> for FatError {
+    fn from(value: edge_http::io::Error<E>) -> Self {
+        FatError::String {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl<E: core::fmt::Debug> From<ds323x::Error<E>> for FatError {
+    fn from(value: ds323x::Error<E>) -> Self {
+        FatError::DS323 {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl<E: core::fmt::Debug> From<eeprom24x::Error<E>> for FatError {
+    fn from(value: eeprom24x::Error<E>) -> Self {
+        FatError::Eeprom24x {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl<E: core::fmt::Debug> From<ExpanderError<I2cDeviceError<E>>> for FatError {
+    fn from(value: ExpanderError<I2cDeviceError<E>>) -> Self {
+        FatError::ExpanderError {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl From<bincode::error::DecodeError> for FatError {
+    fn from(value: bincode::error::DecodeError) -> Self {
+        FatError::Eeprom24x {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl From<bincode::error::EncodeError> for FatError {
+    fn from(value: bincode::error::EncodeError) -> Self {
+        FatError::Eeprom24x {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl From<ConfigError> for FatError {
+    fn from(value: ConfigError) -> Self {
+        FatError::I2CConfigError { error: value }
+    }
+}
+
+impl<E: core::fmt::Debug> From<I2cDeviceError<E>> for FatError {
+    fn from(value: I2cDeviceError<E>) -> Self {
+        FatError::String {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl<E: core::fmt::Debug> From<BusVoltageReadError<I2cDeviceError<E>>> for FatError {
+    fn from(value: BusVoltageReadError<I2cDeviceError<E>>) -> Self {
+        FatError::String {
+            error: format!("{:?}", value),
+        }
+    }
+}
+impl<E: core::fmt::Debug> From<ShuntVoltageReadError<I2cDeviceError<E>>> for FatError {
+    fn from(value: ShuntVoltageReadError<I2cDeviceError<E>>) -> Self {
+        FatError::String {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl From<Infallible> for FatError {
+    fn from(value: Infallible) -> Self {
+        panic!("Infallible error: {:?}", value)
+    }
+}
+
+impl From<InvalidLowLimit> for FatError {
+    fn from(value: InvalidLowLimit) -> Self {
+        FatError::String {
+            error: format!("{:?}", value),
+        }
+    }
+}
+impl From<InvalidHighLimit> for FatError {
+    fn from(value: InvalidHighLimit) -> Self {
+        FatError::String {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl From<nb::Error<EspTwaiError>> for FatError {
+    fn from(value: nb::Error<EspTwaiError>) -> Self {
+        match value {
+            nb::Error::Other(can_error) => FatError::CanBusError { error: can_error },
+            nb::Error::WouldBlock => FatError::String {
+                error: "Would block".to_string(),
+            },
+        }
+    }
+}
+
+impl From<NorFlashErrorKind> for FatError {
+    fn from(value: NorFlashErrorKind) -> Self {
+        FatError::String {
+            error: value.to_string(),
+        }
+    }
+}
+
+impl From<sntpc::Error> for FatError {
+    fn from(value: sntpc::Error) -> Self {
+        FatError::SNTPError { error: value }
+    }
+}

Software/MainBoard/rust/src/hal/battery.rs

@@ -0,0 +1,258 @@
+use crate::fat_error::{FatError, FatResult};
+use crate::hal::Box;
+use async_trait::async_trait;
+use bq34z100::{Bq34z100g1, Bq34z100g1Driver, Flags};
+use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use esp_hal::delay::Delay;
+use esp_hal::i2c::master::I2c;
+use esp_hal::Blocking;
+use measurements::Temperature;
+use serde::Serialize;
+
+#[async_trait(?Send)]
+pub trait BatteryInteraction {
+    async fn state_charge_percent(&mut self) -> FatResult<f32>;
+    async fn remaining_milli_ampere_hour(&mut self) -> FatResult<u16>;
+    async fn max_milli_ampere_hour(&mut self) -> FatResult<u16>;
+    async fn design_milli_ampere_hour(&mut self) -> FatResult<u16>;
+    async fn voltage_milli_volt(&mut self) -> FatResult<u16>;
+    async fn average_current_milli_ampere(&mut self) -> FatResult<i16>;
+    async fn cycle_count(&mut self) -> FatResult<u16>;
+    async fn state_health_percent(&mut self) -> FatResult<u16>;
+    async fn bat_temperature(&mut self) -> FatResult<u16>;
+    async fn get_battery_state(&mut self) -> FatResult<BatteryState>;
+}
+
+#[derive(Debug, Serialize)]
+pub struct BatteryInfo {
+    pub voltage_milli_volt: u16,
+    pub average_current_milli_ampere: i16,
+    pub cycle_count: u16,
+    pub design_milli_ampere_hour: u16,
+    pub remaining_milli_ampere_hour: u16,
+    pub state_of_charge: f32,
+    pub state_of_health: u16,
+    pub temperature: u16,
+}
+
+#[derive(Debug, Serialize)]
+pub enum BatteryState {
+    Unknown,
+    Info(BatteryInfo),
+}
+
+/// If no battery monitor is installed this implementation will be used
+pub struct NoBatteryMonitor {}
+#[async_trait(?Send)]
+impl BatteryInteraction for NoBatteryMonitor {
+    async fn state_charge_percent(&mut self) -> FatResult<f32> {
+        // No monitor configured: assume full battery for lightstate logic
+        Ok(100.0)
+    }
+
+    async fn remaining_milli_ampere_hour(&mut self) -> FatResult<u16> {
+        Err(FatError::NoBatteryMonitor)
+    }
+
+    async fn max_milli_ampere_hour(&mut self) -> FatResult<u16> {
+        Err(FatError::NoBatteryMonitor)
+    }
+
+    async fn design_milli_ampere_hour(&mut self) -> FatResult<u16> {
+        Err(FatError::NoBatteryMonitor)
+    }
+
+    async fn voltage_milli_volt(&mut self) -> FatResult<u16> {
+        Err(FatError::NoBatteryMonitor)
+    }
+
+    async fn average_current_milli_ampere(&mut self) -> FatResult<i16> {
+        Err(FatError::NoBatteryMonitor)
+    }
+
+    async fn cycle_count(&mut self) -> FatResult<u16> {
+        Err(FatError::NoBatteryMonitor)
+    }
+
+    async fn state_health_percent(&mut self) -> FatResult<u16> {
+        Err(FatError::NoBatteryMonitor)
+    }
+
+    async fn bat_temperature(&mut self) -> FatResult<u16> {
+        Err(FatError::NoBatteryMonitor)
+    }
+
+    async fn get_battery_state(&mut self) -> FatResult<BatteryState> {
+        Ok(BatteryState::Unknown)
+    }
+}
+
+//TODO implement this battery monitor kind once controller is complete
+#[allow(dead_code)]
+pub struct WchI2cSlave {}
+
+pub type I2cDev = I2cDevice<'static, CriticalSectionRawMutex, I2c<'static, Blocking>>;
+
+pub struct BQ34Z100G1 {
+    pub battery_driver: Bq34z100g1Driver<I2cDev, Delay>,
+}
+
+#[async_trait(?Send)]
+impl BatteryInteraction for BQ34Z100G1 {
+    async fn state_charge_percent(&mut self) -> FatResult<f32> {
+        self.battery_driver
+            .state_of_charge()
+            .map(|v| v as f32)
+            .map_err(|e| FatError::String {
+                error: alloc::format!("{:?}", e),
+            })
+    }
+
+    async fn remaining_milli_ampere_hour(&mut self) -> FatResult<u16> {
+        self.battery_driver
+            .remaining_capacity()
+            .map_err(|e| FatError::String {
+                error: alloc::format!("{:?}", e),
+            })
+    }
+
+    async fn max_milli_ampere_hour(&mut self) -> FatResult<u16> {
+        self.battery_driver
+            .full_charge_capacity()
+            .map_err(|e| FatError::String {
+                error: alloc::format!("{:?}", e),
+            })
+    }
+
+    async fn design_milli_ampere_hour(&mut self) -> FatResult<u16> {
+        self.battery_driver
+            .design_capacity()
+            .map_err(|e| FatError::String {
+                error: alloc::format!("{:?}", e),
+            })
+    }
+
+    async fn voltage_milli_volt(&mut self) -> FatResult<u16> {
+        self.battery_driver.voltage().map_err(|e| FatError::String {
+            error: alloc::format!("{:?}", e),
+        })
+    }
+
+    async fn average_current_milli_ampere(&mut self) -> FatResult<i16> {
+        self.battery_driver
+            .average_current()
+            .map_err(|e| FatError::String {
+                error: alloc::format!("{:?}", e),
+            })
+    }
+
+    async fn cycle_count(&mut self) -> FatResult<u16> {
+        self.battery_driver
+            .cycle_count()
+            .map_err(|e| FatError::String {
+                error: alloc::format!("{:?}", e),
+            })
+    }
+
+    async fn state_health_percent(&mut self) -> FatResult<u16> {
+        self.battery_driver
+            .state_of_health()
+            .map_err(|e| FatError::String {
+                error: alloc::format!("{:?}", e),
+            })
+    }
+
+    async fn bat_temperature(&mut self) -> FatResult<u16> {
+        self.battery_driver
+            .temperature()
+            .map_err(|e| FatError::String {
+                error: alloc::format!("{:?}", e),
+            })
+    }
+
+    async fn get_battery_state(&mut self) -> FatResult<BatteryState> {
+        Ok(BatteryState::Info(BatteryInfo {
+            voltage_milli_volt: self.voltage_milli_volt().await?,
+            average_current_milli_ampere: self.average_current_milli_ampere().await?,
+            cycle_count: self.cycle_count().await?,
+            design_milli_ampere_hour: self.design_milli_ampere_hour().await?,
+            remaining_milli_ampere_hour: self.remaining_milli_ampere_hour().await?,
+            state_of_charge: self.state_charge_percent().await?,
+            state_of_health: self.state_health_percent().await?,
+            temperature: self.bat_temperature().await?,
+        }))
+    }
+}
+
+pub fn print_battery_bq34z100(
+    battery_driver: &mut Bq34z100g1Driver<I2cDevice<CriticalSectionRawMutex, I2c<Blocking>>, Delay>,
+) -> FatResult<()> {
+    log::info!("Try communicating with battery");
+    let fwversion = battery_driver.fw_version().unwrap_or_else(|e| {
+        log::info!("Firmware {:?}", e);
+        0
+    });
+    log::info!("fw version is {}", fwversion);
+
+    let design_capacity = battery_driver.design_capacity().unwrap_or_else(|e| {
+        log::info!("Design capacity {:?}", e);
+        0
+    });
+    log::info!("Design Capacity {}", design_capacity);
+    if design_capacity == 1000 {
+        log::info!("Still stock configuring battery, readouts are likely to be wrong!");
+    }
+
+    let flags = battery_driver.get_flags_decoded().unwrap_or(Flags {
+        fast_charge_allowed: false,
+        full_chage: false,
+        charging_not_allowed: false,
+        charge_inhibit: false,
+        bat_low: false,
+        bat_high: false,
+        over_temp_discharge: false,
+        over_temp_charge: false,
+        discharge: false,
+        state_of_charge_f: false,
+        state_of_charge_1: false,
+        cf: false,
+        ocv_taken: false,
+    });
+    log::info!("Flags {:?}", flags);
+
+    let chem_id = battery_driver.chem_id().unwrap_or_else(|e| {
+        log::info!("Chemid {:?}", e);
+        0
+    });
+
+    let bat_temp = battery_driver.internal_temperature().unwrap_or_else(|e| {
+        log::info!("Bat Temp {:?}", e);
+        0
+    });
+    let temp_c = Temperature::from_kelvin(bat_temp as f64 / 10_f64).as_celsius();
+    let voltage = battery_driver.voltage().unwrap_or_else(|e| {
+        log::info!("Bat volt {:?}", e);
+        0
+    });
+    let current = battery_driver.current().unwrap_or_else(|e| {
+        log::info!("Bat current {:?}", e);
+        0
+    });
+    let state = battery_driver.state_of_charge().unwrap_or_else(|e| {
+        log::info!("Bat Soc {:?}", e);
+        0
+    });
+    let charge_voltage = battery_driver.charge_voltage().unwrap_or_else(|e| {
+        log::info!("Bat Charge Volt {:?}", e);
+        0
+    });
+    let charge_current = battery_driver.charge_current().unwrap_or_else(|e| {
+        log::info!("Bat Charge Current {:?}", e);
+        0
+    });
+    log::info!("ChemId: {} Current voltage {} and current {} with charge {}% and temp {} CVolt: {} CCur {}", chem_id, voltage, current, state, temp_c, charge_voltage, charge_current);
+    let _ = battery_driver.unsealed();
+    let _ = battery_driver.it_enable();
+    Ok(())
+}

Software/MainBoard/rust/src/hal/can_api.rs

@@ -0,0 +1,13 @@
+use crate::hal::Sensor;
+use bincode::{Decode, Encode};
+
+pub(crate) const SENSOR_BASE_ADDRESS: u16 = 1000;
+#[derive(Debug, Clone, Copy, Encode, Decode)]
+pub(crate) struct AutoDetectRequest {}
+
+#[derive(Debug, Clone, Copy, Encode, Decode)]
+pub(crate) struct ResponseMoisture {
+    pub plant: u8,
+    pub sensor: Sensor,
+    pub hz: u32,
+}

Software/MainBoard/rust/src/hal/esp.rs

@@ -0,0 +1,994 @@
+use crate::bail;
+use crate::config::{NetworkConfig, PlantControllerConfig};
+use crate::hal::{PLANT_COUNT, TIME_ACCESS};
+use crate::log::{LogMessage, LOG_ACCESS};
+use chrono::{DateTime, Utc};
+use serde::Serialize;
+
+use crate::fat_error::{ContextExt, FatError, FatResult};
+use crate::hal::little_fs2storage_adapter::LittleFs2Filesystem;
+use alloc::string::ToString;
+use alloc::sync::Arc;
+use alloc::{format, string::String, vec, vec::Vec};
+use core::net::{IpAddr, Ipv4Addr, SocketAddr};
+use core::str::FromStr;
+use core::sync::atomic::Ordering;
+use embassy_executor::Spawner;
+use embassy_net::udp::UdpSocket;
+use embassy_net::{DhcpConfig, Ipv4Cidr, Runner, Stack, StackResources, StaticConfigV4};
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::mutex::{Mutex, MutexGuard};
+use embassy_sync::once_lock::OnceLock;
+use embassy_time::{Duration, Timer, WithTimeout};
+use embedded_storage::nor_flash::{check_erase, NorFlash, ReadNorFlash};
+use esp_bootloader_esp_idf::ota::OtaImageState::Valid;
+use esp_bootloader_esp_idf::ota::{Ota, OtaImageState, Slot};
+use esp_bootloader_esp_idf::partitions::FlashRegion;
+use esp_hal::gpio::{Input, RtcPinWithResistors};
+use esp_hal::rng::Rng;
+use esp_hal::rtc_cntl::{
+    sleep::{TimerWakeupSource, WakeupLevel},
+    Rtc,
+};
+use esp_hal::system::software_reset;
+use esp_println::println;
+use esp_storage::FlashStorage;
+use esp_wifi::wifi::{
+    AccessPointConfiguration, AccessPointInfo, AuthMethod, ClientConfiguration, Configuration,
+    ScanConfig, ScanTypeConfig, WifiController, WifiDevice, WifiState,
+};
+use littlefs2::fs::Filesystem;
+use littlefs2_core::{FileType, PathBuf, SeekFrom};
+use log::{info, warn};
+use mcutie::{
+    Error, McutieBuilder, McutieReceiver, McutieTask, MqttMessage, PublishDisplay, Publishable,
+    QoS, Topic,
+};
+use portable_atomic::AtomicBool;
+use smoltcp::socket::udp::PacketMetadata;
+use smoltcp::wire::DnsQueryType;
+use sntpc::{get_time, NtpContext, NtpTimestampGenerator};
+
+#[esp_hal::ram(rtc_fast, persistent)]
+static mut LAST_WATERING_TIMESTAMP: [i64; PLANT_COUNT] = [0; PLANT_COUNT];
+#[esp_hal::ram(rtc_fast, persistent)]
+static mut CONSECUTIVE_WATERING_PLANT: [u32; PLANT_COUNT] = [0; PLANT_COUNT];
+#[esp_hal::ram(rtc_fast, persistent)]
+static mut LOW_VOLTAGE_DETECTED: i8 = 0;
+#[esp_hal::ram(rtc_fast, persistent)]
+static mut RESTART_TO_CONF: i8 = 0;
+
+const CONFIG_FILE: &str = "config.json";
+const NTP_SERVER: &str = "pool.ntp.org";
+
+static MQTT_CONNECTED_EVENT_RECEIVED: AtomicBool = AtomicBool::new(false);
+static MQTT_ROUND_TRIP_RECEIVED: AtomicBool = AtomicBool::new(false);
+pub static MQTT_STAY_ALIVE: AtomicBool = AtomicBool::new(false);
+static MQTT_BASE_TOPIC: OnceLock<String> = OnceLock::new();
+
+#[derive(Serialize, Debug)]
+pub struct FileInfo {
+    filename: String,
+    size: usize,
+}
+
+#[derive(Serialize, Debug)]
+pub struct FileList {
+    total: usize,
+    used: usize,
+    files: Vec<FileInfo>,
+}
+
+#[derive(Copy, Clone, Default)]
+struct Timestamp {
+    stamp: DateTime<Utc>,
+}
+
+// Minimal esp-idf equivalent for gpio_hold on esp32c6 via ROM functions
+extern "C" {
+    fn gpio_pad_hold(gpio_num: u32);
+    fn gpio_pad_unhold(gpio_num: u32);
+}
+
+#[inline(always)]
+pub fn hold_enable(gpio_num: u8) {
+    unsafe { gpio_pad_hold(gpio_num as u32) }
+}
+
+#[inline(always)]
+pub fn hold_disable(gpio_num: u8) {
+    unsafe { gpio_pad_unhold(gpio_num as u32) }
+}
+
+impl NtpTimestampGenerator for Timestamp {
+    fn init(&mut self) {
+        self.stamp = DateTime::default();
+    }
+
+    fn timestamp_sec(&self) -> u64 {
+        self.stamp.timestamp() as u64
+    }
+
+    fn timestamp_subsec_micros(&self) -> u32 {
+        self.stamp.timestamp_subsec_micros()
+    }
+}
+
+pub struct Esp<'a> {
+    pub fs: Arc<Mutex<CriticalSectionRawMutex, Filesystem<'static, LittleFs2Filesystem>>>,
+    pub rng: Rng,
+    //first starter (ap or sta will take these)
+    pub interface_sta: Option<WifiDevice<'static>>,
+    pub interface_ap: Option<WifiDevice<'static>>,
+    pub controller: Arc<Mutex<CriticalSectionRawMutex, WifiController<'static>>>,
+
+    pub boot_button: Input<'a>,
+
+    // RTC-capable GPIO used as external wake source (store the raw peripheral)
+    pub wake_gpio1: esp_hal::peripherals::GPIO1<'static>,
+
+    pub ota: Ota<'static, FlashStorage>,
+    pub ota_target: &'static mut FlashRegion<'static, FlashStorage>,
+    pub current: Slot,
+    pub slot0_state: OtaImageState,
+    pub slot1_state: OtaImageState,
+}
+
+// SAFETY: On this target we never move Esp across OS threads; the firmware runs single-core
+// cooperative tasks with Embassy. All interior mutability of non-Send peripherals is gated
+// behind &mut self or embassy_sync Mutex with CriticalSectionRawMutex, which does not rely on
+// thread scheduling. Therefore it is sound to mark Esp as Send to satisfy trait object bounds
+// (e.g., Box<dyn BoardInteraction + Send>). If you add fields that are accessed from multiple
+// CPU cores/threads, reconsider this.
+unsafe impl Send for Esp<'_> {}
+
+macro_rules! mk_static {
+    ($t:ty,$val:expr) => {{
+        static STATIC_CELL: static_cell::StaticCell<$t> = static_cell::StaticCell::new();
+        #[deny(unused_attributes)]
+        let x = STATIC_CELL.uninit().write(($val));
+        x
+    }};
+}
+
+impl Esp<'_> {
+    pub(crate) async fn delete_file(&self, filename: String) -> FatResult<()> {
+        let file = PathBuf::try_from(filename.as_str())?;
+        let access = self.fs.lock().await;
+        access.remove(&*file)?;
+        Ok(())
+    }
+    pub(crate) async fn write_file(
+        &mut self,
+        filename: String,
+        offset: u32,
+        buf: &[u8],
+    ) -> Result<(), FatError> {
+        let file = PathBuf::try_from(filename.as_str())?;
+        let access = self.fs.lock().await;
+        access.open_file_with_options_and_then(
+            |options| options.read(true).write(true).create(true),
+            &*file,
+            |file| {
+                file.seek(SeekFrom::Start(offset))?;
+                file.write(buf)?;
+                Ok(())
+            },
+        )?;
+        Ok(())
+    }
+
+    pub async fn get_size(&mut self, filename: String) -> FatResult<usize> {
+        let file = PathBuf::try_from(filename.as_str())?;
+        let access = self.fs.lock().await;
+        let data = access.metadata(&*file)?;
+        Ok(data.len())
+    }
+    pub(crate) async fn get_file(
+        &mut self,
+        filename: String,
+        chunk: u32,
+    ) -> FatResult<([u8; 512], usize)> {
+        use littlefs2::io::Error as lfs2Error;
+
+        let file = PathBuf::try_from(filename.as_str())?;
+        let access = self.fs.lock().await;
+        let mut buf = [0_u8; 512];
+        let mut read = 0;
+        let offset = chunk * buf.len() as u32;
+        access.open_file_with_options_and_then(
+            |options| options.read(true),
+            &*file,
+            |file| {
+                let length = file.len()? as u32;
+                if length == 0 {
+                    Err(lfs2Error::IO)
+                } else if length > offset {
+                    file.seek(SeekFrom::Start(offset))?;
+                    read = file.read(&mut buf)?;
+                    Ok(())
+                } else {
+                    //exactly at end, do nothing
+                    Ok(())
+                }
+            },
+        )?;
+        Ok((buf, read))
+    }
+
+    pub(crate) async fn write_ota(&mut self, offset: u32, buf: &[u8]) -> Result<(), FatError> {
+        let _ = check_erase(self.ota_target, offset, offset + 4096);
+        self.ota_target.erase(offset, offset + 4096)?;
+
+        let mut temp = vec![0; buf.len()];
+        let read_back = temp.as_mut_slice();
+        //change to nor flash, align writes!
+        self.ota_target.write(offset, buf)?;
+        self.ota_target.read(offset, read_back)?;
+        if buf != read_back {
+            info!("Expected {:?} but got {:?}", buf, read_back);
+            bail!(
+                "Flash error, read back does not match write buffer at offset {:x}",
+                offset
+            )
+        }
+        Ok(())
+    }
+
+    pub(crate) async fn finalize_ota(&mut self) -> Result<(), FatError> {
+        let current = self.ota.current_slot()?;
+        if self.ota.current_ota_state()? != OtaImageState::Valid {
+            info!(
+                "Validating current slot {:?} as it was able to ota",
+                current
+            );
+            self.ota.set_current_ota_state(Valid)?;
+        }
+
+        self.ota.set_current_slot(current.next())?;
+        info!("switched slot");
+        self.ota.set_current_ota_state(OtaImageState::New)?;
+        info!("switched state for new partition");
+        let state_new = self.ota.current_ota_state()?;
+        info!("state on new partition now {:?}", state_new);
+        //determine nextslot crc
+
+        self.set_restart_to_conf(true);
+        Ok(())
+    }
+
+    pub(crate) fn mode_override_pressed(&mut self) -> bool {
+        self.boot_button.is_low()
+    }
+
+    pub(crate) async fn sntp(
+        &mut self,
+        _max_wait_ms: u32,
+        stack: Stack<'_>,
+    ) -> FatResult<DateTime<Utc>> {
+        println!("start sntp");
+        let mut rx_meta = [PacketMetadata::EMPTY; 16];
+        let mut rx_buffer = [0; 4096];
+        let mut tx_meta = [PacketMetadata::EMPTY; 16];
+        let mut tx_buffer = [0; 4096];
+
+        let mut socket = UdpSocket::new(
+            stack,
+            &mut rx_meta,
+            &mut rx_buffer,
+            &mut tx_meta,
+            &mut tx_buffer,
+        );
+        socket.bind(123).unwrap();
+
+        let context = NtpContext::new(Timestamp::default());
+
+        let ntp_addrs = stack
+            .dns_query(NTP_SERVER, DnsQueryType::A)
+            .await
+            .expect("Failed to resolve DNS");
+        if ntp_addrs.is_empty() {
+            bail!("Failed to resolve DNS");
+        }
+        info!("NTP server: {:?}", ntp_addrs);
+
+        let mut counter = 0;
+        loop {
+            let addr: IpAddr = ntp_addrs[0].into();
+            let timeout = get_time(SocketAddr::from((addr, 123)), &socket, context)
+                .with_timeout(Duration::from_millis((_max_wait_ms / 10) as u64))
+                .await;
+
+            match timeout {
+                Ok(result) => {
+                    let time = result?;
+                    info!("Time: {:?}", time);
+                    return DateTime::from_timestamp(time.seconds as i64, 0)
+                        .context("Could not convert Sntp result");
+                }
+                Err(err) => {
+                    warn!("sntp timeout, retry: {:?}", err);
+                    counter += 1;
+                    if counter > 10 {
+                        bail!("Failed to get time from NTP server");
+                    }
+                    Timer::after(Duration::from_millis(100)).await;
+                }
+            }
+        }
+    }
+
+    pub(crate) async fn wifi_scan(&mut self) -> FatResult<Vec<AccessPointInfo>> {
+        info!("start wifi scan");
+        let mut lock = self.controller.try_lock()?;
+        info!("start wifi scan lock");
+        let scan_config = ScanConfig {
+            ssid: None,
+            bssid: None,
+            channel: None,
+            show_hidden: false,
+            scan_type: ScanTypeConfig::Active {
+                min: Default::default(),
+                max: Default::default(),
+            },
+        };
+        let rv = lock.scan_with_config_async(scan_config).await?;
+        info!("end wifi scan lock");
+        Ok(rv)
+    }
+
+    pub(crate) fn last_pump_time(&self, plant: usize) -> Option<DateTime<Utc>> {
+        let ts = unsafe { LAST_WATERING_TIMESTAMP }[plant];
+        DateTime::from_timestamp_millis(ts)
+    }
+    pub(crate) fn store_last_pump_time(&mut self, plant: usize, time: DateTime<Utc>) {
+        unsafe {
+            LAST_WATERING_TIMESTAMP[plant] = time.timestamp_millis();
+        }
+    }
+    pub(crate) fn set_low_voltage_in_cycle(&mut self) {
+        unsafe {
+            LOW_VOLTAGE_DETECTED = 1;
+        }
+    }
+    pub(crate) fn clear_low_voltage_in_cycle(&mut self) {
+        unsafe {
+            LOW_VOLTAGE_DETECTED = 0;
+        }
+    }
+
+    pub(crate) fn low_voltage_in_cycle(&mut self) -> bool {
+        unsafe { LOW_VOLTAGE_DETECTED == 1 }
+    }
+    pub(crate) fn store_consecutive_pump_count(&mut self, plant: usize, count: u32) {
+        unsafe {
+            CONSECUTIVE_WATERING_PLANT[plant] = count;
+        }
+    }
+    pub(crate) fn consecutive_pump_count(&mut self, plant: usize) -> u32 {
+        unsafe { CONSECUTIVE_WATERING_PLANT[plant] }
+    }
+    pub(crate) fn get_restart_to_conf(&mut self) -> bool {
+        unsafe { RESTART_TO_CONF == 1 }
+    }
+    pub(crate) fn set_restart_to_conf(&mut self, to_conf: bool) {
+        unsafe {
+            if to_conf {
+                RESTART_TO_CONF = 1;
+            } else {
+                RESTART_TO_CONF = 0;
+            }
+        }
+    }
+
+    pub(crate) async fn wifi_ap(&mut self) -> FatResult<Stack<'static>> {
+        let ssid = match self.load_config().await {
+            Ok(config) => config.network.ap_ssid.as_str().to_string(),
+            Err(_) => "PlantCtrl Emergency Mode".to_string(),
+        };
+
+        let spawner = Spawner::for_current_executor().await;
+
+        let device = self.interface_ap.take().unwrap();
+        let gw_ip_addr_str = "192.168.71.1";
+        let gw_ip_addr = Ipv4Addr::from_str(gw_ip_addr_str).expect("failed to parse gateway ip");
+
+        let config = embassy_net::Config::ipv4_static(StaticConfigV4 {
+            address: Ipv4Cidr::new(gw_ip_addr, 24),
+            gateway: Some(gw_ip_addr),
+            dns_servers: Default::default(),
+        });
+
+        let seed = (self.rng.random() as u64) << 32 | self.rng.random() as u64;
+
+        println!("init secondary stack");
+        // Init network stack
+        let (stack, runner) = embassy_net::new(
+            device,
+            config,
+            mk_static!(StackResources<4>, StackResources::<4>::new()),
+            seed,
+        );
+        let stack = mk_static!(Stack, stack);
+
+        let client_config = Configuration::AccessPoint(AccessPointConfiguration {
+            ssid: ssid.clone(),
+            ..Default::default()
+        });
+
+        self.controller
+            .lock()
+            .await
+            .set_configuration(&client_config)?;
+
+        println!("start new");
+        self.controller.lock().await.start()?;
+        println!("start net task");
+        spawner.spawn(net_task(runner)).ok();
+        println!("run dhcp");
+        spawner.spawn(run_dhcp(stack.clone(), gw_ip_addr_str)).ok();
+
+        loop {
+            if stack.is_link_up() {
+                break;
+            }
+            Timer::after(Duration::from_millis(500)).await;
+        }
+        while !stack.is_config_up() {
+            Timer::after(Duration::from_millis(100)).await
+        }
+        println!("Connect to the AP `${ssid}` and point your browser to http://{gw_ip_addr_str}/");
+        stack
+            .config_v4()
+            .inspect(|c| println!("ipv4 config: {c:?}"));
+
+        Ok(stack.clone())
+    }
+
+    pub(crate) async fn wifi(
+        &mut self,
+        network_config: &NetworkConfig,
+    ) -> FatResult<Stack<'static>> {
+        esp_wifi::wifi_set_log_verbose();
+        let ssid = network_config.ssid.clone();
+        match &ssid {
+            Some(ssid) => {
+                if ssid.is_empty() {
+                    bail!("Wifi ssid was empty")
+                }
+            }
+            None => {
+                bail!("Wifi ssid was empty")
+            }
+        }
+        let ssid = ssid.unwrap().to_string();
+        info!("attempting to connect wifi {ssid}");
+        let password = match network_config.password {
+            Some(ref password) => password.to_string(),
+            None => "".to_string(),
+        };
+        let max_wait = network_config.max_wait;
+
+        let spawner = Spawner::for_current_executor().await;
+
+        let device = self.interface_sta.take().unwrap();
+        let config = embassy_net::Config::dhcpv4(DhcpConfig::default());
+
+        let seed = (self.rng.random() as u64) << 32 | self.rng.random() as u64;
+
+        // Init network stack
+        let (stack, runner) = embassy_net::new(
+            device,
+            config,
+            mk_static!(StackResources<8>, StackResources::<8>::new()),
+            seed,
+        );
+        let stack = mk_static!(Stack, stack);
+
+        let client_config = Configuration::Client(ClientConfiguration {
+            ssid,
+            bssid: None,
+            auth_method: AuthMethod::WPA2Personal, //FIXME read from config, fill via scan
+            password,
+            channel: None,
+        });
+        self.controller
+            .lock()
+            .await
+            .set_configuration(&client_config)?;
+        spawner.spawn(net_task(runner)).ok();
+        self.controller.lock().await.start_async().await?;
+
+        let timeout = {
+            let guard = TIME_ACCESS.get().await.lock().await;
+            guard.current_time_us()
+        } + max_wait as u64 * 1000;
+        loop {
+            let state = esp_wifi::wifi::sta_state();
+            match state {
+                WifiState::StaStarted => {
+                    self.controller.lock().await.connect()?;
+                    break;
+                }
+                _ => {}
+            }
+            if {
+                let guard = TIME_ACCESS.get().await.lock().await;
+                guard.current_time_us()
+            } > timeout
+            {
+                bail!("Timeout waiting for wifi sta ready")
+            }
+            Timer::after(Duration::from_millis(500)).await;
+        }
+        let timeout = {
+            let guard = TIME_ACCESS.get().await.lock().await;
+            guard.current_time_us()
+        } + max_wait as u64 * 1000;
+        loop {
+            let state = esp_wifi::wifi::sta_state();
+            match state {
+                WifiState::StaConnected => {
+                    break;
+                }
+                _ => {}
+            }
+            if {
+                let guard = TIME_ACCESS.get().await.lock().await;
+                guard.current_time_us()
+            } > timeout
+            {
+                bail!("Timeout waiting for wifi sta connected")
+            }
+            Timer::after(Duration::from_millis(500)).await;
+        }
+        let timeout = {
+            let guard = TIME_ACCESS.get().await.lock().await;
+            guard.current_time_us()
+        } + max_wait as u64 * 1000;
+        while !stack.is_link_up() {
+            if {
+                let guard = TIME_ACCESS.get().await.lock().await;
+                guard.current_time_us()
+            } > timeout
+            {
+                bail!("Timeout waiting for wifi link up")
+            }
+            Timer::after(Duration::from_millis(500)).await;
+        }
+        let timeout = {
+            let guard = TIME_ACCESS.get().await.lock().await;
+            guard.current_time_us()
+        } + max_wait as u64 * 1000;
+        while !stack.is_config_up() {
+            if {
+                let guard = TIME_ACCESS.get().await.lock().await;
+                guard.current_time_us()
+            } > timeout
+            {
+                bail!("Timeout waiting for wifi config up")
+            }
+            Timer::after(Duration::from_millis(100)).await
+        }
+
+        info!("Connected WIFI, dhcp: {:?}", stack.config_v4());
+        Ok(stack.clone())
+    }
+
+    pub fn deep_sleep(
+        &mut self,
+        duration_in_ms: u64,
+        mut rtc: MutexGuard<CriticalSectionRawMutex, Rtc>,
+    ) -> ! {
+        // Configure and enter deep sleep using esp-hal. Also keep prior behavior where
+        // duration_in_ms == 0 triggers an immediate reset.
+
+        // Mark the current OTA image as valid if we reached here while in pending verify.
+        if let Ok(cur) = self.ota.current_ota_state() {
+            if cur == OtaImageState::PendingVerify {
+                self.ota
+                    .set_current_ota_state(OtaImageState::Valid)
+                    .expect("Could not set image to valid");
+            }
+        }
+
+        if duration_in_ms == 0 {
+            software_reset();
+        } else {
+            let timer = TimerWakeupSource::new(core::time::Duration::from_millis(duration_in_ms));
+            let mut wake_pins: [(&mut dyn RtcPinWithResistors, WakeupLevel); 1] =
+                [(&mut self.wake_gpio1, WakeupLevel::Low)];
+            let ext1 = esp_hal::rtc_cntl::sleep::Ext1WakeupSource::new(&mut wake_pins);
+            rtc.sleep_deep(&[&timer, &ext1]);
+        }
+    }
+
+    pub(crate) async fn load_config(&mut self) -> FatResult<PlantControllerConfig> {
+        let cfg = PathBuf::try_from(CONFIG_FILE)?;
+        let config_exist = self.fs.lock().await.exists(&cfg);
+        if !config_exist {
+            bail!("No config file stored")
+        }
+        let data = self.fs.lock().await.read::<4096>(&cfg)?;
+        let config: PlantControllerConfig = serde_json::from_slice(&data)?;
+        return Ok(config);
+    }
+    pub(crate) async fn save_config(&mut self, config: Vec<u8>) -> FatResult<()> {
+        let filesystem = self.fs.lock().await;
+        let cfg = PathBuf::try_from(CONFIG_FILE)?;
+        filesystem.write(&cfg, &*config)?;
+        Ok(())
+    }
+    pub(crate) async fn list_files(&self) -> FatResult<FileList> {
+        let path = PathBuf::new();
+
+        let fs = self.fs.lock().await;
+        let free_size = fs.available_space()?;
+        let total_size = fs.total_space();
+
+        let mut result = FileList {
+            total: total_size,
+            used: total_size - free_size,
+            files: Vec::new(),
+        };
+
+        fs.read_dir_and_then(&path, |dir| {
+            for entry in dir {
+                let e = entry?;
+                if e.file_type() == FileType::File {
+                    result.files.push(FileInfo {
+                        filename: e.path().to_string(),
+                        size: e.metadata().len(),
+                    });
+                }
+            }
+            Ok(())
+        })?;
+        Ok(result)
+    }
+
+    pub(crate) async fn init_rtc_deepsleep_memory(
+        &self,
+        init_rtc_store: bool,
+        to_config_mode: bool,
+    ) {
+        if init_rtc_store {
+            unsafe {
+                LAST_WATERING_TIMESTAMP = [0; PLANT_COUNT];
+                CONSECUTIVE_WATERING_PLANT = [0; PLANT_COUNT];
+                LOW_VOLTAGE_DETECTED = 0;
+                if to_config_mode {
+                    RESTART_TO_CONF = 1
+                } else {
+                    RESTART_TO_CONF = 0;
+                }
+            };
+        } else {
+            unsafe {
+                if to_config_mode {
+                    RESTART_TO_CONF = 1;
+                }
+                LOG_ACCESS
+                    .lock()
+                    .await
+                    .log(
+                        LogMessage::RestartToConfig,
+                        RESTART_TO_CONF as u32,
+                        0,
+                        "",
+                        "",
+                    )
+                    .await;
+                LOG_ACCESS
+                    .lock()
+                    .await
+                    .log(
+                        LogMessage::LowVoltage,
+                        LOW_VOLTAGE_DETECTED as u32,
+                        0,
+                        "",
+                        "",
+                    )
+                    .await;
+                for i in 0..PLANT_COUNT {
+                    log::info!(
+                        "LAST_WATERING_TIMESTAMP[{}] = UTC {}",
+                        i,
+                        LAST_WATERING_TIMESTAMP[i]
+                    );
+                }
+                for i in 0..PLANT_COUNT {
+                    log::info!(
+                        "CONSECUTIVE_WATERING_PLANT[{}] = {}",
+                        i,
+                        CONSECUTIVE_WATERING_PLANT[i]
+                    );
+                }
+            }
+        }
+    }
+
+    pub(crate) async fn mqtt(
+        &mut self,
+        network_config: &'static NetworkConfig,
+        stack: Stack<'static>,
+    ) -> FatResult<()> {
+        let base_topic = network_config
+            .base_topic
+            .as_ref()
+            .context("missing base topic")?;
+        if base_topic.is_empty() {
+            bail!("Mqtt base_topic was empty")
+        }
+        MQTT_BASE_TOPIC
+            .init(base_topic.to_string())
+            .map_err(|_| FatError::String {
+                error: "Error setting basetopic".to_string(),
+            })?;
+
+        let mqtt_url = network_config
+            .mqtt_url
+            .as_ref()
+            .context("missing mqtt url")?;
+        if mqtt_url.is_empty() {
+            bail!("Mqtt url was empty")
+        }
+
+        let last_will_topic = format!("{}/state", base_topic);
+        let round_trip_topic = format!("{}/internal/roundtrip", base_topic);
+        let stay_alive_topic = format!("{}/stay_alive", base_topic);
+
+        let mut builder: McutieBuilder<'_, String, PublishDisplay<String, &str>, 0> =
+            McutieBuilder::new(stack, "plant ctrl", mqtt_url);
+        if network_config.mqtt_user.is_some() && network_config.mqtt_password.is_some() {
+            builder = builder.with_authentication(
+                network_config.mqtt_user.as_ref().unwrap().as_str(),
+                network_config.mqtt_password.as_ref().unwrap().as_str(),
+            );
+            info!("With authentification");
+        }
+
+        let lwt = Topic::General(last_will_topic);
+        let lwt = mk_static!(Topic<String>, lwt);
+        let lwt = lwt.with_display("lost").retain(true).qos(QoS::AtLeastOnce);
+        builder = builder.with_last_will(lwt);
+        //TODO make configurable
+        builder = builder.with_device_id("plantctrl");
+
+        let builder: McutieBuilder<'_, String, PublishDisplay<String, &str>, 2> = builder
+            .with_subscriptions([
+                Topic::General(round_trip_topic.clone()),
+                Topic::General(stay_alive_topic.clone()),
+            ]);
+
+        let keep_alive = Duration::from_secs(60 * 60 * 2).as_secs() as u16;
+        let (receiver, task) = builder.build(keep_alive);
+
+        let spawner = Spawner::for_current_executor().await;
+        spawner.spawn(mqtt_incoming_task(
+            receiver,
+            round_trip_topic.clone(),
+            stay_alive_topic.clone(),
+        ))?;
+        spawner.spawn(mqtt_runner(task))?;
+
+        LOG_ACCESS
+            .lock()
+            .await
+            .log(LogMessage::StayAlive, 0, 0, "", &stay_alive_topic)
+            .await;
+
+        LOG_ACCESS
+            .lock()
+            .await
+            .log(LogMessage::MqttInfo, 0, 0, "", mqtt_url)
+            .await;
+
+        let mqtt_timeout = 15000;
+        let timeout = {
+            let guard = TIME_ACCESS.get().await.lock().await;
+            guard.current_time_us()
+        } + mqtt_timeout as u64 * 1000;
+        while !MQTT_CONNECTED_EVENT_RECEIVED.load(Ordering::Relaxed) {
+            let cur = TIME_ACCESS.get().await.lock().await.current_time_us();
+            if cur > timeout {
+                bail!("Timeout waiting MQTT connect event")
+            }
+            Timer::after(Duration::from_millis(100)).await;
+        }
+
+        Topic::General(round_trip_topic.clone())
+            .with_display("online_text")
+            .publish()
+            .await
+            .unwrap();
+
+        let timeout = {
+            let guard = TIME_ACCESS.get().await.lock().await;
+            guard.current_time_us()
+        } + mqtt_timeout as u64 * 1000;
+        while !MQTT_ROUND_TRIP_RECEIVED.load(Ordering::Relaxed) {
+            let cur = TIME_ACCESS.get().await.lock().await.current_time_us();
+            if cur > timeout {
+                //ensure we do not further try to publish
+                MQTT_CONNECTED_EVENT_RECEIVED.store(false, Ordering::Relaxed);
+                bail!("Timeout waiting MQTT roundtrip")
+            }
+            Timer::after(Duration::from_millis(100)).await;
+        }
+        Ok(())
+    }
+
+    pub(crate) async fn mqtt_inner(&mut self, subtopic: &str, message: &str) -> FatResult<()> {
+        if !subtopic.starts_with("/") {
+            bail!("Subtopic without / at start {}", subtopic);
+        }
+        if subtopic.len() > 192 {
+            bail!("Subtopic exceeds 192 chars {}", subtopic);
+        }
+        let base_topic = MQTT_BASE_TOPIC
+            .try_get()
+            .context("missing base topic in static!")?;
+
+        let full_topic = format!("{base_topic}{subtopic}");
+
+        loop {
+            let result = Topic::General(full_topic.as_str())
+                .with_display(message)
+                .retain(true)
+                .publish()
+                .await;
+            match result {
+                Ok(()) => return Ok(()),
+                Err(err) => {
+                    let retry = match err {
+                        Error::IOError => false,
+                        Error::TimedOut => true,
+                        Error::TooLarge => false,
+                        Error::PacketError => false,
+                        Error::Invalid => false,
+                    };
+                    if !retry {
+                        bail!(
+                            "Error during mqtt send on topic {} with message {:#?} error is {:?}",
+                            &full_topic,
+                            message,
+                            err
+                        );
+                    }
+                    info!(
+                        "Retransmit for {} with message {:#?} error is {:?} retrying {}",
+                        &full_topic, message, err, retry
+                    );
+                    Timer::after(Duration::from_millis(100)).await;
+                }
+            }
+        }
+    }
+    pub(crate) async fn mqtt_publish(&mut self, subtopic: &str, message: &str) {
+        let online = MQTT_CONNECTED_EVENT_RECEIVED.load(Ordering::Relaxed);
+        if !online {
+            return;
+        }
+        let roundtrip_ok = MQTT_ROUND_TRIP_RECEIVED.load(Ordering::Relaxed);
+        if !roundtrip_ok {
+            info!("MQTT roundtrip not received yet, dropping message");
+            return;
+        }
+        match self.mqtt_inner(subtopic, message).await {
+            Ok(()) => {}
+            Err(err) => {
+                info!(
+                    "Error during mqtt send on topic {} with message {:#?} error is {:?}",
+                    subtopic, message, err
+                );
+            }
+        };
+    }
+}
+
+#[embassy_executor::task]
+async fn mqtt_runner(
+    task: McutieTask<'static, String, PublishDisplay<'static, String, &'static str>, 2>,
+) {
+    task.run().await;
+}
+
+#[embassy_executor::task]
+async fn mqtt_incoming_task(
+    receiver: McutieReceiver,
+    round_trip_topic: String,
+    stay_alive_topic: String,
+) {
+    loop {
+        let message = receiver.receive().await;
+        match message {
+            MqttMessage::Connected => {
+                info!("Mqtt connected");
+                MQTT_CONNECTED_EVENT_RECEIVED.store(true, Ordering::Relaxed);
+            }
+            MqttMessage::Publish(topic, payload) => match topic {
+                Topic::DeviceType(_type_topic) => {}
+                Topic::Device(_device_topic) => {}
+                Topic::General(topic) => {
+                    let subtopic = topic.as_str();
+
+                    if subtopic.eq(round_trip_topic.as_str()) {
+                        MQTT_ROUND_TRIP_RECEIVED.store(true, Ordering::Relaxed);
+                    } else if subtopic.eq(stay_alive_topic.as_str()) {
+                        let value = payload.eq_ignore_ascii_case("true".as_ref())
+                            || payload.eq_ignore_ascii_case("1".as_ref());
+                        let a = match value {
+                            true => 1,
+                            false => 0,
+                        };
+                        LOG_ACCESS
+                            .lock()
+                            .await
+                            .log(LogMessage::MqttStayAliveRec, a, 0, "", "")
+                            .await;
+                        MQTT_STAY_ALIVE.store(value, Ordering::Relaxed);
+                    } else {
+                        LOG_ACCESS
+                            .lock()
+                            .await
+                            .log(LogMessage::UnknownTopic, 0, 0, "", &*topic)
+                            .await;
+                    }
+                }
+            },
+            MqttMessage::Disconnected => {
+                MQTT_CONNECTED_EVENT_RECEIVED.store(false, Ordering::Relaxed);
+                info!("Mqtt disconnected");
+            }
+            MqttMessage::HomeAssistantOnline => {
+                info!("Home assistant is online");
+            }
+        }
+    }
+}
+
+#[embassy_executor::task(pool_size = 2)]
+async fn net_task(mut runner: Runner<'static, WifiDevice<'static>>) {
+    runner.run().await;
+}
+
+#[embassy_executor::task]
+async fn run_dhcp(stack: Stack<'static>, gw_ip_addr: &'static str) {
+    use core::net::{Ipv4Addr, SocketAddrV4};
+
+    use edge_dhcp::{
+        io::{self, DEFAULT_SERVER_PORT},
+        server::{Server, ServerOptions},
+    };
+    use edge_nal::UdpBind;
+    use edge_nal_embassy::{Udp, UdpBuffers};
+
+    let ip = Ipv4Addr::from_str(gw_ip_addr).expect("dhcp task failed to parse gw ip");
+
+    let mut buf = [0u8; 1500];
+
+    let mut gw_buf = [Ipv4Addr::UNSPECIFIED];
+
+    let buffers = UdpBuffers::<3, 1024, 1024, 10>::new();
+    let unbound_socket = Udp::new(stack, &buffers);
+    let mut bound_socket = unbound_socket
+        .bind(SocketAddr::V4(SocketAddrV4::new(
+            Ipv4Addr::UNSPECIFIED,
+            DEFAULT_SERVER_PORT,
+        )))
+        .await
+        .unwrap();
+
+    loop {
+        _ = io::server::run(
+            &mut Server::<_, 64>::new_with_et(ip),
+            &ServerOptions::new(ip, Some(&mut gw_buf)),
+            &mut bound_socket,
+            &mut buf,
+        )
+        .await
+        .inspect_err(|e| log::warn!("DHCP server error: {e:?}"));
+        Timer::after(Duration::from_millis(500)).await;
+    }
+}

Software/MainBoard/rust/src/hal/initial_hal.rs

@@ -0,0 +1,144 @@
+use crate::alloc::boxed::Box;
+use crate::fat_error::{FatError, FatResult};
+use crate::hal::esp::Esp;
+use crate::hal::rtc::{BackupHeader, RTCModuleInteraction};
+use crate::hal::water::TankSensor;
+use crate::hal::{BoardInteraction, FreePeripherals, Moistures, TIME_ACCESS};
+use crate::{
+    bail,
+    config::PlantControllerConfig,
+    hal::battery::{BatteryInteraction, NoBatteryMonitor},
+};
+use async_trait::async_trait;
+use chrono::{DateTime, Utc};
+use esp_hal::gpio::{Level, Output, OutputConfig};
+use measurements::{Current, Voltage};
+
+pub struct Initial<'a> {
+    pub(crate) general_fault: Output<'a>,
+    pub(crate) esp: Esp<'a>,
+    pub(crate) config: PlantControllerConfig,
+    pub(crate) battery: Box<dyn BatteryInteraction + Send>,
+    pub rtc: Box<dyn RTCModuleInteraction + Send>,
+}
+
+pub(crate) struct NoRTC {}
+
+#[async_trait(?Send)]
+impl RTCModuleInteraction for NoRTC {
+    async fn get_backup_info(&mut self) -> Result<BackupHeader, FatError> {
+        bail!("Please configure board revision")
+    }
+
+    async fn get_backup_config(&mut self, _chunk: usize) -> FatResult<([u8; 32], usize, u16)> {
+        bail!("Please configure board revision")
+    }
+
+    async fn backup_config(&mut self, _offset: usize, _bytes: &[u8]) -> FatResult<()> {
+        bail!("Please configure board revision")
+    }
+
+    async fn backup_config_finalize(&mut self, _crc: u16, _length: usize) -> FatResult<()> {
+        bail!("Please configure board revision")
+    }
+
+    async fn get_rtc_time(&mut self) -> Result<DateTime<Utc>, FatError> {
+        bail!("Please configure board revision")
+    }
+
+    async fn set_rtc_time(&mut self, _time: &DateTime<Utc>) -> Result<(), FatError> {
+        bail!("Please configure board revision")
+    }
+}
+
+pub(crate) fn create_initial_board(
+    free_pins: FreePeripherals<'static>,
+    config: PlantControllerConfig,
+    esp: Esp<'static>,
+) -> Result<Box<dyn BoardInteraction<'static> + Send>, FatError> {
+    log::info!("Start initial");
+    let general_fault = Output::new(free_pins.gpio23, Level::Low, OutputConfig::default());
+    let v = Initial {
+        general_fault,
+        config,
+        esp,
+        battery: Box::new(NoBatteryMonitor {}),
+        rtc: Box::new(NoRTC {}),
+    };
+    Ok(Box::new(v))
+}
+
+#[async_trait(?Send)]
+impl<'a> BoardInteraction<'a> for Initial<'a> {
+    fn get_tank_sensor(&mut self) -> Result<&mut TankSensor<'a>, FatError> {
+        bail!("Please configure board revision")
+    }
+
+    fn get_esp(&mut self) -> &mut Esp<'a> {
+        &mut self.esp
+    }
+
+    fn get_config(&mut self) -> &PlantControllerConfig {
+        &self.config
+    }
+
+    fn get_battery_monitor(&mut self) -> &mut Box<dyn BatteryInteraction + Send> {
+        &mut self.battery
+    }
+
+    fn get_rtc_module(&mut self) -> &mut Box<dyn RTCModuleInteraction + Send> {
+        &mut self.rtc
+    }
+
+    async fn set_charge_indicator(&mut self, _charging: bool) -> Result<(), FatError> {
+        bail!("Please configure board revision")
+    }
+
+    async fn deep_sleep(&mut self, duration_in_ms: u64) -> ! {
+        let rtc = TIME_ACCESS.get().await.lock().await;
+        self.esp.deep_sleep(duration_in_ms, rtc);
+    }
+    fn is_day(&self) -> bool {
+        false
+    }
+    async fn light(&mut self, _enable: bool) -> Result<(), FatError> {
+        bail!("Please configure board revision")
+    }
+
+    async fn pump(&mut self, _plant: usize, _enable: bool) -> Result<(), FatError> {
+        bail!("Please configure board revision")
+    }
+
+    async fn pump_current(&mut self, _plant: usize) -> Result<Current, FatError> {
+        bail!("Please configure board revision")
+    }
+
+    async fn fault(&mut self, _plant: usize, _enable: bool) -> Result<(), FatError> {
+        bail!("Please configure board revision")
+    }
+
+    async fn measure_moisture_hz(&mut self) -> Result<Moistures, FatError> {
+        bail!("Please configure board revision")
+    }
+
+
+    async fn general_fault(&mut self, enable: bool) {
+        self.general_fault.set_level(enable.into());
+    }
+
+    async fn test(&mut self) -> Result<(), FatError> {
+        bail!("Please configure board revision")
+    }
+
+    fn set_config(&mut self, config: PlantControllerConfig) {
+        self.config = config;
+    }
+
+    async fn get_mptt_voltage(&mut self) -> Result<Voltage, FatError> {
+        bail!("Please configure board revision")
+    }
+
+    async fn get_mptt_current(&mut self) -> Result<Current, FatError> {
+        bail!("Please configure board revision")
+    }
+}

Software/MainBoard/rust/src/hal/little_fs2storage_adapter.rs

@@ -0,0 +1,88 @@
+use embedded_storage::nor_flash::{check_erase, NorFlash, ReadNorFlash};
+use esp_bootloader_esp_idf::partitions::FlashRegion;
+use esp_storage::FlashStorage;
+use littlefs2::consts::U4096 as lfsCache;
+use littlefs2::consts::U512 as lfsLookahead;
+use littlefs2::driver::Storage as lfs2Storage;
+use littlefs2::io::Error as lfs2Error;
+use littlefs2::io::Result as lfs2Result;
+use log::error;
+
+pub struct LittleFs2Filesystem {
+    pub(crate) storage: &'static mut FlashRegion<'static, FlashStorage>,
+}
+
+impl lfs2Storage for LittleFs2Filesystem {
+    const READ_SIZE: usize = 4096;
+    const WRITE_SIZE: usize = 4096;
+    const BLOCK_SIZE: usize = 4096; //usually optimal for flash access
+    const BLOCK_COUNT: usize = 8 * 1000 * 1000 / 4096; //8Mb in 4k blocks + a little space for stupid calculation errors
+    const BLOCK_CYCLES: isize = 100;
+    type CACHE_SIZE = lfsCache;
+    type LOOKAHEAD_SIZE = lfsLookahead;
+
+    fn read(&mut self, off: usize, buf: &mut [u8]) -> lfs2Result<usize> {
+        let read_size: usize = Self::READ_SIZE;
+        if off % read_size != 0 {
+            error!("Littlefs2Filesystem read error: offset not aligned to read size offset: {} read_size: {}", off, read_size);
+            return Err(lfs2Error::IO);
+        }
+        if buf.len() % read_size != 0 {
+            error!("Littlefs2Filesystem read error: length not aligned to read size length: {} read_size: {}", buf.len(), read_size);
+            return Err(lfs2Error::IO);
+        }
+        match self.storage.read(off as u32, buf) {
+            Ok(..) => Ok(buf.len()),
+            Err(err) => {
+                error!("Littlefs2Filesystem read error: {:?}", err);
+                Err(lfs2Error::IO)
+            }
+        }
+    }
+
+    fn write(&mut self, off: usize, data: &[u8]) -> lfs2Result<usize> {
+        let write_size: usize = Self::WRITE_SIZE;
+        if off % write_size != 0 {
+            error!("Littlefs2Filesystem write error: offset not aligned to write size offset: {} write_size: {}", off, write_size);
+            return Err(lfs2Error::IO);
+        }
+        if data.len() % write_size != 0 {
+            error!("Littlefs2Filesystem write error: length not aligned to write size length: {} write_size: {}", data.len(), write_size);
+            return Err(lfs2Error::IO);
+        }
+        match self.storage.write(off as u32, data) {
+            Ok(..) => Ok(data.len()),
+            Err(err) => {
+                error!("Littlefs2Filesystem write error: {:?}", err);
+                Err(lfs2Error::IO)
+            }
+        }
+    }
+
+    fn erase(&mut self, off: usize, len: usize) -> lfs2Result<usize> {
+        let block_size: usize = Self::BLOCK_SIZE;
+        if off % block_size != 0 {
+            error!("Littlefs2Filesystem erase error: offset not aligned to block size offset: {} block_size: {}", off, block_size);
+            return lfs2Result::Err(lfs2Error::IO);
+        }
+        if len % block_size != 0 {
+            error!("Littlefs2Filesystem erase error: length not aligned to block size length: {} block_size: {}", len, block_size);
+            return lfs2Result::Err(lfs2Error::IO);
+        }
+
+        match check_erase(self.storage, off as u32, (off+len) as u32) {
+            Ok(_) => {}
+            Err(err) => {
+                error!("Littlefs2Filesystem check erase error: {:?}", err);
+                return lfs2Result::Err(lfs2Error::IO);
+            }
+        }
+        match self.storage.erase(off as u32, (off + len) as u32) {
+            Ok(..) => lfs2Result::Ok(len),
+            Err(err) => {
+                error!("Littlefs2Filesystem erase error: {:?}", err);
+                lfs2Result::Err(lfs2Error::IO)
+            }
+        }
+    }
+}

Software/MainBoard/rust/src/hal/mod.rs

@@ -0,0 +1,715 @@
+pub(crate) mod battery;
+// mod can_api; // replaced by external canapi crate
+pub mod esp;
+mod initial_hal;
+mod little_fs2storage_adapter;
+pub(crate) mod rtc;
+mod v3_hal;
+mod v3_shift_register;
+mod v4_hal;
+pub(crate) mod v4_sensor;
+mod water;
+use crate::alloc::string::ToString;
+use crate::hal::rtc::{DS3231Module, RTCModuleInteraction};
+use esp_hal::peripherals::Peripherals;
+use esp_hal::peripherals::ADC1;
+use esp_hal::peripherals::GPIO0;
+use esp_hal::peripherals::GPIO10;
+use esp_hal::peripherals::GPIO11;
+use esp_hal::peripherals::GPIO12;
+use esp_hal::peripherals::GPIO13;
+use esp_hal::peripherals::GPIO14;
+use esp_hal::peripherals::GPIO15;
+use esp_hal::peripherals::GPIO16;
+use esp_hal::peripherals::GPIO17;
+use esp_hal::peripherals::GPIO18;
+use esp_hal::peripherals::GPIO2;
+use esp_hal::peripherals::GPIO21;
+use esp_hal::peripherals::GPIO22;
+use esp_hal::peripherals::GPIO23;
+use esp_hal::peripherals::GPIO24;
+use esp_hal::peripherals::GPIO25;
+use esp_hal::peripherals::GPIO26;
+use esp_hal::peripherals::GPIO27;
+use esp_hal::peripherals::GPIO28;
+use esp_hal::peripherals::GPIO29;
+use esp_hal::peripherals::GPIO3;
+use esp_hal::peripherals::GPIO30;
+use esp_hal::peripherals::GPIO4;
+use esp_hal::peripherals::GPIO5;
+use esp_hal::peripherals::GPIO6;
+use esp_hal::peripherals::GPIO7;
+use esp_hal::peripherals::GPIO8;
+use esp_hal::peripherals::TWAI0;
+
+use crate::{
+    bail,
+    config::{BatteryBoardVersion, BoardVersion, PlantControllerConfig},
+    hal::{
+        battery::{BatteryInteraction, NoBatteryMonitor},
+        esp::Esp,
+    },
+    log::LogMessage,
+    BOARD_ACCESS,
+};
+use alloc::boxed::Box;
+use alloc::format;
+use alloc::sync::Arc;
+use async_trait::async_trait;
+use bincode::{Decode, Encode};
+use bq34z100::Bq34z100g1Driver;
+use chrono::{DateTime, FixedOffset, Utc};
+use core::cell::RefCell;
+use canapi::SensorSlot;
+use ds323x::ic::DS3231;
+use ds323x::interface::I2cInterface;
+use ds323x::{DateTimeAccess, Ds323x};
+use eeprom24x::addr_size::TwoBytes;
+use eeprom24x::page_size::B32;
+use eeprom24x::unique_serial::No;
+use eeprom24x::{Eeprom24x, SlaveAddr, Storage};
+use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::blocking_mutex::CriticalSectionMutex;
+use esp_bootloader_esp_idf::partitions::{
+    AppPartitionSubType, DataPartitionSubType, FlashRegion, PartitionEntry,
+};
+use esp_hal::clock::CpuClock;
+use esp_hal::gpio::{Input, InputConfig, Pull};
+use measurements::{Current, Voltage};
+
+use crate::fat_error::{ContextExt, FatError, FatResult};
+use crate::hal::battery::{print_battery_bq34z100, BQ34Z100G1};
+use crate::hal::little_fs2storage_adapter::LittleFs2Filesystem;
+use crate::hal::water::TankSensor;
+use crate::log::LOG_ACCESS;
+use embassy_sync::mutex::Mutex;
+use embassy_sync::once_lock::OnceLock;
+use embedded_storage::nor_flash::ReadNorFlash;
+use esp_alloc as _;
+use esp_backtrace as _;
+use esp_bootloader_esp_idf::ota::{Ota, OtaImageState};
+use esp_bootloader_esp_idf::ota::{Slot as ota_slot, Slot};
+use esp_hal::delay::Delay;
+use esp_hal::i2c::master::{BusTimeout, Config, I2c};
+use esp_hal::pcnt::unit::Unit;
+use esp_hal::pcnt::Pcnt;
+use esp_hal::rng::Rng;
+use esp_hal::rtc_cntl::{Rtc, SocResetReason};
+use esp_hal::system::reset_reason;
+use esp_hal::time::Rate;
+use esp_hal::timer::timg::TimerGroup;
+use esp_hal::Blocking;
+use esp_storage::FlashStorage;
+use esp_wifi::{init, EspWifiController};
+use littlefs2::fs::{Allocation, Filesystem as lfs2Filesystem};
+use littlefs2::object_safe::DynStorage;
+use log::{error, info, warn};
+use portable_atomic::AtomicBool;
+use serde::Serialize;
+
+
+pub static TIME_ACCESS: OnceLock<Mutex<CriticalSectionRawMutex, Rtc>> = OnceLock::new();
+
+//Only support for 8 right now!
+pub const PLANT_COUNT: usize = 8;
+
+pub static PROGRESS_ACTIVE: AtomicBool = AtomicBool::new(false);
+
+const TANK_MULTI_SAMPLE: usize = 11;
+pub static I2C_DRIVER: OnceLock<
+    embassy_sync::blocking_mutex::Mutex<CriticalSectionRawMutex, RefCell<I2c<Blocking>>>,
+> = OnceLock::new();
+
+#[derive(Debug, PartialEq, Clone, Copy, Encode, Decode)]
+pub enum Sensor {
+    A,
+    B,
+}
+
+impl Into<SensorSlot> for Sensor {
+    fn into(self) -> SensorSlot {
+        match self {
+            Sensor::A => SensorSlot::A,
+            Sensor::B => SensorSlot::B,
+        }
+    }
+}
+
+pub struct PlantHal {}
+
+pub struct HAL<'a> {
+    pub board_hal: Box<dyn BoardInteraction<'a> + Send>,
+}
+
+#[async_trait(?Send)]
+pub trait BoardInteraction<'a> {
+    fn get_tank_sensor(&mut self) -> Result<&mut TankSensor<'a>, FatError>;
+    fn get_esp(&mut self) -> &mut Esp<'a>;
+    fn get_config(&mut self) -> &PlantControllerConfig;
+    fn get_battery_monitor(&mut self) -> &mut Box<dyn BatteryInteraction + Send>;
+    fn get_rtc_module(&mut self) -> &mut Box<dyn RTCModuleInteraction + Send>;
+    async fn set_charge_indicator(&mut self, charging: bool) -> Result<(), FatError>;
+    async fn deep_sleep(&mut self, duration_in_ms: u64) -> !;
+
+    fn is_day(&self) -> bool;
+    //should be multsampled
+    async fn light(&mut self, enable: bool) -> FatResult<()>;
+    async fn pump(&mut self, plant: usize, enable: bool) -> FatResult<()>;
+    async fn pump_current(&mut self, plant: usize) -> FatResult<Current>;
+    async fn fault(&mut self, plant: usize, enable: bool) -> FatResult<()>;
+    async fn measure_moisture_hz(&mut self) -> Result<Moistures, FatError>;
+    async fn general_fault(&mut self, enable: bool);
+    async fn test(&mut self) -> FatResult<()>;
+    fn set_config(&mut self, config: PlantControllerConfig);
+    async fn get_mptt_voltage(&mut self) -> FatResult<Voltage>;
+    async fn get_mptt_current(&mut self) -> FatResult<Current>;
+
+    // Return JSON string with autodetected sensors per plant. Default: not supported.
+    async fn detect_sensors(&mut self) -> FatResult<DetectionResult> {
+        bail!("Autodetection is only available on v4 HAL with CAN bus");
+    }
+
+    async fn progress(&mut self, counter: u32) {
+        // Indicate progress is active to suppress default wait_infinity blinking
+        crate::hal::PROGRESS_ACTIVE.store(true, core::sync::atomic::Ordering::Relaxed);
+
+        let current = counter % PLANT_COUNT as u32;
+        for led in 0..PLANT_COUNT {
+            if let Err(err) = self.fault(led, current == led as u32).await {
+                warn!("Fault on plant {}: {:?}", led, err);
+            }
+        }
+        let even = counter % 2 == 0;
+        let _ = self.general_fault(even.into()).await;
+    }
+
+    async fn clear_progress(&mut self) {
+        for led in 0..PLANT_COUNT {
+            if let Err(err) = self.fault(led, false).await {
+                warn!("Fault on plant {}: {:?}", led, err);
+            }
+        }
+        let _ = self.general_fault(false).await;
+
+        // Reset progress active flag so wait_infinity can resume blinking
+        crate::hal::PROGRESS_ACTIVE.store(false, core::sync::atomic::Ordering::Relaxed);
+    }
+}
+
+#[allow(dead_code)]
+pub struct FreePeripherals<'a> {
+    pub gpio0: GPIO0<'a>,
+    pub gpio2: GPIO2<'a>,
+    pub gpio3: GPIO3<'a>,
+    pub gpio4: GPIO4<'a>,
+    pub gpio5: GPIO5<'a>,
+    pub gpio6: GPIO6<'a>,
+    pub gpio7: GPIO7<'a>,
+    pub gpio8: GPIO8<'a>,
+    // //config button here
+    pub gpio10: GPIO10<'a>,
+    pub gpio11: GPIO11<'a>,
+    pub gpio12: GPIO12<'a>,
+    pub gpio13: GPIO13<'a>,
+    pub gpio14: GPIO14<'a>,
+    pub gpio15: GPIO15<'a>,
+    pub gpio16: GPIO16<'a>,
+    pub gpio17: GPIO17<'a>,
+    pub gpio18: GPIO18<'a>,
+    // //i2c here
+    pub gpio21: GPIO21<'a>,
+    pub gpio22: GPIO22<'a>,
+    pub gpio23: GPIO23<'a>,
+    pub gpio24: GPIO24<'a>,
+    pub gpio25: GPIO25<'a>,
+    pub gpio26: GPIO26<'a>,
+    pub gpio27: GPIO27<'a>,
+    pub gpio28: GPIO28<'a>,
+    pub gpio29: GPIO29<'a>,
+    pub gpio30: GPIO30<'a>,
+    pub twai: TWAI0<'a>,
+    pub pcnt0: Unit<'a, 0>,
+    pub pcnt1: Unit<'a, 1>,
+    pub adc1: ADC1<'a>,
+}
+
+macro_rules! mk_static {
+    ($t:ty,$val:expr) => {{
+        static STATIC_CELL: static_cell::StaticCell<$t> = static_cell::StaticCell::new();
+        #[deny(unused_attributes)]
+        let x = STATIC_CELL.uninit().write(($val));
+        x
+    }};
+}
+
+impl PlantHal {
+    pub async fn create() -> Result<Mutex<CriticalSectionRawMutex, HAL<'static>>, FatError> {
+        let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
+        let peripherals: Peripherals = esp_hal::init(config);
+
+        esp_alloc::heap_allocator!(size: 64 * 1024);
+        esp_alloc::heap_allocator!(#[link_section = ".dram2_uninit"] size: 64000);
+
+        let rtc: Rtc = Rtc::new(peripherals.LPWR);
+        TIME_ACCESS
+            .init(Mutex::new(rtc))
+            .map_err(|_| FatError::String {
+                error: "Init error rct".to_string(),
+            })?;
+
+        let systimer = SystemTimer::new(peripherals.SYSTIMER);
+
+        let boot_button = Input::new(
+            peripherals.GPIO9,
+            InputConfig::default().with_pull(Pull::None),
+        );
+
+        // Reserve GPIO1 for deep sleep wake (configured just before entering sleep)
+        let wake_gpio1 = peripherals.GPIO1;
+
+        let rng = Rng::new(peripherals.RNG);
+        let timg0 = TimerGroup::new(peripherals.TIMG0);
+        let esp_wifi_ctrl = &*mk_static!(
+            EspWifiController<'static>,
+            init(timg0.timer0, rng.clone()).expect("Could not init wifi controller")
+        );
+
+        let (controller, interfaces) =
+            esp_wifi::wifi::new(&esp_wifi_ctrl, peripherals.WIFI).expect("Could not init wifi");
+
+        use esp_hal::timer::systimer::SystemTimer;
+        esp_hal_embassy::init(systimer.alarm0);
+
+        //let mut adc1 = Adc::new(peripherals.ADC1, adc1_config);
+        //
+
+        let pcnt_module = Pcnt::new(peripherals.PCNT);
+
+        let free_pins = FreePeripherals {
+            //     can: peripherals.can,
+            //     adc1: peripherals.adc1,
+            //     pcnt0: peripherals.pcnt0,
+            //     pcnt1: peripherals.pcnt1,
+            gpio0: peripherals.GPIO0,
+            gpio2: peripherals.GPIO2,
+            gpio3: peripherals.GPIO3,
+            gpio4: peripherals.GPIO4,
+            gpio5: peripherals.GPIO5,
+            gpio6: peripherals.GPIO6,
+            gpio7: peripherals.GPIO7,
+            gpio8: peripherals.GPIO8,
+            gpio10: peripherals.GPIO10,
+            gpio11: peripherals.GPIO11,
+            gpio12: peripherals.GPIO12,
+            gpio13: peripherals.GPIO13,
+            gpio14: peripherals.GPIO14,
+            gpio15: peripherals.GPIO15,
+            gpio16: peripherals.GPIO16,
+            gpio17: peripherals.GPIO17,
+            gpio18: peripherals.GPIO18,
+            gpio21: peripherals.GPIO21,
+            gpio22: peripherals.GPIO22,
+            gpio23: peripherals.GPIO23,
+            gpio24: peripherals.GPIO24,
+            gpio25: peripherals.GPIO25,
+            gpio26: peripherals.GPIO26,
+            gpio27: peripherals.GPIO27,
+            gpio28: peripherals.GPIO28,
+            gpio29: peripherals.GPIO29,
+            gpio30: peripherals.GPIO30,
+            twai: peripherals.TWAI0,
+            pcnt0: pcnt_module.unit0,
+            pcnt1: pcnt_module.unit1,
+            adc1: peripherals.ADC1,
+        };
+
+        let tablebuffer = mk_static!(
+            [u8; esp_bootloader_esp_idf::partitions::PARTITION_TABLE_MAX_LEN],
+            [0u8; esp_bootloader_esp_idf::partitions::PARTITION_TABLE_MAX_LEN]
+        );
+        let storage_ota = mk_static!(FlashStorage, FlashStorage::new());
+        let pt =
+            esp_bootloader_esp_idf::partitions::read_partition_table(storage_ota, tablebuffer)?;
+
+        let ota_data = mk_static!(
+            PartitionEntry,
+            pt.find_partition(esp_bootloader_esp_idf::partitions::PartitionType::Data(
+                DataPartitionSubType::Ota,
+            ))?
+            .expect("No OTA data partition found")
+        );
+
+        let ota_data = mk_static!(
+            FlashRegion<FlashStorage>,
+            ota_data.as_embedded_storage(storage_ota)
+        );
+
+        let state_0 = ota_state(ota_slot::Slot0, ota_data);
+        let state_1 = ota_state(ota_slot::Slot1, ota_data);
+        let mut ota = Ota::new(ota_data)?;
+        let running = get_current_slot_and_fix_ota_data(&mut ota, state_0, state_1)?;
+        let target = running.next();
+
+        info!("Currently running OTA slot: {:?}", running);
+        info!("Slot0 state: {:?}", state_0);
+        info!("Slot1 state: {:?}", state_1);
+
+        //obtain current_state and next_state here!
+        let ota_target = match target {
+            Slot::None => {
+                panic!("No OTA slot active?");
+            }
+            Slot::Slot0 => pt
+                .find_partition(esp_bootloader_esp_idf::partitions::PartitionType::App(
+                    AppPartitionSubType::Ota0,
+                ))?
+                .context("Partition table invalid no ota0")?,
+            Slot::Slot1 => pt
+                .find_partition(esp_bootloader_esp_idf::partitions::PartitionType::App(
+                    AppPartitionSubType::Ota1,
+                ))?
+                .context("Partition table invalid no ota1")?,
+        };
+
+        let ota_target = mk_static!(PartitionEntry, ota_target);
+        let storage_ota = mk_static!(FlashStorage, FlashStorage::new());
+        let ota_target = mk_static!(
+            FlashRegion<FlashStorage>,
+            ota_target.as_embedded_storage(storage_ota)
+        );
+
+        let data_partition = pt
+            .find_partition(esp_bootloader_esp_idf::partitions::PartitionType::Data(
+                DataPartitionSubType::LittleFs,
+            ))?
+            .expect("Data partition with littlefs not found");
+        let data_partition = mk_static!(PartitionEntry, data_partition);
+
+        let storage_data = mk_static!(FlashStorage, FlashStorage::new());
+        let data = mk_static!(
+            FlashRegion<FlashStorage>,
+            data_partition.as_embedded_storage(storage_data)
+        );
+        let lfs2filesystem = mk_static!(LittleFs2Filesystem, LittleFs2Filesystem { storage: data });
+        let alloc = mk_static!(Allocation<LittleFs2Filesystem>, lfs2Filesystem::allocate());
+        if lfs2filesystem.is_mountable() {
+            log::info!("Littlefs2 filesystem is mountable");
+        } else {
+            match lfs2filesystem.format() {
+                Result::Ok(..) => {
+                    log::info!("Littlefs2 filesystem is formatted");
+                }
+                Err(err) => {
+                    error!("Littlefs2 filesystem could not be formatted: {:?}", err);
+                }
+            }
+        }
+
+        let fs = Arc::new(Mutex::new(
+            lfs2Filesystem::mount(alloc, lfs2filesystem).expect("Could not mount lfs2 filesystem"),
+        ));
+
+        let ap = interfaces.ap;
+        let sta = interfaces.sta;
+        let mut esp = Esp {
+            fs,
+            rng,
+            controller: Arc::new(Mutex::new(controller)),
+            interface_sta: Some(sta),
+            interface_ap: Some(ap),
+            boot_button,
+            wake_gpio1,
+            ota,
+            ota_target,
+            current: running,
+            slot0_state: state_0,
+            slot1_state: state_1,
+        };
+
+        //init,reset rtc memory depending on cause
+        let mut init_rtc_store: bool = false;
+        let mut to_config_mode: bool = false;
+        let reasons = match reset_reason() {
+            None => "unknown",
+            Some(reason) => match reason {
+                SocResetReason::ChipPowerOn => "power on",
+                SocResetReason::CoreSDIO => "sdio reset",
+                SocResetReason::CoreMwdt0 => "Watchdog Main",
+                SocResetReason::CoreMwdt1 => "Watchdog 1",
+                SocResetReason::CoreRtcWdt => "Watchdog RTC",
+                SocResetReason::Cpu0Mwdt0 => "Watchdog MCpu0",
+                SocResetReason::Cpu0Sw => "software reset cpu0",
+                SocResetReason::SysRtcWdt => "Watchdog Sys rtc",
+                SocResetReason::Cpu0Mwdt1 => "cpu0 mwdt1",
+                SocResetReason::SysSuperWdt => "Watchdog Super",
+                SocResetReason::Cpu0RtcWdt => {
+                    init_rtc_store = true;
+                    "Watchdog RTC cpu0"
+                }
+                SocResetReason::CoreSw => "software reset",
+                SocResetReason::CoreDeepSleep => "deep sleep",
+                SocResetReason::SysBrownOut => "sys brown out",
+                SocResetReason::CoreEfuseCrc => "core efuse crc",
+                SocResetReason::CoreUsbUart => {
+                    //TODO still required? or via button ignore? to_config_mode = true;
+                    to_config_mode = true;
+                    "core usb uart"
+                }
+                SocResetReason::CoreUsbJtag => "core usb jtag",
+                SocResetReason::Cpu0JtagCpu => "cpu0 jtag cpu",
+            },
+        };
+        LOG_ACCESS
+            .lock()
+            .await
+            .log(
+                LogMessage::ResetReason,
+                init_rtc_store as u32,
+                to_config_mode as u32,
+                "",
+                &format!("{reasons:?}"),
+            )
+            .await;
+
+        esp.init_rtc_deepsleep_memory(init_rtc_store, to_config_mode)
+            .await;
+
+        let config = esp.load_config().await;
+
+        log::info!("Init rtc driver");
+
+        let sda = peripherals.GPIO20;
+        let scl = peripherals.GPIO19;
+
+        let i2c = I2c::new(
+            peripherals.I2C0,
+            Config::default()
+                .with_frequency(Rate::from_hz(100))
+                .with_timeout(BusTimeout::Maximum),
+        )?
+        .with_scl(scl)
+        .with_sda(sda);
+        let i2c_bus: embassy_sync::blocking_mutex::Mutex<
+            CriticalSectionRawMutex,
+            RefCell<I2c<Blocking>>,
+        > = CriticalSectionMutex::new(RefCell::new(i2c));
+
+        I2C_DRIVER.init(i2c_bus).expect("Could not init i2c driver");
+
+        let i2c_bus = I2C_DRIVER.get().await;
+        let rtc_device = I2cDevice::new(&i2c_bus);
+        let eeprom_device = I2cDevice::new(&i2c_bus);
+
+        let mut rtc: Ds323x<
+            I2cInterface<I2cDevice<CriticalSectionRawMutex, I2c<Blocking>>>,
+            DS3231,
+        > = Ds323x::new_ds3231(rtc_device);
+
+        info!("Init rtc eeprom driver");
+        let eeprom = Eeprom24x::new_24x32(eeprom_device, SlaveAddr::Alternative(true, true, true));
+        let rtc_time = rtc.datetime();
+        match rtc_time {
+            Ok(tt) => {
+                log::info!("Rtc Module reports time at UTC {}", tt);
+            }
+            Err(err) => {
+                log::info!("Rtc Module could not be read {:?}", err);
+            }
+        }
+
+        let storage: Storage<
+            I2cDevice<'static, CriticalSectionRawMutex, I2c<Blocking>>,
+            B32,
+            TwoBytes,
+            No,
+            Delay,
+        > = Storage::new(eeprom, Delay::new());
+        let rtc_module: Box<dyn RTCModuleInteraction + Send> =
+            Box::new(DS3231Module { rtc, storage }) as Box<dyn RTCModuleInteraction + Send>;
+
+        let hal = match config {
+            Result::Ok(config) => {
+                let battery_interaction: Box<dyn BatteryInteraction + Send> =
+                    match config.hardware.battery {
+                        BatteryBoardVersion::Disabled => Box::new(NoBatteryMonitor {}),
+                        BatteryBoardVersion::BQ34Z100G1 => {
+                            let battery_device = I2cDevice::new(I2C_DRIVER.get().await);
+                            let mut battery_driver = Bq34z100g1Driver {
+                                i2c: battery_device,
+                                delay: Delay::new(),
+                                flash_block_data: [0; 32],
+                            };
+                            let status = print_battery_bq34z100(&mut battery_driver);
+                            match status {
+                                Ok(_) => {}
+                                Err(err) => {
+                                    LOG_ACCESS
+                                        .lock()
+                                        .await
+                                        .log(
+                                            LogMessage::BatteryCommunicationError,
+                                            0u32,
+                                            0,
+                                            "",
+                                            &format!("{err:?})"),
+                                        )
+                                        .await;
+                                }
+                            }
+                            Box::new(BQ34Z100G1 { battery_driver })
+                        }
+                        BatteryBoardVersion::WchI2cSlave => {
+                            // TODO use correct implementation once availible
+                            Box::new(NoBatteryMonitor {})
+                        }
+                    };
+
+                let board_hal: Box<dyn BoardInteraction + Send> = match config.hardware.board {
+                    BoardVersion::INITIAL => {
+                        initial_hal::create_initial_board(free_pins, config, esp)?
+                    }
+                    BoardVersion::V3 => {
+                        v3_hal::create_v3(free_pins, esp, config, battery_interaction, rtc_module)?
+                    }
+                    BoardVersion::V4 => {
+                        v4_hal::create_v4(free_pins, esp, config, battery_interaction, rtc_module)
+                            .await?
+                    }
+                };
+
+                HAL { board_hal }
+            }
+            Err(err) => {
+                LOG_ACCESS
+                    .lock()
+                    .await
+                    .log(
+                        LogMessage::ConfigModeMissingConfig,
+                        0,
+                        0,
+                        "",
+                        &err.to_string(),
+                    )
+                    .await;
+                HAL {
+                    board_hal: initial_hal::create_initial_board(
+                        free_pins,
+                        PlantControllerConfig::default(),
+                        esp,
+                    )?,
+                }
+            }
+        };
+
+        Ok(Mutex::new(hal))
+    }
+}
+
+fn ota_state(slot: ota_slot, ota_data: &mut FlashRegion<FlashStorage>) -> OtaImageState {
+    // Read and log OTA states for both slots before constructing Ota
+    // Each OTA select entry is 32 bytes: [seq:4][label:20][state:4][crc:4]
+    // Offsets within the OTA data partition: slot0 @ 0x0000, slot1 @ 0x1000
+    if slot == ota_slot::None {
+        return OtaImageState::Undefined;
+    }
+    let mut slot_buf = [0u8; 32];
+    if slot == ota_slot::Slot0 {
+        let _ = ota_data.read(0x0000, &mut slot_buf);
+    } else {
+        let _ = ota_data.read(0x1000, &mut slot_buf);
+    }
+    let raw_state = u32::from_le_bytes(slot_buf[24..28].try_into().unwrap_or([0xff; 4]));
+    let state0 = OtaImageState::try_from(raw_state).unwrap_or(OtaImageState::Undefined);
+    state0
+}
+
+fn get_current_slot_and_fix_ota_data(
+    ota: &mut Ota<FlashStorage>,
+    state0: OtaImageState,
+    state1: OtaImageState,
+) -> Result<ota_slot, FatError> {
+    let state = ota.current_ota_state().unwrap_or_default();
+    let swap = match state {
+        OtaImageState::Invalid => true,
+        OtaImageState::Aborted => true,
+        OtaImageState::Undefined => {
+            info!("Undefined image in current slot, bootloader wrong?");
+            false
+        }
+        _ => false,
+    };
+    let current = ota.current_slot()?;
+    if swap {
+        let other = match current {
+            ota_slot::Slot0 => state1,
+            ota_slot::Slot1 => state0,
+            _ => OtaImageState::Invalid,
+        };
+
+        match other {
+            OtaImageState::Invalid => {
+                bail!(
+                    "cannot recover slot, as both slots in invalid state {:?} {:?} {:?}",
+                    current,
+                    state0,
+                    state1
+                );
+            }
+            OtaImageState::Aborted => {
+                bail!(
+                    "cannot recover slot, as both slots in invalid state {:?} {:?} {:?}",
+                    current,
+                    state0,
+                    state1
+                );
+            }
+            _ => {}
+        }
+        info!(
+            "Current slot has state {:?} other state has {:?} swapping",
+            state, other
+        );
+        ota.set_current_slot(current.next())?;
+        //we actually booted other slot, than partition table assumes
+        return Ok(ota.current_slot()?);
+    };
+    Ok(current)
+}
+
+pub async fn esp_time() -> DateTime<Utc> {
+    let guard = TIME_ACCESS.get().await.lock().await;
+    DateTime::from_timestamp_micros(guard.current_time_us() as i64).unwrap()
+}
+
+pub async fn esp_set_time(time: DateTime<FixedOffset>) -> FatResult<()> {
+    {
+        let guard = TIME_ACCESS.get().await.lock().await;
+        guard.set_current_time_us(time.timestamp_micros() as u64);
+    }
+    BOARD_ACCESS
+        .get()
+        .await
+        .lock()
+        .await
+        .board_hal
+        .get_rtc_module()
+        .set_rtc_time(&time.to_utc())
+        .await
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Default, Serialize)]
+pub struct Moistures{
+    pub sensor_a_hz: [f32; PLANT_COUNT],
+    pub sensor_b_hz: [f32; PLANT_COUNT],
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize)]
+pub struct DetectionResult {
+    plant: [DetectionSensorResult; crate::hal::PLANT_COUNT]
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize)]
+pub struct DetectionSensorResult{
+    sensor_a: bool,
+    sensor_b: bool,
+}

Software/MainBoard/rust/src/hal/rtc.rs

@@ -0,0 +1,133 @@
+use crate::hal::Box;
+use crate::fat_error::FatResult;
+use async_trait::async_trait;
+use bincode::config::Configuration;
+use bincode::{config, Decode, Encode};
+use chrono::{DateTime, Utc};
+use ds323x::ic::DS3231;
+use ds323x::interface::I2cInterface;
+use ds323x::{DateTimeAccess, Ds323x};
+use eeprom24x::addr_size::TwoBytes;
+use eeprom24x::page_size::B32;
+use eeprom24x::unique_serial::No;
+use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embedded_storage::{ReadStorage, Storage};
+use esp_hal::delay::Delay;
+use esp_hal::i2c::master::I2c;
+use esp_hal::Blocking;
+use serde::{Deserialize, Serialize};
+
+pub const X25: crc::Crc<u16> = crc::Crc::<u16>::new(&crc::CRC_16_IBM_SDLC);
+const CONFIG: Configuration = config::standard();
+//
+#[async_trait(?Send)]
+pub trait RTCModuleInteraction {
+    async fn get_backup_info(&mut self) -> FatResult<BackupHeader>;
+    async fn get_backup_config(&mut self, chunk: usize) -> FatResult<([u8; 32], usize, u16)>;
+    async fn backup_config(&mut self, offset: usize, bytes: &[u8]) -> FatResult<()>;
+    async fn backup_config_finalize(&mut self, crc: u16, length: usize) -> FatResult<()>;
+    async fn get_rtc_time(&mut self) -> FatResult<DateTime<Utc>>;
+    async fn set_rtc_time(&mut self, time: &DateTime<Utc>) -> FatResult<()>;
+}
+//
+const BACKUP_HEADER_MAX_SIZE: usize = 64;
+
+#[derive(Serialize, Deserialize, PartialEq, Debug, Default, Encode, Decode)]
+pub struct BackupHeader {
+    pub timestamp: i64,
+    crc16: u16,
+    pub size: u16,
+}
+//
+pub struct DS3231Module {
+    pub(crate) rtc: Ds323x<
+        I2cInterface<I2cDevice<'static, CriticalSectionRawMutex, I2c<'static, Blocking>>>,
+        DS3231,
+    >,
+
+    pub(crate) storage: eeprom24x::Storage<
+        I2cDevice<'static, CriticalSectionRawMutex, I2c<'static, Blocking>>,
+        B32,
+        TwoBytes,
+        No,
+        Delay,
+    >,
+}
+
+#[async_trait(?Send)]
+impl RTCModuleInteraction for DS3231Module {
+    async fn get_backup_info(&mut self) -> FatResult<BackupHeader> {
+        let mut header_page_buffer = [0_u8; BACKUP_HEADER_MAX_SIZE];
+
+        self.storage.read(0, &mut header_page_buffer)?;
+
+        let (header, len): (BackupHeader, usize) =
+            bincode::decode_from_slice(&header_page_buffer[..], CONFIG)?;
+
+        log::info!("Raw header is {:?} with size {}", header_page_buffer, len);
+        Ok(header)
+    }
+
+    async fn get_backup_config(&mut self, chunk: usize) -> FatResult<([u8; 32], usize, u16)> {
+        let mut header_page_buffer = [0_u8; BACKUP_HEADER_MAX_SIZE];
+
+        self.storage.read(0, &mut header_page_buffer)?;
+        let (header, _header_size): (BackupHeader, usize) =
+            bincode::decode_from_slice(&header_page_buffer[..], CONFIG)?;
+
+        let mut buf = [0_u8; 32];
+        let offset = chunk * buf.len() + BACKUP_HEADER_MAX_SIZE;
+
+        let end: usize = header.size as usize + BACKUP_HEADER_MAX_SIZE;
+        let current_end = offset + buf.len();
+        let chunk_size = if current_end > end {
+            end - offset
+        } else {
+            buf.len()
+        };
+        if chunk_size == 0 {
+            Ok((buf, 0, header.crc16))
+        } else {
+            self.storage.read(offset as u32, &mut buf)?;
+            //&buf[..chunk_size];
+            Ok((buf, chunk_size, header.crc16))
+        }
+    }
+    async fn backup_config(&mut self, offset: usize, bytes: &[u8]) -> FatResult<()> {
+        //skip header and write after
+        self.storage
+            .write((BACKUP_HEADER_MAX_SIZE + offset) as u32, &bytes)?;
+
+        Ok(())
+    }
+
+    async fn backup_config_finalize(&mut self, crc: u16, length: usize) -> FatResult<()> {
+        let mut header_page_buffer = [0_u8; BACKUP_HEADER_MAX_SIZE];
+
+        let time = self.get_rtc_time().await?.timestamp_millis();
+        let header = BackupHeader {
+            crc16: crc,
+            timestamp: time,
+            size: length as u16,
+        };
+        let config = config::standard();
+        let encoded = bincode::encode_into_slice(&header, &mut header_page_buffer, config)?;
+        log::info!(
+            "Raw header is {:?} with size {}",
+            header_page_buffer,
+            encoded
+        );
+        self.storage.write(0, &header_page_buffer)?;
+        Ok(())
+    }
+
+    async fn get_rtc_time(&mut self) -> FatResult<DateTime<Utc>> {
+        Ok(self.rtc.datetime()?.and_utc())
+    }
+
+    async fn set_rtc_time(&mut self, time: &DateTime<Utc>) -> FatResult<()> {
+        let naive_time = time.naive_utc();
+        Ok(self.rtc.set_datetime(&naive_time)?)
+    }
+}

Software/MainBoard/rust/src/hal/v3_hal.rs

@@ -0,0 +1,450 @@
+use crate::bail;
+use crate::fat_error::FatError;
+use crate::hal::esp::{hold_disable, hold_enable};
+use crate::hal::rtc::RTCModuleInteraction;
+use crate::hal::v3_shift_register::ShiftRegister40;
+use crate::hal::water::TankSensor;
+use crate::hal::{BoardInteraction, FreePeripherals, Moistures, Sensor, PLANT_COUNT, TIME_ACCESS};
+use crate::log::{LogMessage, LOG_ACCESS};
+use crate::{
+    config::PlantControllerConfig,
+    hal::{battery::BatteryInteraction, esp::Esp},
+};
+use alloc::boxed::Box;
+use alloc::format;
+use alloc::string::ToString;
+use async_trait::async_trait;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::mutex::Mutex;
+use embassy_time::Timer;
+use embedded_hal::digital::OutputPin as _;
+use esp_hal::gpio::{Flex, Input, InputConfig, Level, Output, OutputConfig, Pull};
+use esp_hal::pcnt::channel::CtrlMode::Keep;
+use esp_hal::pcnt::channel::EdgeMode::{Hold, Increment};
+use esp_hal::pcnt::unit::Unit;
+use measurements::{Current, Voltage};
+
+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 MS_1: usize = 13;
+const SENSOR_ON: usize = 12;
+
+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;
+
+const CHARGING: usize = 14;
+const AWAKE: usize = 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 REPEAT_MOIST_MEASURE: usize = 1;
+
+pub struct V3<'a> {
+    config: PlantControllerConfig,
+    battery_monitor: Box<dyn BatteryInteraction + Send>,
+    rtc_module: Box<dyn RTCModuleInteraction + Send>,
+    esp: Esp<'a>,
+    shift_register:
+        Mutex<CriticalSectionRawMutex, ShiftRegister40<Output<'a>, Output<'a>, Output<'a>>>,
+    _shift_register_enable_invert: Output<'a>,
+    tank_sensor: TankSensor<'a>,
+    solar_is_day: Input<'a>,
+    light: Output<'a>,
+    main_pump: Output<'a>,
+    general_fault: Output<'a>,
+    pub signal_counter: Unit<'static, 0>,
+}
+
+pub(crate) fn create_v3(
+    peripherals: FreePeripherals<'static>,
+    esp: Esp<'static>,
+    config: PlantControllerConfig,
+    battery_monitor: Box<dyn BatteryInteraction + Send>,
+    rtc_module: Box<dyn RTCModuleInteraction + Send>,
+) -> Result<Box<dyn BoardInteraction<'static> + Send + 'static>, FatError> {
+    log::info!("Start v3");
+    let clock = Output::new(peripherals.gpio15, Level::Low, OutputConfig::default());
+    let latch = Output::new(peripherals.gpio3, Level::Low, OutputConfig::default());
+    let data = Output::new(peripherals.gpio23, Level::Low, OutputConfig::default());
+    let shift_register = ShiftRegister40::new(clock, latch, data);
+    //disable all
+    for mut pin in shift_register.decompose() {
+        let _ = pin.set_low();
+    }
+
+    // Set always-on status bits
+    let _ = shift_register.decompose()[AWAKE].set_high();
+    let _ = shift_register.decompose()[CHARGING].set_high();
+
+    // Multiplexer defaults: ms0..ms3 low, ms4 high (disabled)
+    let _ = shift_register.decompose()[MS_0].set_low();
+    let _ = shift_register.decompose()[MS_1].set_low();
+    let _ = shift_register.decompose()[MS_2].set_low();
+    let _ = shift_register.decompose()[MS_3].set_low();
+    let _ = shift_register.decompose()[MS_4].set_high();
+
+    let one_wire_pin = Flex::new(peripherals.gpio18);
+    let tank_power_pin = Output::new(peripherals.gpio11, Level::Low, OutputConfig::default());
+
+    let flow_sensor_pin = Input::new(
+        peripherals.gpio4,
+        InputConfig::default().with_pull(Pull::Up),
+    );
+
+    let tank_sensor = TankSensor::create(
+        one_wire_pin,
+        peripherals.adc1,
+        peripherals.gpio5,
+        tank_power_pin,
+        flow_sensor_pin,
+        peripherals.pcnt1,
+    )?;
+
+    let solar_is_day = Input::new(peripherals.gpio7, InputConfig::default());
+    let light = Output::new(peripherals.gpio10, Level::Low, OutputConfig::default());
+    let mut main_pump = Output::new(peripherals.gpio2, Level::Low, OutputConfig::default());
+    main_pump.set_low();
+    let mut general_fault = Output::new(peripherals.gpio6, Level::Low, OutputConfig::default());
+    general_fault.set_low();
+
+    let mut shift_register_enable_invert =
+        Output::new(peripherals.gpio21, Level::Low, OutputConfig::default());
+    shift_register_enable_invert.set_low();
+
+    let signal_counter = peripherals.pcnt0;
+
+    signal_counter.set_high_limit(Some(i16::MAX))?;
+
+    let ch0 = &signal_counter.channel0;
+    let edge_pin = Input::new(peripherals.gpio22, InputConfig::default());
+    ch0.set_edge_signal(edge_pin.peripheral_input());
+    ch0.set_input_mode(Hold, Increment);
+    ch0.set_ctrl_mode(Keep, Keep);
+    signal_counter.listen();
+
+    Ok(Box::new(V3 {
+        config,
+        battery_monitor,
+        rtc_module,
+        esp,
+        shift_register: Mutex::new(shift_register),
+        _shift_register_enable_invert: shift_register_enable_invert,
+        tank_sensor,
+        solar_is_day,
+        light,
+        main_pump,
+        general_fault,
+        signal_counter,
+    }))
+}
+
+impl V3<'_> {
+
+    async fn inner_measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> Result<f32, FatError> {
+        let mut results = [0_f32; REPEAT_MOIST_MEASURE];
+        for repeat in 0..REPEAT_MOIST_MEASURE {
+            self.signal_counter.pause();
+            self.signal_counter.clear();
+            //Disable all
+            {
+                let shift_register = self.shift_register.lock().await;
+                shift_register.decompose()[MS_4].set_high()?;
+            }
+
+            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 is_bit_set = |b: u8| -> bool { sensor_channel & (1 << b) != 0 };
+            {
+                let shift_register = self.shift_register.lock().await;
+                let pin_0 = &mut shift_register.decompose()[MS_0];
+                let pin_1 = &mut shift_register.decompose()[MS_1];
+                let pin_2 = &mut shift_register.decompose()[MS_2];
+                let pin_3 = &mut 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()?;
+                }
+
+                shift_register.decompose()[MS_4].set_low()?;
+                shift_register.decompose()[SENSOR_ON].set_high()?;
+            }
+            let measurement = 100; //how long to measure and then extrapolate to hz
+            let factor = 1000f32 / measurement as f32; //scale raw cound by this number to get hz
+
+            //give some time to stabilize
+            Timer::after_millis(10).await;
+            self.signal_counter.resume();
+            Timer::after_millis(measurement).await;
+            self.signal_counter.pause();
+            {
+                let shift_register = self.shift_register.lock().await;
+                shift_register.decompose()[MS_4].set_high()?;
+                shift_register.decompose()[SENSOR_ON].set_low()?;
+            }
+            Timer::after_millis(10).await;
+            let unscaled = self.signal_counter.value();
+            let hz = unscaled as f32 * factor;
+            LOG_ACCESS
+                .lock()
+                .await
+                .log(
+                    LogMessage::RawMeasure,
+                    unscaled as u32,
+                    hz as u32,
+                    &plant.to_string(),
+                    &format!("{sensor:?}"),
+                )
+                .await;
+            results[repeat] = hz;
+        }
+        results.sort_by(|a, b| a.partial_cmp(b).unwrap()); // floats don't seem to implement total_ord
+
+        let mid = results.len() / 2;
+        let median = results[mid];
+        Ok(median)
+    }
+}
+
+#[async_trait(?Send)]
+impl<'a> BoardInteraction<'a> for V3<'a> {
+    fn get_tank_sensor(&mut self) -> Result<&mut TankSensor<'a>, FatError> {
+        Ok(&mut self.tank_sensor)
+    }
+
+    fn get_esp(&mut self) -> &mut Esp<'a> {
+        &mut self.esp
+    }
+
+    fn get_config(&mut self) -> &PlantControllerConfig {
+        &self.config
+    }
+
+    fn get_battery_monitor(&mut self) -> &mut Box<dyn BatteryInteraction + Send> {
+        &mut self.battery_monitor
+    }
+
+    fn get_rtc_module(&mut self) -> &mut Box<dyn RTCModuleInteraction + Send> {
+        &mut self.rtc_module
+    }
+    async fn set_charge_indicator(&mut self, charging: bool) -> Result<(), FatError> {
+        let shift_register = self.shift_register.lock().await;
+        if charging {
+            let _ = shift_register.decompose()[CHARGING].set_high();
+        } else {
+            let _ = shift_register.decompose()[CHARGING].set_low();
+        }
+        Ok(())
+    }
+
+    async fn deep_sleep(&mut self, duration_in_ms: u64) -> ! {
+        let _ = self.shift_register.lock().await.decompose()[AWAKE].set_low();
+        let guard = TIME_ACCESS.get().await.lock().await;
+        self.esp.deep_sleep(duration_in_ms, guard)
+    }
+
+    fn is_day(&self) -> bool {
+        self.solar_is_day.is_high()
+    }
+
+    async fn light(&mut self, enable: bool) -> Result<(), FatError> {
+        hold_disable(10);
+        if enable {
+            self.light.set_high();
+        } else {
+            self.light.set_low();
+        }
+        hold_enable(10);
+        Ok(())
+    }
+    async fn pump(&mut self, plant: usize, enable: bool) -> Result<(), FatError> {
+        if enable {
+            self.main_pump.set_high();
+        }
+
+        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}"),
+        };
+        let shift_register = self.shift_register.lock().await;
+        if enable {
+            let _ = shift_register.decompose()[index].set_high();
+        } else {
+            let _ = shift_register.decompose()[index].set_low();
+        }
+
+        if !enable {
+            self.main_pump.set_low();
+        }
+        Ok(())
+    }
+
+    async fn pump_current(&mut self, _plant: usize) -> Result<Current, FatError> {
+        bail!("Not implemented in v3")
+    }
+
+    async fn fault(&mut self, plant: usize, enable: bool) -> Result<(), FatError> {
+        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),
+        };
+        let shift_register = self.shift_register.lock().await;
+        if enable {
+            let _ = shift_register.decompose()[index].set_high();
+        } else {
+            let _ = shift_register.decompose()[index].set_low();
+        }
+        Ok(())
+    }
+
+    async fn measure_moisture_hz(&mut self) -> Result<Moistures, FatError> {
+        let mut result = Moistures::default();
+        for plant in 0..PLANT_COUNT {
+            let a = self.inner_measure_moisture_hz(plant, Sensor::A).await;
+            let b = self.inner_measure_moisture_hz(plant, Sensor::B).await;
+            let aa = a.unwrap_or_else(|_| u32::MAX as f32);
+            let bb = b.unwrap_or_else(|_| u32::MAX as f32);
+            LOG_ACCESS
+                .lock()
+                .await
+                .log(LogMessage::TestSensor, aa as u32, bb as u32, &plant.to_string(), "")
+                .await;
+            result.sensor_a_hz[plant] = aa;
+            result.sensor_b_hz[plant] = bb;
+        }
+        Ok(result)
+    }
+
+
+    async fn general_fault(&mut self, enable: bool) {
+        hold_disable(6);
+        if enable {
+            self.general_fault.set_high();
+        } else {
+            self.general_fault.set_low();
+        }
+        hold_enable(6);
+    }
+
+    async fn test(&mut self) -> Result<(), FatError> {
+        self.general_fault(true).await;
+        Timer::after_millis(100).await;
+        self.general_fault(false).await;
+        Timer::after_millis(100).await;
+        self.light(true).await?;
+        Timer::after_millis(500).await;
+
+        self.light(false).await?;
+        Timer::after_millis(500).await;
+        for i in 0..PLANT_COUNT {
+            self.fault(i, true).await?;
+            Timer::after_millis(500).await;
+            self.fault(i, false).await?;
+            Timer::after_millis(500).await;
+        }
+        for i in 0..PLANT_COUNT {
+            self.pump(i, true).await?;
+            Timer::after_millis(100).await;
+            self.pump(i, false).await?;
+            Timer::after_millis(100).await;
+        }
+        self.measure_moisture_hz().await?;
+        Timer::after_millis(10).await;
+        Ok(())
+    }
+
+    fn set_config(&mut self, config: PlantControllerConfig) {
+        self.config = config;
+    }
+
+    async fn get_mptt_voltage(&mut self) -> Result<Voltage, FatError> {
+        bail!("Not implemented in v3")
+    }
+    async fn get_mptt_current(&mut self) -> Result<Current, FatError> {
+        bail!("Not implemented in v3")
+    }
+}

Software/MainBoard/rust/src/hal/v3_shift_register.rs

@@ -0,0 +1,154 @@
+//! Serial-in parallel-out shift register
+#![allow(warnings)]
+use core::cell::RefCell;
+use core::convert::Infallible;
+use core::iter::Iterator;
+use core::mem::{self, MaybeUninit};
+use core::result::{Result, Result::Ok};
+use embedded_hal::digital::OutputPin;
+
+trait ShiftRegisterInternal: Send {
+    fn update(&self, index: usize, command: bool) -> Result<(), ()>;
+}
+
+/// Output pin of the shift register
+pub struct ShiftRegisterPin<'a> {
+    shift_register: &'a dyn ShiftRegisterInternal,
+    index: usize,
+}
+
+impl<'a> ShiftRegisterPin<'a> {
+    fn new(shift_register: &'a dyn ShiftRegisterInternal, index: usize) -> Self {
+        ShiftRegisterPin {
+            shift_register,
+            index,
+        }
+    }
+}
+
+impl embedded_hal::digital::ErrorType for ShiftRegisterPin<'_> {
+    type Error = Infallible;
+}
+
+impl OutputPin for ShiftRegisterPin<'_> {
+    fn set_low(&mut self) -> Result<(), Infallible> {
+        self.shift_register.update(self.index, false).unwrap();
+        Ok(())
+    }
+
+    fn set_high(&mut self) -> Result<(), Infallible> {
+        self.shift_register.update(self.index, true).unwrap();
+        Ok(())
+    }
+}
+
+macro_rules! ShiftRegisterBuilder {
+    ($name: ident, $size: expr) => {
+        /// Serial-in parallel-out shift register
+        pub struct $name<Pin1, Pin2, Pin3>
+        where
+            Pin1: OutputPin + Send,
+            Pin2: OutputPin + Send,
+            Pin3: OutputPin + Send,
+        {
+            clock: RefCell<Pin1>,
+            latch: RefCell<Pin2>,
+            data: RefCell<Pin3>,
+            output_state: RefCell<[bool; $size]>,
+        }
+
+        impl<Pin1, Pin2, Pin3> ShiftRegisterInternal for $name<Pin1, Pin2, Pin3>
+        where
+            Pin1: OutputPin + Send,
+            Pin2: OutputPin + Send,
+            Pin3: OutputPin + Send,
+        {
+            /// Sets the value of the shift register output at `index` to value `command`
+            fn update(&self, index: usize, command: bool) -> Result<(), ()> {
+                self.output_state.borrow_mut()[index] = command;
+                let output_state = self.output_state.borrow();
+                self.latch.borrow_mut().set_low().map_err(|_e| ())?;
+
+                for i in 1..=output_state.len() {
+                    if output_state[output_state.len() - i] {
+                        self.data.borrow_mut().set_high().map_err(|_e| ())?;
+                    } else {
+                        self.data.borrow_mut().set_low().map_err(|_e| ())?;
+                    }
+                    self.clock.borrow_mut().set_high().map_err(|_e| ())?;
+                    self.clock.borrow_mut().set_low().map_err(|_e| ())?;
+                }
+
+                self.latch.borrow_mut().set_high().map_err(|_e| ())?;
+                Ok(())
+            }
+        }
+
+        impl<Pin1, Pin2, Pin3> $name<Pin1, Pin2, Pin3>
+        where
+            Pin1: OutputPin + Send,
+            Pin2: OutputPin + Send,
+            Pin3: OutputPin + Send,
+        {
+            /// Creates a new SIPO shift register from clock, latch, and data output pins
+            pub fn new(clock: Pin1, latch: Pin2, data: Pin3) -> Self {
+                $name {
+                    clock: RefCell::new(clock),
+                    latch: RefCell::new(latch),
+                    data: RefCell::new(data),
+                    output_state: RefCell::new([false; $size]),
+                }
+            }
+
+            /// Get embedded-hal output pins to control the shift register outputs
+            pub fn decompose(&self) -> [ShiftRegisterPin<'_>; $size] {
+                // Create an uninitialized array of `MaybeUninit`. The `assume_init` is
+                // safe because the type we are claiming to have initialized here is a
+                // bunch of `MaybeUninit`s, which do not require initialization.
+                let mut pins: [MaybeUninit<ShiftRegisterPin>; $size] =
+                    unsafe { MaybeUninit::uninit().assume_init() };
+
+                // Dropping a `MaybeUninit` does nothing, so if there is a panic during this loop,
+                // we have a memory leak, but there is no memory safety issue.
+                for (index, elem) in pins.iter_mut().enumerate() {
+                    elem.write(ShiftRegisterPin::new(self, index));
+                }
+
+                // Everything is initialized. Transmute the array to the
+                // initialized type.
+                unsafe { mem::transmute::<_, [ShiftRegisterPin; $size]>(pins) }
+            }
+
+            /// Consume the shift register and return the original clock, latch, and data output pins
+            pub fn release(self) -> (Pin1, Pin2, Pin3) {
+                let Self {
+                    clock,
+                    latch,
+                    data,
+                    output_state: _,
+                } = self;
+                (clock.into_inner(), latch.into_inner(), data.into_inner())
+            }
+        }
+    };
+}
+
+ShiftRegisterBuilder!(ShiftRegister8, 8);
+ShiftRegisterBuilder!(ShiftRegister16, 16);
+ShiftRegisterBuilder!(ShiftRegister24, 24);
+ShiftRegisterBuilder!(ShiftRegister32, 32);
+ShiftRegisterBuilder!(ShiftRegister40, 40);
+ShiftRegisterBuilder!(ShiftRegister48, 48);
+ShiftRegisterBuilder!(ShiftRegister56, 56);
+ShiftRegisterBuilder!(ShiftRegister64, 64);
+ShiftRegisterBuilder!(ShiftRegister72, 72);
+ShiftRegisterBuilder!(ShiftRegister80, 80);
+ShiftRegisterBuilder!(ShiftRegister88, 88);
+ShiftRegisterBuilder!(ShiftRegister96, 96);
+ShiftRegisterBuilder!(ShiftRegister104, 104);
+ShiftRegisterBuilder!(ShiftRegister112, 112);
+ShiftRegisterBuilder!(ShiftRegister120, 120);
+ShiftRegisterBuilder!(ShiftRegister128, 128);
+
+/// 8 output serial-in parallel-out shift register
+pub type ShiftRegister<Pin1, Pin2, Pin3> = ShiftRegister8<Pin1, Pin2, Pin3>;

Software/MainBoard/rust/src/hal/v4_hal.rs

@@ -0,0 +1,458 @@
+use crate::bail;
+use crate::config::PlantControllerConfig;
+use crate::fat_error::{FatError, FatResult};
+use crate::hal::battery::BatteryInteraction;
+use crate::hal::esp::{hold_disable, hold_enable, Esp};
+use crate::hal::rtc::RTCModuleInteraction;
+use crate::hal::v4_sensor::{SensorImpl, SensorInteraction};
+use crate::hal::water::TankSensor;
+use crate::hal::{BoardInteraction, DetectionResult, FreePeripherals, Moistures, I2C_DRIVER, PLANT_COUNT, TIME_ACCESS};
+use crate::log::{LogMessage, LOG_ACCESS};
+use alloc::boxed::Box;
+use alloc::string::ToString;
+use async_trait::async_trait;
+use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_time::Timer;
+use esp_hal::gpio::{Flex, Input, InputConfig, Level, Output, OutputConfig, Pull};
+use esp_hal::i2c::master::I2c;
+use esp_hal::pcnt::channel::CtrlMode::Keep;
+use esp_hal::pcnt::channel::EdgeMode::{Hold, Increment};
+use esp_hal::twai::TwaiMode;
+use esp_hal::{twai, Blocking};
+use ina219::address::{Address, Pin};
+use ina219::calibration::UnCalibrated;
+use ina219::configuration::{Configuration, OperatingMode, Resolution};
+use ina219::SyncIna219;
+use measurements::Resistance;
+use measurements::{Current, Voltage};
+use pca9535::{GPIOBank, Pca9535Immediate, StandardExpanderInterface};
+
+const MPPT_CURRENT_SHUNT_OHMS: f64 = 0.05_f64;
+const TWAI_BAUDRATE: twai::BaudRate = twai::BaudRate::B125K;
+
+pub enum Charger<'a> {
+    SolarMpptV1 {
+        mppt_ina: SyncIna219<
+            I2cDevice<'a, CriticalSectionRawMutex, I2c<'static, Blocking>>,
+            UnCalibrated,
+        >,
+        solar_is_day: Input<'a>,
+        charge_indicator: Output<'a>,
+    },
+    ErrorInit {},
+}
+
+impl<'a> Charger<'a> {
+    pub(crate) fn get_mppt_current(&mut self) -> FatResult<Current> {
+        match self {
+            Charger::SolarMpptV1 { mppt_ina, .. } => {
+                let v = mppt_ina.shunt_voltage()?;
+                let shunt_voltage = Voltage::from_microvolts(v.shunt_voltage_uv().abs() as f64);
+                let shut_value = Resistance::from_ohms(MPPT_CURRENT_SHUNT_OHMS);
+                let current = shunt_voltage.as_volts() / shut_value.as_ohms();
+                Ok(Current::from_amperes(current))
+            }
+            Charger::ErrorInit { .. } => {
+                bail!("hardware error during init");
+            }
+        }
+    }
+
+    pub(crate) fn get_mptt_voltage(&mut self) -> FatResult<Voltage> {
+        match self {
+            Charger::SolarMpptV1 { mppt_ina, .. } => {
+                let v = mppt_ina.bus_voltage()?;
+                Ok(Voltage::from_millivolts(v.voltage_mv() as f64))
+            }
+            Charger::ErrorInit { .. } => {
+                bail!("hardware error during init");
+            }
+        }
+    }
+}
+
+impl Charger<'_> {
+    pub(crate) fn power_save(&mut self) {
+        match self {
+            Charger::SolarMpptV1 { mppt_ina, .. } => {
+                let _ = mppt_ina
+                    .set_configuration(Configuration {
+                        reset: Default::default(),
+                        bus_voltage_range: Default::default(),
+                        shunt_voltage_range: Default::default(),
+                        bus_resolution: Default::default(),
+                        shunt_resolution: Default::default(),
+                        operating_mode: OperatingMode::PowerDown,
+                    })
+                    .map_err(|e| {
+                        log::info!(
+                    "Error setting ina mppt configuration during deep sleep preparation{:?}",
+                    e
+                );
+                    });
+            }
+            _ => {}
+        }
+    }
+    fn set_charge_indicator(&mut self, charging: bool) -> FatResult<()> {
+        match self {
+            Self::SolarMpptV1 {
+                charge_indicator, ..
+            } => {
+                charge_indicator.set_level(charging.into());
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+
+    fn is_day(&self) -> bool {
+        match self {
+            Charger::SolarMpptV1 { solar_is_day, .. } => solar_is_day.is_high(),
+            _ => true,
+        }
+    }
+}
+
+pub struct V4<'a> {
+    esp: Esp<'a>,
+    tank_sensor: TankSensor<'a>,
+    charger: Charger<'a>,
+    rtc_module: Box<dyn RTCModuleInteraction + Send>,
+    battery_monitor: Box<dyn BatteryInteraction + Send>,
+    config: PlantControllerConfig,
+
+    awake: Output<'a>,
+    light: Output<'a>,
+    general_fault: Output<'a>,
+    pump_expander: Pca9535Immediate<I2cDevice<'a, CriticalSectionRawMutex, I2c<'static, Blocking>>>,
+    pump_ina: Option<
+        SyncIna219<I2cDevice<'a, CriticalSectionRawMutex, I2c<'static, Blocking>>, UnCalibrated>,
+    >,
+    sensor: SensorImpl,
+    extra1: Output<'a>,
+    extra2: Output<'a>,
+}
+
+pub(crate) async fn create_v4(
+    peripherals: FreePeripherals<'static>,
+    esp: Esp<'static>,
+    config: PlantControllerConfig,
+    battery_monitor: Box<dyn BatteryInteraction + Send>,
+    rtc_module: Box<dyn RTCModuleInteraction + Send>,
+) -> Result<Box<dyn BoardInteraction<'static> + Send + 'static>, FatError> {
+    log::info!("Start v4");
+    let mut awake = Output::new(peripherals.gpio21, Level::High, OutputConfig::default());
+    awake.set_high();
+
+    let mut general_fault = Output::new(peripherals.gpio23, Level::Low, OutputConfig::default());
+    general_fault.set_low();
+
+    let extra1 = Output::new(peripherals.gpio6, Level::Low, OutputConfig::default());
+    let extra2 = Output::new(peripherals.gpio15, Level::Low, OutputConfig::default());
+
+    let one_wire_pin = Flex::new(peripherals.gpio18);
+    let tank_power_pin = Output::new(peripherals.gpio11, Level::Low, OutputConfig::default());
+    let flow_sensor_pin = Input::new(
+        peripherals.gpio4,
+        InputConfig::default().with_pull(Pull::Up),
+    );
+
+    let tank_sensor = TankSensor::create(
+        one_wire_pin,
+        peripherals.adc1,
+        peripherals.gpio5,
+        tank_power_pin,
+        flow_sensor_pin,
+        peripherals.pcnt1,
+    )?;
+
+    let sensor_expander_device = I2cDevice::new(I2C_DRIVER.get().await);
+    let mut sensor_expander = Pca9535Immediate::new(sensor_expander_device, 34);
+    let sensor = match sensor_expander.pin_into_output(GPIOBank::Bank0, 0) {
+        Ok(_) => {
+            log::info!("SensorExpander answered");
+
+            let signal_counter = peripherals.pcnt0;
+
+            signal_counter.set_high_limit(Some(i16::MAX))?;
+
+            let ch0 = &signal_counter.channel0;
+            let edge_pin = Input::new(peripherals.gpio22, InputConfig::default());
+            ch0.set_edge_signal(edge_pin.peripheral_input());
+            ch0.set_input_mode(Hold, Increment);
+            ch0.set_ctrl_mode(Keep, Keep);
+            signal_counter.listen();
+
+            for pin in 0..8 {
+                let _ = sensor_expander.pin_into_output(GPIOBank::Bank0, pin);
+                let _ = sensor_expander.pin_into_output(GPIOBank::Bank1, pin);
+                let _ = sensor_expander.pin_set_low(GPIOBank::Bank0, pin);
+                let _ = sensor_expander.pin_set_low(GPIOBank::Bank1, pin);
+            }
+
+            SensorImpl::PulseCounter {
+                signal_counter,
+                sensor_expander,
+            }
+        }
+        Err(_) => {
+            log::info!("Can bus mode ");
+            let twai_config = Some(twai::TwaiConfiguration::new(
+                peripherals.twai,
+                peripherals.gpio2,
+                peripherals.gpio0,
+                TWAI_BAUDRATE,
+                TwaiMode::Normal,
+            ));
+            let can_power = Output::new(peripherals.gpio22, Level::Low, OutputConfig::default());
+
+            //can bus version
+            SensorImpl::CanBus {
+                twai_config,
+                can_power,
+            }
+        }
+    };
+
+    let solar_is_day = Input::new(peripherals.gpio7, InputConfig::default());
+    let light = Output::new(peripherals.gpio10, Level::Low, Default::default());
+    let charge_indicator = Output::new(peripherals.gpio3, Level::Low, Default::default());
+
+    let pump_device = I2cDevice::new(I2C_DRIVER.get().await);
+    let mut pump_expander = Pca9535Immediate::new(pump_device, 32);
+    for pin in 0..8 {
+        let _ = pump_expander.pin_into_output(GPIOBank::Bank0, pin);
+        let _ = pump_expander.pin_into_output(GPIOBank::Bank1, pin);
+        let _ = pump_expander.pin_set_low(GPIOBank::Bank0, pin);
+        let _ = pump_expander.pin_set_low(GPIOBank::Bank1, pin);
+    }
+
+    let mppt_current = I2cDevice::new(I2C_DRIVER.get().await);
+    let mppt_ina = match SyncIna219::new(mppt_current, Address::from_pins(Pin::Vcc, Pin::Gnd)) {
+        Ok(mut ina) => {
+            // Prefer higher averaging for more stable readings
+            let _ = ina.set_configuration(Configuration {
+                reset: Default::default(),
+                bus_voltage_range: Default::default(),
+                shunt_voltage_range: Default::default(),
+                bus_resolution: Default::default(),
+                shunt_resolution: Resolution::Avg128,
+                operating_mode: Default::default(),
+            });
+            Some(ina)
+        }
+        Err(err) => {
+            log::info!("Error creating mppt ina: {:?}", err);
+            None
+        }
+    };
+
+    let pump_current_dev = I2cDevice::new(I2C_DRIVER.get().await);
+    let pump_ina = match SyncIna219::new(pump_current_dev, Address::from_pins(Pin::Gnd, Pin::Sda)) {
+        Ok(ina) => Some(ina),
+        Err(err) => {
+            log::info!("Error creating pump ina: {:?}", err);
+            None
+        }
+    };
+
+    let charger = match mppt_ina {
+        Some(mut mppt_ina) => {
+            mppt_ina.set_configuration(Configuration {
+                reset: Default::default(),
+                bus_voltage_range: Default::default(),
+                shunt_voltage_range: Default::default(),
+                bus_resolution: Default::default(),
+                shunt_resolution: ina219::configuration::Resolution::Avg128,
+                operating_mode: Default::default(),
+            })?;
+
+            Charger::SolarMpptV1 {
+                mppt_ina,
+                solar_is_day,
+                charge_indicator,
+            }
+        }
+        None => Charger::ErrorInit {},
+    };
+
+    let v = V4 {
+        rtc_module,
+        esp,
+        awake,
+        tank_sensor,
+        light,
+        general_fault,
+        pump_expander,
+        config,
+        battery_monitor,
+        pump_ina,
+        charger,
+        extra1,
+        extra2,
+        sensor,
+    };
+    Ok(Box::new(v))
+}
+
+#[async_trait(?Send)]
+impl<'a> BoardInteraction<'a> for V4<'a> {
+    fn get_tank_sensor(&mut self) -> Result<&mut TankSensor<'a>, FatError> {
+        Ok(&mut self.tank_sensor)
+    }
+
+    fn get_esp(&mut self) -> &mut Esp<'a> {
+        &mut self.esp
+    }
+
+    fn get_config(&mut self) -> &PlantControllerConfig {
+        &self.config
+    }
+
+    fn get_battery_monitor(&mut self) -> &mut Box<dyn BatteryInteraction + Send> {
+        &mut self.battery_monitor
+    }
+
+    fn get_rtc_module(&mut self) -> &mut Box<dyn RTCModuleInteraction + Send> {
+        &mut self.rtc_module
+    }
+
+    async fn set_charge_indicator(&mut self, charging: bool) -> Result<(), FatError> {
+        self.charger.set_charge_indicator(charging)
+    }
+
+    async fn deep_sleep(&mut self, duration_in_ms: u64) -> ! {
+        self.awake.set_low();
+        self.charger.power_save();
+        let rtc = TIME_ACCESS.get().await.lock().await;
+        self.esp.deep_sleep(duration_in_ms, rtc);
+    }
+
+    fn is_day(&self) -> bool {
+        self.charger.is_day()
+    }
+
+    async fn light(&mut self, enable: bool) -> Result<(), FatError> {
+        hold_disable(10);
+        self.light.set_level(enable.into());
+        hold_enable(10);
+        Ok(())
+    }
+
+    async fn pump(&mut self, plant: usize, enable: bool) -> FatResult<()> {
+        if enable {
+            self.pump_expander
+                .pin_set_high(GPIOBank::Bank0, plant as u8)?;
+        } else {
+            self.pump_expander
+                .pin_set_low(GPIOBank::Bank0, plant as u8)?;
+        }
+        Ok(())
+    }
+
+    async fn pump_current(&mut self, _plant: usize) -> Result<Current, FatError> {
+        // sensor is shared for all pumps, ignore plant id
+        match self.pump_ina.as_mut() {
+            None => {
+                bail!("pump current sensor not available");
+            }
+            Some(pump_ina) => {
+                let v = pump_ina
+                    .shunt_voltage()
+                    .map_err(|e| FatError::String {
+                        error: alloc::format!("{:?}", e),
+                    })
+                    .map(|v| {
+                        let shunt_voltage =
+                            Voltage::from_microvolts(v.shunt_voltage_uv().abs() as f64);
+                        let shut_value = Resistance::from_ohms(0.05_f64);
+                        let current = shunt_voltage.as_volts() / shut_value.as_ohms();
+                        Current::from_amperes(current)
+                    })?;
+                Ok(v)
+            }
+        }
+    }
+
+    async fn fault(&mut self, plant: usize, enable: bool) -> FatResult<()> {
+        if enable {
+            self.pump_expander
+                .pin_set_high(GPIOBank::Bank1, plant as u8)?;
+        } else {
+            self.pump_expander
+                .pin_set_low(GPIOBank::Bank1, plant as u8)?;
+        }
+        Ok(())
+    }
+
+    async fn measure_moisture_hz(&mut self) -> Result<Moistures, FatError> {
+        self.sensor.measure_moisture_hz().await
+    }
+
+    async fn general_fault(&mut self, enable: bool) {
+        hold_disable(23);
+        self.general_fault.set_level(enable.into());
+        hold_enable(23);
+    }
+
+    async fn test(&mut self) -> Result<(), FatError> {
+        self.general_fault(true).await;
+        Timer::after_millis(100).await;
+        self.general_fault(false).await;
+        Timer::after_millis(500).await;
+        self.extra1.set_high();
+        Timer::after_millis(500).await;
+        self.extra1.set_low();
+        Timer::after_millis(500).await;
+        self.extra2.set_high();
+        Timer::after_millis(500).await;
+        self.extra2.set_low();
+        Timer::after_millis(500).await;
+        self.light(true).await?;
+        Timer::after_millis(500).await;
+        self.light(false).await?;
+        Timer::after_millis(500).await;
+        for i in 0..PLANT_COUNT {
+            self.fault(i, true).await?;
+            Timer::after_millis(500).await;
+            self.fault(i, false).await?;
+            Timer::after_millis(500).await;
+        }
+        for i in 0..PLANT_COUNT {
+            self.pump(i, true).await?;
+            Timer::after_millis(100).await;
+            self.pump(i, false).await?;
+            Timer::after_millis(100).await;
+        }
+        let moisture = self.measure_moisture_hz().await?;
+        for plant in 0..PLANT_COUNT {
+            let a = moisture.sensor_a_hz[plant] as u32;
+            let b = moisture.sensor_b_hz[plant] as u32;
+            LOG_ACCESS
+                .lock()
+                .await
+                .log(LogMessage::TestSensor, a, b, &plant.to_string(), "")
+                .await;
+        }
+        Timer::after_millis(10).await;
+        Ok(())
+    }
+
+    fn set_config(&mut self, config: PlantControllerConfig) {
+        self.config = config;
+    }
+
+    async fn get_mptt_voltage(&mut self) -> FatResult<Voltage> {
+        self.charger.get_mptt_voltage()
+    }
+
+    async fn get_mptt_current(&mut self) -> FatResult<Current> {
+        self.charger.get_mppt_current()
+    }
+
+    async fn detect_sensors(&mut self) -> FatResult<DetectionResult> {
+        self.sensor.autodetect().await
+    }
+}

Software/MainBoard/rust/src/hal/v4_sensor.rs

@@ -0,0 +1,314 @@
+use canapi::id::{classify, plant_id, MessageKind, IDENTIFY_CMD_OFFSET};
+use crate::bail;
+use crate::fat_error::{ContextExt, FatError, FatResult};
+use canapi::{SensorSlot};
+use crate::hal::{DetectionResult, Moistures, Sensor};
+use crate::hal::Box;
+use crate::log::{LogMessage, LOG_ACCESS};
+use alloc::format;
+use alloc::string::ToString;
+use async_trait::async_trait;
+use bincode::config;
+use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_time::{Instant, Timer, WithTimeout};
+use embedded_can::{Frame, Id};
+use esp_hal::gpio::Output;
+use esp_hal::i2c::master::I2c;
+use esp_hal::pcnt::unit::Unit;
+use esp_hal::twai::{EspTwaiFrame, StandardId, Twai, TwaiConfiguration};
+use esp_hal::{Blocking};
+use log::{error, info, warn};
+use pca9535::{GPIOBank, Pca9535Immediate, StandardExpanderInterface};
+
+const REPEAT_MOIST_MEASURE: usize = 10;
+
+
+
+#[async_trait(?Send)]
+pub trait SensorInteraction {
+    async fn measure_moisture_hz(&mut self) -> FatResult<Moistures>;
+}
+
+const MS0: u8 = 1_u8;
+const MS1: u8 = 0_u8;
+const MS2: u8 = 3_u8;
+const MS3: u8 = 4_u8;
+const MS4: u8 = 2_u8;
+const SENSOR_ON: u8 = 5_u8;
+
+pub enum SensorImpl {
+    PulseCounter {
+        signal_counter: Unit<'static, 0>,
+        sensor_expander:
+            Pca9535Immediate<I2cDevice<'static, CriticalSectionRawMutex, I2c<'static, Blocking>>>,
+    },
+    CanBus {
+        twai_config: Option<TwaiConfiguration<'static, Blocking>>,
+        can_power: Output<'static>,
+    },
+}
+
+#[async_trait(?Send)]
+impl SensorInteraction for SensorImpl {
+    async fn measure_moisture_hz(&mut self) -> FatResult<Moistures> {
+        match self {
+            SensorImpl::PulseCounter {
+                signal_counter,
+                sensor_expander,
+                ..
+            } => {
+                let mut result = Moistures::default();
+                for plant in 0..crate::hal::PLANT_COUNT{
+                    result.sensor_a_hz[plant] =  Self::inner_pulse(plant, Sensor::A, signal_counter, sensor_expander).await?;
+                    info!("Sensor {} {:?}: {}", plant, Sensor::A, result.sensor_a_hz[plant]);
+                    result.sensor_b_hz[plant] =  Self::inner_pulse(plant, Sensor::B, signal_counter, sensor_expander).await?;
+                    info!("Sensor {} {:?}: {}", plant, Sensor::B, result.sensor_b_hz[plant]);
+                }
+                Ok(result)
+            }
+
+            SensorImpl::CanBus {
+                twai_config,
+                can_power,
+            } => {
+                can_power.set_high();
+                let config = twai_config.take().expect("twai config not set");
+                let mut twai = config.start();
+
+                loop {
+                    let rec = twai.receive();
+                    match rec {
+                        Ok(_) => {}
+                        Err(err) => {
+                            info!("Error receiving CAN message: {:?}", err);
+                            break;
+                        }
+                    }
+                }
+
+                Timer::after_millis(10).await;
+                let can = Self::inner_can(&mut twai).await;
+
+                can_power.set_low();
+
+                let config = twai.stop();
+                twai_config.replace(config);
+
+                let value = can?;
+                Ok(value)
+            }
+        }
+    }
+}
+
+
+
+impl SensorImpl {
+    pub async fn autodetect(&mut self) -> FatResult<DetectionResult> {
+        match self {
+            SensorImpl::PulseCounter { .. } => {
+                bail!("Only CAN bus implementation supports autodetection")
+            }
+            SensorImpl::CanBus {
+                twai_config,
+                can_power,
+            } => {
+                // Power on CAN transceiver and start controller
+                can_power.set_high();
+                let config = twai_config.take().expect("twai config not set");
+                let mut as_async = config.into_async().start();
+                // Give CAN some time to stabilize
+                Timer::after_millis(10).await;
+
+                // Send a few test messages per potential sensor node
+                for plant in 0..crate::hal::PLANT_COUNT {
+                    for sensor in [Sensor::A, Sensor::B] {
+                        let target = StandardId::new(plant_id(IDENTIFY_CMD_OFFSET, sensor.into(),  plant as u16)).context(">> Could not create address for sensor! (plant: {}) <<")?;
+                        let can_buffer = [0_u8; 0];
+                        if let Some(frame) = EspTwaiFrame::new(target, &can_buffer) {
+                            // Try a few times; we intentionally ignore rx here and rely on stub logic
+                            let resu = as_async.transmit_async(&frame).await;
+                            match resu {
+                                Ok(_) => {
+                                    info!(
+                                        "Sent test message to plant {} sensor {:?}",
+                                        plant, sensor
+                                    );
+                                }
+                                Err(err) => {
+                                    info!("Error sending test message to plant {} sensor {:?}: {:?}", plant, sensor, err);
+                                }
+                            }
+                        } else {
+                            info!("Error building CAN frame");
+                        }
+
+                    }
+                }
+
+                let mut result = DetectionResult::default();
+                loop {
+                    match as_async.receive_async().with_deadline(Instant::from_millis(100)).await {
+                        Ok(or) => {
+                            match or {
+                                Ok(can_frame) => {
+                                    match can_frame.id() {
+                                        Id::Standard(id) => {
+                                            let rawid = id.as_raw();
+                                            match classify(rawid) {
+                                                None => {}
+                                                Some(msg) => {
+                                                    if msg.0 == MessageKind::MoistureData {
+                                                        let plant = msg.1 as usize;
+                                                        let sensor = msg.2;
+                                                        match sensor {
+                                                            SensorSlot::A => {
+                                                                result.plant[plant].sensor_a = true;
+                                                            }
+                                                            SensorSlot::B => {
+                                                                result.plant[plant].sensor_b = true;
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        Id::Extended(ext) => {
+                                            warn!("Received extended ID: {:?}", ext);
+                                        }
+                                    }
+
+                                }
+                                Err(err ) => {
+                                    error!("Error receiving CAN message: {:?}", err);
+                                    break;
+                                }
+                            }
+                            info!("Received CAN message: {:?}", or);
+
+                        }
+                        Err(err) => {
+                            error!("Timeout receiving CAN message: {:?}", err);
+                            break;
+                        }
+                    }
+                }
+
+                let config = as_async.stop().into_blocking();
+                can_power.set_low();
+                twai_config.replace(config);
+
+                info!("Autodetection result: {:?}", result);
+                Ok(result)
+            }
+        }
+    }
+
+    pub async fn inner_pulse(plant: usize, sensor: Sensor, signal_counter: &mut Unit<'_, 0>, sensor_expander: &mut Pca9535Immediate<I2cDevice<'static, CriticalSectionRawMutex, I2c<'static, Blocking>>>) -> FatResult<f32> {
+
+    let mut results = [0_f32; REPEAT_MOIST_MEASURE];
+    for repeat in 0..REPEAT_MOIST_MEASURE {
+    signal_counter.pause();
+    signal_counter.clear();
+
+    //Disable all
+    sensor_expander.pin_set_high(GPIOBank::Bank0, MS4)?;
+
+    let sensor_channel = match sensor {
+    Sensor::A => plant as u32,
+    Sensor::B => (15 - plant) as u32,
+    };
+
+    let is_bit_set = |b: u8| -> bool { sensor_channel & (1 << b) != 0 };
+    if is_bit_set(0) {
+    sensor_expander.pin_set_high(GPIOBank::Bank0, MS0)?;
+    } else {
+    sensor_expander.pin_set_low(GPIOBank::Bank0, MS0)?;
+    }
+    if is_bit_set(1) {
+    sensor_expander.pin_set_high(GPIOBank::Bank0, MS1)?;
+    } else {
+    sensor_expander.pin_set_low(GPIOBank::Bank0, MS1)?;
+    }
+    if is_bit_set(2) {
+    sensor_expander.pin_set_high(GPIOBank::Bank0, MS2)?;
+    } else {
+    sensor_expander.pin_set_low(GPIOBank::Bank0, MS2)?;
+    }
+    if is_bit_set(3) {
+    sensor_expander.pin_set_high(GPIOBank::Bank0, MS3)?;
+    } else {
+    sensor_expander.pin_set_low(GPIOBank::Bank0, MS3)?;
+    }
+
+    sensor_expander.pin_set_low(GPIOBank::Bank0, MS4)?;
+    sensor_expander.pin_set_high(GPIOBank::Bank0, SENSOR_ON)?;
+
+    let measurement = 100; // TODO what is this scaling factor? what is its purpose?
+    let factor = 1000f32 / measurement as f32;
+
+    //give some time to stabilize
+    Timer::after_millis(10).await;
+    signal_counter.resume();
+    Timer::after_millis(measurement).await;
+    signal_counter.pause();
+    sensor_expander.pin_set_high(GPIOBank::Bank0, MS4)?;
+    sensor_expander.pin_set_low(GPIOBank::Bank0, SENSOR_ON)?;
+    sensor_expander.pin_set_low(GPIOBank::Bank0, MS0)?;
+    sensor_expander.pin_set_low(GPIOBank::Bank0, MS1)?;
+    sensor_expander.pin_set_low(GPIOBank::Bank0, MS2)?;
+    sensor_expander.pin_set_low(GPIOBank::Bank0, MS3)?;
+    Timer::after_millis(10).await;
+    let unscaled = 1337; //signal_counter.get_counter_value()? as i32;
+    let hz = unscaled as f32 * factor;
+    LOG_ACCESS
+    .lock()
+    .await
+    .log(
+    LogMessage::RawMeasure,
+    unscaled as u32,
+    hz as u32,
+    &plant.to_string(),
+    &format!("{sensor:?}"),
+    )
+    .await;
+    results[repeat] = hz;
+    }
+    results.sort_by(|a, b| a.partial_cmp(b).unwrap()); // floats don't seem to implement total_ord
+
+    let mid = results.len() / 2;
+    let median = results[mid];
+    Ok(median)
+}
+
+    async fn inner_can(
+        twai: &mut Twai<'static, Blocking>,
+    ) -> FatResult<Moistures> {
+        [0_u8; 8];
+        config::standard();
+
+        let timeout = Instant::now()
+            .checked_add(embassy_time::Duration::from_millis(100))
+            .context("Timeout")?;
+        loop {
+            let answer = twai.receive();
+            match answer {
+                Ok(answer) => {
+                    info!("Received CAN message: {:?}", answer);
+                }
+                Err(error) => match error {
+                    nb::Error::Other(error) => {
+                        return Err(FatError::CanBusError { error });
+                    }
+                    nb::Error::WouldBlock => {
+                        if Instant::now() > timeout {
+                            bail!("Timeout waiting for CAN answer");
+                        }
+                        Timer::after_millis(10).await;
+                    }
+                },
+            }
+        }
+    }
+}

Software/MainBoard/rust/src/hal/water.rs

@@ -0,0 +1,153 @@
+use crate::bail;
+use crate::fat_error::FatError;
+use crate::hal::{ADC1, TANK_MULTI_SAMPLE};
+use embassy_time::Timer;
+use esp_hal::analog::adc::{Adc, AdcConfig, AdcPin, Attenuation};
+use esp_hal::delay::Delay;
+use esp_hal::gpio::{Flex, Input, Output, OutputConfig, Pull};
+use esp_hal::pcnt::channel::CtrlMode::Keep;
+use esp_hal::pcnt::channel::EdgeMode::{Hold, Increment};
+use esp_hal::pcnt::unit::Unit;
+use esp_hal::peripherals::GPIO5;
+use esp_hal::Blocking;
+use esp_println::println;
+use onewire::{ds18b20, Device, DeviceSearch, OneWire, DS18B20};
+
+pub struct TankSensor<'a> {
+    one_wire_bus: OneWire<Flex<'a>>,
+    tank_channel: Adc<'a, ADC1<'a>, Blocking>,
+    tank_power: Output<'a>,
+    tank_pin: AdcPin<GPIO5<'a>, ADC1<'a>>,
+    flow_counter: Unit<'a, 1>,
+}
+
+impl<'a> TankSensor<'a> {
+    pub(crate) fn create(
+        mut one_wire_pin: Flex<'a>,
+        adc1: ADC1<'a>,
+        gpio5: GPIO5<'a>,
+        tank_power: Output<'a>,
+        flow_sensor: Input,
+        pcnt1: Unit<'a, 1>,
+    ) -> Result<TankSensor<'a>, FatError> {
+        one_wire_pin.apply_output_config(&OutputConfig::default().with_pull(Pull::None));
+
+        let mut adc1_config = AdcConfig::new();
+        let tank_pin = adc1_config.enable_pin(gpio5, Attenuation::_11dB);
+        let tank_channel = Adc::new(adc1, adc1_config);
+
+        let one_wire_bus = OneWire::new(one_wire_pin, false);
+
+        pcnt1.set_high_limit(Some(i16::MAX))?;
+
+        let ch0 = &pcnt1.channel0;
+        ch0.set_edge_signal(flow_sensor.peripheral_input());
+        ch0.set_input_mode(Hold, Increment);
+        ch0.set_ctrl_mode(Keep, Keep);
+        pcnt1.listen();
+
+        Ok(TankSensor {
+            one_wire_bus,
+            tank_channel,
+            tank_power,
+            tank_pin,
+            flow_counter: pcnt1,
+        })
+    }
+
+    pub fn reset_flow_meter(&mut self) {
+        self.flow_counter.pause();
+        self.flow_counter.clear();
+    }
+
+    pub fn start_flow_meter(&mut self) {
+        self.flow_counter.resume();
+    }
+
+    pub fn get_flow_meter_value(&mut self) -> i16 {
+        self.flow_counter.value()
+    }
+
+    pub fn stop_flow_meter(&mut self) -> i16 {
+        self.flow_counter.pause();
+        self.get_flow_meter_value()
+    }
+
+    pub async fn water_temperature_c(&mut self) -> Result<f32, FatError> {
+        //multisample should be moved to water_temperature_c
+        let mut attempt = 1;
+        let mut delay = Delay::new();
+        self.one_wire_bus.reset(&mut delay)?;
+        let mut search = DeviceSearch::new();
+        let mut water_temp_sensor: Option<Device> = None;
+        while let Some(device) = self.one_wire_bus.search_next(&mut search, &mut delay)? {
+            if device.address[0] == ds18b20::FAMILY_CODE {
+                water_temp_sensor = Some(device);
+                break;
+            }
+        }
+        match water_temp_sensor {
+            Some(device) => {
+                println!("Found one wire device: {:?}", device);
+                let mut water_temp_sensor = DS18B20::new(device)?;
+
+                let water_temp: Result<f32, FatError> = loop {
+                    let temp = self
+                        .single_temperature_c(&mut water_temp_sensor, &mut delay)
+                        .await;
+                    match &temp {
+                        Ok(res) => {
+                            println!("Water temp is {}", res);
+                            break temp;
+                        }
+                        Err(err) => {
+                            println!("Could not get water temp {} attempt {}", err, attempt)
+                        }
+                    }
+                    if attempt == 5 {
+                        break temp;
+                    }
+                    attempt += 1;
+                };
+                water_temp
+            }
+            None => {
+                bail!("Not found any one wire Ds18b20");
+            }
+        }
+    }
+
+    async fn single_temperature_c(
+        &mut self,
+        sensor: &mut DS18B20,
+        delay: &mut Delay,
+    ) -> Result<f32, FatError> {
+        let resolution = sensor.measure_temperature(&mut self.one_wire_bus, delay)?;
+        Timer::after_millis(resolution.time_ms() as u64).await;
+        let temperature = sensor.read_temperature(&mut self.one_wire_bus, delay)? as f32;
+        if temperature == 85_f32 {
+            bail!("Ds18b20 dummy temperature returned");
+        }
+        Ok(temperature / 10_f32)
+    }
+
+    pub async fn tank_sensor_voltage(&mut self) -> Result<f32, FatError> {
+        self.tank_power.set_high();
+        //let stabilize
+        Timer::after_millis(100).await;
+
+        let mut store = [0_u16; TANK_MULTI_SAMPLE];
+        for multisample in 0..TANK_MULTI_SAMPLE {
+            let value = self.tank_channel.read_oneshot(&mut self.tank_pin);
+            //force yield
+            Timer::after_millis(10).await;
+            store[multisample] = value.unwrap();
+        }
+        self.tank_power.set_low();
+
+        store.sort();
+        //TODO probably wrong? check!
+        let median_mv = store[6] as f32 * 3300_f32 / 4096_f32;
+        Ok(median_mv)
+    }
+}

Software/MainBoard/rust/src/log/mod.rs

@@ -0,0 +1,284 @@
+use crate::hal::TIME_ACCESS;
+use crate::vec;
+use alloc::string::ToString;
+use alloc::vec::Vec;
+use bytemuck::{AnyBitPattern, Pod, Zeroable};
+use deranged::RangedU8;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::mutex::Mutex;
+use esp_hal::Persistable;
+use log::info;
+use serde::Serialize;
+use strum_macros::IntoStaticStr;
+use unit_enum::UnitEnum;
+
+const LOG_ARRAY_SIZE: u8 = 220;
+const MAX_LOG_ARRAY_INDEX: u8 = LOG_ARRAY_SIZE - 1;
+#[esp_hal::ram(rtc_fast, persistent)]
+static mut LOG_ARRAY: LogArray = LogArray {
+    buffer: [LogEntryInner {
+        timestamp: 0,
+        message_id: 0,
+        a: 0,
+        b: 0,
+        txt_short: [0; TXT_SHORT_LENGTH],
+        txt_long: [0; TXT_LONG_LENGTH],
+    }; LOG_ARRAY_SIZE as usize],
+    head: 0,
+};
+pub static LOG_ACCESS: Mutex<CriticalSectionRawMutex, &'static mut LogArray> =
+    unsafe { Mutex::new(&mut *&raw mut LOG_ARRAY) };
+
+const TXT_SHORT_LENGTH: usize = 8;
+const TXT_LONG_LENGTH: usize = 32;
+
+#[derive(Debug, Clone, Copy, AnyBitPattern)]
+#[repr(C)]
+pub struct LogArray {
+    buffer: [LogEntryInner; LOG_ARRAY_SIZE as usize],
+    head: u8,
+}
+
+unsafe impl Persistable for LogArray {}
+unsafe impl Zeroable for LogEntryInner {}
+
+unsafe impl Pod for LogEntryInner {}
+
+#[derive(Debug, Clone, Copy)]
+struct LogEntryInner {
+    pub timestamp: u64,
+    pub message_id: u16,
+    pub a: u32,
+    pub b: u32,
+    pub txt_short: [u8; TXT_SHORT_LENGTH],
+    pub txt_long: [u8; TXT_LONG_LENGTH],
+}
+
+#[derive(Serialize)]
+pub struct LogEntry {
+    pub timestamp: u64,
+    pub message_id: u16,
+    pub a: u32,
+    pub b: u32,
+    pub txt_short: alloc::string::String,
+    pub txt_long: alloc::string::String,
+}
+
+impl From<LogEntryInner> for LogEntry {
+    fn from(value: LogEntryInner) -> Self {
+        LogEntry {
+            timestamp: value.timestamp,
+            message_id: value.message_id,
+            a: value.a,
+            b: value.b,
+            txt_short: alloc::string::String::from_utf8_lossy_owned(value.txt_short.to_vec()),
+            txt_long: alloc::string::String::from_utf8_lossy_owned(value.txt_long.to_vec()),
+        }
+    }
+}
+
+pub async fn log(
+    message_key: LogMessage,
+    number_a: u32,
+    number_b: u32,
+    txt_short: &str,
+    txt_long: &str,
+) {
+    LOG_ACCESS
+        .lock()
+        .await
+        .log(message_key, number_a, number_b, txt_short, txt_long)
+        .await
+}
+
+impl LogArray {
+    pub fn get(&mut self) -> Vec<LogEntry> {
+        let head: RangedU8<0, MAX_LOG_ARRAY_INDEX> =
+            RangedU8::new(self.head).unwrap_or(RangedU8::new(0).unwrap());
+
+        let mut rv: Vec<LogEntry> = Vec::new();
+        let mut index = head.wrapping_sub(1);
+        for _ in 0..self.buffer.len() {
+            let entry = self.buffer[index.get() as usize];
+            if (entry.message_id as usize) != LogMessage::Empty.ordinal() {
+                rv.push(entry.into());
+            }
+            index = index.wrapping_sub(1);
+        }
+        rv
+    }
+
+    pub async fn log(
+        &mut self,
+        message_key: LogMessage,
+        number_a: u32,
+        number_b: u32,
+        txt_short: &str,
+        txt_long: &str,
+    ) {
+        let mut head: RangedU8<0, MAX_LOG_ARRAY_INDEX> =
+            RangedU8::new(self.head).unwrap_or(RangedU8::new(0).unwrap());
+
+        let mut txt_short_stack: heapless::String<TXT_SHORT_LENGTH> = heapless::String::new();
+        let mut txt_long_stack: heapless::String<TXT_LONG_LENGTH> = heapless::String::new();
+
+        limit_length(txt_short, &mut txt_short_stack);
+        limit_length(txt_long, &mut txt_long_stack);
+
+        let time = {
+            let guard = TIME_ACCESS.get().await.lock().await;
+            guard.current_time_us()
+        } / 1000;
+
+        let ordinal = message_key.ordinal() as u16;
+        let template: &str = message_key.into();
+        let mut template_string = template.to_string();
+        template_string = template_string.replace("${number_a}", number_a.to_string().as_str());
+        template_string = template_string.replace("${number_b}", number_b.to_string().as_str());
+        template_string = template_string.replace("${txt_long}", txt_long);
+        template_string = template_string.replace("${txt_short}", txt_short);
+
+        info!("{}", template_string);
+
+        let to_modify = &mut self.buffer[head.get() as usize];
+        to_modify.timestamp = time;
+        to_modify.message_id = ordinal;
+        to_modify.a = number_a;
+        to_modify.b = number_b;
+        to_modify
+            .txt_short
+            .clone_from_slice(&txt_short_stack.as_bytes());
+        to_modify
+            .txt_long
+            .clone_from_slice(&txt_long_stack.as_bytes());
+        head = head.wrapping_add(1);
+        self.head = head.get();
+    }
+}
+
+fn limit_length<const LIMIT: usize>(input: &str, target: &mut heapless::String<LIMIT>) {
+    for char in input.chars() {
+        match target.push(char) {
+            Ok(_) => {} //continue adding chars
+            Err(_) => {
+                //clear space for two asci chars
+                while target.len() + 2 >= LIMIT {
+                    target.pop().unwrap();
+                }
+                //add .. to shortened strings
+                target.push('.').unwrap();
+                target.push('.').unwrap();
+                return;
+            }
+        }
+    }
+    while target.len() < LIMIT {
+        target.push(' ').unwrap();
+    }
+}
+
+#[derive(IntoStaticStr, Serialize, PartialEq, Eq, PartialOrd, Ord, Clone, UnitEnum)]
+pub enum LogMessage {
+    #[strum(serialize = "")]
+    Empty,
+    #[strum(
+        serialize = "Reset due to ${txt_long} requires rtc clear ${number_a} and force config mode ${number_b}"
+    )]
+    ResetReason,
+    #[strum(serialize = "Current restart to conf mode ${number_a}")]
+    RestartToConfig,
+    #[strum(serialize = "Current low voltage detection is ${number_a}")]
+    LowVoltage,
+    #[strum(serialize = "Error communicating with battery!! ${txt_long}")]
+    BatteryCommunicationError,
+    #[strum(serialize = "Tank water level cricial! Refill tank!")]
+    TankWaterLevelLow,
+    #[strum(serialize = "Tank sensor hardware error: ${txt_long}")]
+    TankSensorBoardError,
+    #[strum(serialize = "Tank sensor not present, raw voltage measured = ${number_a} mV")]
+    TankSensorMissing,
+    #[strum(
+        serialize = "Tank sensor value out of range, min = ${number_a}%, max = ${number_b}%, value = ${text_short}%"
+    )]
+    TankSensorValueRangeError,
+    #[strum(
+        serialize = "raw measure unscaled ${number_a} hz ${number_b}, plant ${txt_short} sensor ${txt_long}"
+    )]
+    RawMeasure,
+    #[strum(serialize = "IP info: ${txt_long}")]
+    WifiInfo,
+    #[strum(serialize = "Plant:${txt_short} a:${number_a} b:${number_b}")]
+    TestSensor,
+    #[strum(serialize = "Stay alive topic is ${txt_long}")]
+    StayAlive,
+    #[strum(serialize = "Connecting mqtt ${txt_short} with id ${txt_long}")]
+    MqttInfo,
+    #[strum(serialize = "Received stay alive with value ${number_a}")]
+    MqttStayAliveRec,
+    #[strum(serialize = "Unknown topic recieved ${txt_long}")]
+    UnknownTopic,
+    #[strum(serialize = "Partition state is ${txt_long}")]
+    PartitionState,
+    #[strum(serialize = "Mounted Filesystem free ${number_a} total ${number_b} use ${txt_short}")]
+    FilesystemMount,
+    #[strum(
+        serialize = "Mounting Filesystem, this will format the first time and needs quite some time!"
+    )]
+    MountingFilesystem,
+    #[strum(serialize = "Year inplausible, force config mode")]
+    YearInplausibleForceConfig,
+    #[strum(serialize = "Going to config mode, due to request from prior run")]
+    ConfigModeSoftwareOverride,
+    #[strum(serialize = "Going to config mode, due to request via config mode button")]
+    ConfigModeButtonOverride,
+    #[strum(serialize = "Going to normal mode")]
+    NormalRun,
+    #[strum(serialize = "Missing normal config, entering config mode ${txt_long}")]
+    ConfigModeMissingConfig,
+    #[strum(serialize = "startup state wifi ${number_a} sntp ${number_b} mqtt ${txt_short}")]
+    StartupInfo,
+    #[strum(
+        serialize = "Trying to pump for ${number_b}s with pump ${number_a} now dryrun: ${txt_short}"
+    )]
+    PumpPlant,
+    #[strum(serialize = "Enable main power dryrun: ${number_a}")]
+    EnableMain,
+    #[strum(
+        serialize = "Pumped multiple times, but plant is still to try attempt: ${number_a} limit :: ${number_b} plant: ${txt_short}"
+    )]
+    ConsecutivePumpCountLimit,
+    #[strum(
+        serialize = "Pump Overcurrent error, pump: ${number_a} tripped overcurrent ${number_b} limit was ${txt_short} @s ${txt_long}"
+    )]
+    PumpOverCurrent,
+    #[strum(
+        serialize = "Pump Open loop error, pump: ${number_a} is low,  ${number_b} limit was ${txt_short} @s ${txt_long}"
+    )]
+    PumpOpenLoopCurrent,
+    #[strum(serialize = "Pump Open current sensor required but did not work: ${number_a}")]
+    PumpMissingSensorCurrent,
+}
+
+#[derive(Serialize)]
+pub struct MessageTranslation {
+    msg_type: LogMessage,
+    message: &'static str,
+}
+
+impl From<&LogMessage> for MessageTranslation {
+    fn from(value: &LogMessage) -> Self {
+        Self {
+            msg_type: value.clone(),
+            message: value.into(),
+        }
+    }
+}
+
+impl LogMessage {
+    pub fn to_log_localisation_config() -> Vec<MessageTranslation> {
+        Vec::from_iter((0..LogMessage::len()).map(|i| {
+            let msg_type = LogMessage::from_ordinal(i).unwrap();
+            (&msg_type).into()
+        }))
+    }
+}

Software/MainBoard/rust/src/plant_state.rs

@@ -0,0 +1,328 @@
+use crate::hal::Moistures;
+use crate::{
+    config::PlantConfig,
+    hal::HAL,
+    in_time_range,
+};
+use chrono::{DateTime, TimeDelta, Utc};
+use chrono_tz::Tz;
+use serde::{Deserialize, Serialize};
+
+const MOIST_SENSOR_MAX_FREQUENCY: f32 = 7500.; // 60kHz (500Hz margin)
+const MOIST_SENSOR_MIN_FREQUENCY: f32 = 150.; // this is really, really dry, think like cactus levels
+
+#[derive(Debug, PartialEq, Serialize)]
+pub enum MoistureSensorError {
+    ShortCircuit { hz: f32, max: f32 },
+    OpenLoop { hz: f32, min: f32 },
+}
+
+#[derive(Debug, PartialEq, Serialize)]
+pub enum MoistureSensorState {
+    Disabled,
+    MoistureValue { raw_hz: f32, moisture_percent: f32 },
+    SensorError(MoistureSensorError),
+}
+
+impl MoistureSensorState {
+    pub fn is_err(&self) -> Option<&MoistureSensorError> {
+        match self {
+            MoistureSensorState::SensorError(moisture_sensor_error) => Some(moisture_sensor_error),
+            _ => None,
+        }
+    }
+
+    pub fn moisture_percent(&self) -> Option<f32> {
+        if let MoistureSensorState::MoistureValue {
+            raw_hz: _,
+            moisture_percent,
+        } = self
+        {
+            Some(*moisture_percent)
+        } else {
+            None
+        }
+    }
+}
+
+impl MoistureSensorState {}
+
+#[derive(Debug, PartialEq, Serialize)]
+pub enum PumpError {
+    PumpNotWorking {
+        failed_attempts: usize,
+        max_allowed_failures: usize,
+    },
+}
+
+#[derive(Debug, Serialize)]
+pub struct PumpState {
+    consecutive_pump_count: u32,
+    previous_pump: Option<DateTime<Utc>>,
+}
+
+impl PumpState {
+    fn is_err(&self, plant_config: &PlantConfig) -> Option<PumpError> {
+        if self.consecutive_pump_count > plant_config.max_consecutive_pump_count as u32 {
+            Some(PumpError::PumpNotWorking {
+                failed_attempts: self.consecutive_pump_count as usize,
+                max_allowed_failures: plant_config.max_consecutive_pump_count as usize,
+            })
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Copy, Debug, PartialEq)]
+pub enum PlantWateringMode {
+    OFF,
+    TargetMoisture,
+    MinMoisture,
+    TimerOnly,
+}
+
+pub struct PlantState {
+    pub sensor_a: MoistureSensorState,
+    pub sensor_b: MoistureSensorState,
+    pub pump: PumpState,
+}
+
+fn map_range_moisture(
+    s: f32,
+    min_frequency: Option<f32>,
+    max_frequency: Option<f32>,
+) -> Result<f32, MoistureSensorError> {
+    // Use overrides if provided, otherwise fallback to defaults
+    let min_freq = min_frequency.unwrap_or(MOIST_SENSOR_MIN_FREQUENCY);
+    let max_freq = max_frequency.unwrap_or(MOIST_SENSOR_MAX_FREQUENCY);
+
+    if s < min_freq {
+        return Err(MoistureSensorError::OpenLoop {
+            hz: s,
+            min: min_freq,
+        });
+    }
+    if s > max_freq {
+        return Err(MoistureSensorError::ShortCircuit {
+            hz: s,
+            max: max_freq,
+        });
+    }
+    let moisture_percent = (s - min_freq) * 100.0 / (max_freq - min_freq);
+
+    Ok(moisture_percent)
+}
+
+impl PlantState {
+    pub async fn read_hardware_state(moistures: Moistures, plant_id: usize, board: &mut HAL<'_>) -> Self {
+        let sensor_a = if board.board_hal.get_config().plants[plant_id].sensor_a {
+            let raw = moistures.sensor_a_hz[plant_id];
+            match map_range_moisture(
+                raw,
+                    board.board_hal.get_config().plants[plant_id].moisture_sensor_min_frequency,
+                    board.board_hal.get_config().plants[plant_id].moisture_sensor_max_frequency,
+                ) {
+                    Ok(moisture_percent) => MoistureSensorState::MoistureValue {
+                        raw_hz: raw,
+                        moisture_percent,
+                    },
+                    Err(err) => MoistureSensorState::SensorError(err),
+                }
+        } else {
+            MoistureSensorState::Disabled
+        };
+
+        let sensor_b = if board.board_hal.get_config().plants[plant_id].sensor_b {
+            let raw = moistures.sensor_b_hz[plant_id];
+            match map_range_moisture(
+                raw,
+                board.board_hal.get_config().plants[plant_id].moisture_sensor_min_frequency,
+                board.board_hal.get_config().plants[plant_id].moisture_sensor_max_frequency,
+            ) {
+                Ok(moisture_percent) => MoistureSensorState::MoistureValue {
+                    raw_hz: raw,
+                    moisture_percent,
+                },
+                Err(err) => MoistureSensorState::SensorError(err),
+            }
+        } else {
+            MoistureSensorState::Disabled
+        };
+
+        let previous_pump = board.board_hal.get_esp().last_pump_time(plant_id);
+        let consecutive_pump_count = board.board_hal.get_esp().consecutive_pump_count(plant_id);
+        let state = Self {
+            sensor_a,
+            sensor_b,
+            pump: PumpState {
+                consecutive_pump_count,
+                previous_pump,
+            },
+        };
+        if state.is_err() {
+            let _ = board.board_hal.fault(plant_id, true);
+        }
+        state
+    }
+
+    pub fn pump_in_timeout(&self, plant_conf: &PlantConfig, current_time: &DateTime<Tz>) -> bool {
+        if matches!(plant_conf.mode, PlantWateringMode::OFF) {
+            return false;
+        }
+        self.pump.previous_pump.is_some_and(|last_pump| {
+            last_pump
+                .checked_add_signed(TimeDelta::minutes(plant_conf.pump_cooldown_min.into()))
+                .is_some_and(|earliest_next_allowed_pump| {
+                    earliest_next_allowed_pump > *current_time
+                })
+        })
+    }
+
+    pub fn is_err(&self) -> bool {
+        self.sensor_a.is_err().is_some() || self.sensor_b.is_err().is_some()
+    }
+
+    pub fn plant_moisture(
+        &self,
+    ) -> (
+        Option<f32>,
+        (Option<&MoistureSensorError>, Option<&MoistureSensorError>),
+    ) {
+        match (
+            self.sensor_a.moisture_percent(),
+            self.sensor_b.moisture_percent(),
+        ) {
+            (Some(moisture_a), Some(moisture_b)) => {
+                (Some((moisture_a + moisture_b) / 2.), (None, None))
+            }
+            (Some(moisture_percent), _) => (Some(moisture_percent), (None, self.sensor_b.is_err())),
+            (_, Some(moisture_percent)) => (Some(moisture_percent), (self.sensor_a.is_err(), None)),
+            _ => (None, (self.sensor_a.is_err(), self.sensor_b.is_err())),
+        }
+    }
+
+    pub fn needs_to_be_watered(
+        &self,
+        plant_conf: &PlantConfig,
+        current_time: &DateTime<Tz>,
+    ) -> bool {
+        match plant_conf.mode {
+            PlantWateringMode::OFF => false,
+            PlantWateringMode::TargetMoisture => {
+                let (moisture_percent, _) = self.plant_moisture();
+                if let Some(moisture_percent) = moisture_percent {
+                    if self.pump_in_timeout(plant_conf, current_time) {
+                        false
+                    } else if moisture_percent < plant_conf.target_moisture {
+                        in_time_range(
+                            current_time,
+                            plant_conf.pump_hour_start,
+                            plant_conf.pump_hour_end,
+                        )
+                    } else {
+                        false
+                    }
+                } else {
+                    // in case no moisture can be determined, do not water the plant
+                    false
+                }
+            }
+            PlantWateringMode::MinMoisture => {
+                let (moisture_percent, _) = self.plant_moisture();
+                if let Some(_moisture_percent) = moisture_percent {
+                    if self.pump_in_timeout(plant_conf, current_time) {
+                        false
+                    } else if !in_time_range(
+                        current_time,
+                        plant_conf.pump_hour_start,
+                        plant_conf.pump_hour_end,
+                    ) {
+                        false
+                    } else if true {
+                        //if not cooldown min and below max
+                        true
+                    } else if true {
+                        //if below min disable cooldown min
+                        true
+                    } else {
+                        false
+                    }
+                } else {
+                    false
+                }
+            }
+            PlantWateringMode::TimerOnly => !self.pump_in_timeout(plant_conf, current_time),
+        }
+    }
+
+    pub fn to_mqtt_info(
+        &self,
+        plant_conf: &PlantConfig,
+        current_time: &DateTime<Tz>,
+    ) -> PlantInfo<'_> {
+        PlantInfo {
+            sensor_a: &self.sensor_a,
+            sensor_b: &self.sensor_b,
+            mode: plant_conf.mode,
+            do_water: self.needs_to_be_watered(plant_conf, current_time),
+            dry: if let Some(moisture_percent) = self.plant_moisture().0 {
+                moisture_percent < plant_conf.target_moisture
+            } else {
+                false
+            },
+            cooldown: self.pump_in_timeout(plant_conf, current_time),
+            out_of_work_hour: in_time_range(
+                current_time,
+                plant_conf.pump_hour_start,
+                plant_conf.pump_hour_end,
+            ),
+            consecutive_pump_count: self.pump.consecutive_pump_count,
+            pump_error: self.pump.is_err(plant_conf),
+            last_pump: self
+                .pump
+                .previous_pump
+                .map(|t| t.with_timezone(&current_time.timezone())),
+            next_pump: if matches!(
+                plant_conf.mode,
+                PlantWateringMode::TimerOnly
+                    | PlantWateringMode::TargetMoisture
+                    | PlantWateringMode::MinMoisture
+            ) {
+                self.pump.previous_pump.and_then(|last_pump| {
+                    last_pump
+                        .checked_add_signed(TimeDelta::minutes(plant_conf.pump_cooldown_min.into()))
+                        .map(|t| t.with_timezone(&current_time.timezone()))
+                })
+            } else {
+                None
+            },
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Serialize)]
+/// State of a single plant to be tracked
+pub struct PlantInfo<'a> {
+    /// state of humidity sensor on bank a
+    sensor_a: &'a MoistureSensorState,
+    /// state of humidity sensor on bank b
+    sensor_b: &'a MoistureSensorState,
+    /// configured plant watering mode
+    mode: PlantWateringMode,
+    /// the plant needs to be watered
+    do_water: bool,
+    /// plant is considered to be dry according to settings
+    dry: bool,
+    /// plant irrigation cooldown is active
+    cooldown: bool,
+    /// plant should not be watered at this time of day TODO: does this really belong here? Isn't this a global setting?
+    out_of_work_hour: bool,
+    /// how often has the pump been watered without reaching target moisture
+    consecutive_pump_count: u32,
+    pump_error: Option<PumpError>,
+    /// last time when the pump was active
+    last_pump: Option<DateTime<Tz>>,
+    /// next time when pump should activate
+    next_pump: Option<DateTime<Tz>>,
+}

Software/MainBoard/rust/src/tank.rs

@@ -0,0 +1,194 @@
+use crate::alloc::string::{String, ToString};
+use crate::config::TankConfig;
+use crate::hal::HAL;
+use crate::fat_error::FatResult;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::mutex::MutexGuard;
+use serde::Serialize;
+
+const OPEN_TANK_VOLTAGE: f32 = 3.0;
+pub const WATER_FROZEN_THRESH: f32 = 4.0;
+
+#[derive(Debug, Clone, Serialize)]
+pub enum TankError {
+    SensorDisabled,
+    SensorMissing(f32),
+    SensorValueError { value: f32, min: f32, max: f32 },
+    BoardError(String),
+}
+
+pub enum TankState {
+    Present(f32),
+    Error(TankError),
+    Disabled,
+}
+
+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));
+    }
+
+    let r2 = raw_value_mv * 50.0 / (3.3 - raw_value_mv);
+    let mut percent = r2 / 190_f32 * 100_f32;
+    percent = percent.clamp(0.0, 100.0);
+    Ok(percent)
+}
+
+fn raw_voltage_to_tank_fill_percent(
+    raw_value_mv: f32,
+    config: &TankConfig,
+) -> Result<f32, TankError> {
+    let divider_percent = raw_voltage_to_divider_percent(raw_value_mv)?;
+    if divider_percent < config.tank_empty_percent.into()
+        || divider_percent > config.tank_full_percent.into()
+    {
+        return Err(TankError::SensorValueError {
+            value: divider_percent,
+            min: config.tank_empty_percent.into(),
+            max: config.tank_full_percent.into(),
+        });
+    }
+    Ok(
+        (divider_percent - f32::from(config.tank_empty_percent)) * 100.
+            / f32::from(config.tank_full_percent - config.tank_empty_percent),
+    )
+}
+
+impl TankState {
+    pub fn left_ml(&self, config: &TankConfig) -> Result<f32, TankError> {
+        match self {
+            TankState::Disabled => Err(TankError::SensorDisabled),
+            TankState::Error(err) => Err(err.clone()),
+            TankState::Present(raw_value_mv) => {
+                let tank_fill_percent = raw_voltage_to_tank_fill_percent(*raw_value_mv, config)?;
+                Ok(config.tank_useable_ml as f32 * tank_fill_percent / 100.)
+            }
+        }
+    }
+    pub fn enough_water(&self, config: &TankConfig) -> Result<bool, TankError> {
+        match self {
+            TankState::Disabled => Err(TankError::SensorDisabled),
+            TankState::Error(err) => Err(err.clone()),
+            TankState::Present(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() {
+                    Ok(true)
+                } else {
+                    Ok(false)
+                }
+            }
+        }
+    }
+
+    pub fn is_enabled(&self) -> bool {
+        !matches!(self, TankState::Disabled)
+    }
+
+    pub fn warn_level(&self, config: &TankConfig) -> Result<bool, TankError> {
+        match self {
+            TankState::Disabled => Err(TankError::SensorDisabled),
+            TankState::Error(err) => Err(err.clone()),
+            TankState::Present(raw_value_mv) => {
+                let tank_fill_percent = raw_voltage_to_tank_fill_percent(*raw_value_mv, config);
+                match tank_fill_percent {
+                    Ok(value) => {
+                        if value < config.tank_warn_percent.into() {
+                            Ok(true)
+                        } else {
+                            Ok(false)
+                        }
+                    }
+                    Err(err) => match err {
+                        TankError::SensorValueError { value, min, max: _ } => Ok(value < min),
+                        _ => Err(err),
+                    },
+                }
+            }
+        }
+    }
+
+    pub fn got_error(&self, config: &TankConfig) -> Option<TankError> {
+        match self {
+            TankState::Present(raw_value_mv) => {
+                raw_voltage_to_tank_fill_percent(*raw_value_mv, config).err()
+            }
+            TankState::Error(err) => Some(err.clone()),
+            TankState::Disabled => Some(TankError::SensorDisabled),
+        }
+    }
+
+    pub fn as_mqtt_info(&self, config: &TankConfig, water_temp: &FatResult<f32>) -> 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 warn level be triggered if there is an error?
+        let raw = match self {
+            TankState::Disabled | TankState::Error(_) => None,
+            TankState::Present(raw_value_mv) => Some(*raw_value_mv),
+        };
+
+        let percent = match raw {
+            Some(r) => raw_voltage_to_tank_fill_percent(r, config).ok(),
+            None => None,
+        };
+
+        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.as_ref().err().map(|err| err.to_string()),
+            percent,
+        }
+    }
+}
+
+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()
+            .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(err.to_string())),
+        }
+    } else {
+        TankState::Disabled
+    }
+}
+
+#[derive(Debug, Serialize)]
+/// Information structure send to mqtt for monitoring purposes
+pub struct TankInfo {
+    /// there is enough water in the tank
+    pub(crate) enough_water: bool,
+    /// 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>,
+    /// 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>,
+    /// percent value
+    pub(crate) percent: Option<f32>,
+    /// water in the tank might be frozen
+    pub(crate) water_frozen: bool,
+    /// water temperature
+    pub(crate) water_temp: Option<f32>,
+    pub(crate) temp_sensor_error: Option<String>,
+}

Software/MainBoard/rust/src/webserver/.gitignore

@@ -0,0 +1,2 @@
+index.html.gz
+bundle.js.gz

Software/MainBoard/rust/src/webserver/backup_manager.rs

@@ -0,0 +1,191 @@
+use crate::fat_error::{FatError, FatResult};
+use crate::hal::rtc::X25;
+use crate::BOARD_ACCESS;
+use alloc::borrow::ToOwned;
+use alloc::format;
+use alloc::string::{String, ToString};
+use chrono::DateTime;
+use edge_http::io::server::Connection;
+use embedded_io_async::{Read, Write};
+use log::info;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, PartialEq, Debug)]
+pub struct WebBackupHeader {
+    timestamp: String,
+    size: u16,
+}
+pub(crate) async fn get_backup_config<T, const N: usize>(
+    conn: &mut Connection<'_, T, { N }>,
+) -> FatResult<Option<u32>>
+where
+    T: Read + Write,
+{
+    // First pass: verify checksum without sending data
+    let mut checksum = X25.digest();
+    let mut chunk = 0_usize;
+    loop {
+        let mut board = BOARD_ACCESS.get().await.lock().await;
+        board.board_hal.progress(chunk as u32).await;
+        let (buf, len, expected_crc) = board
+            .board_hal
+            .get_rtc_module()
+            .get_backup_config(chunk)
+            .await?;
+
+        // Update checksum with the actual data bytes of this chunk
+        checksum.update(&buf[..len]);
+
+        let is_last = len == 0 || len < buf.len();
+        if is_last {
+            let actual_crc = checksum.finalize();
+            if actual_crc != expected_crc {
+                BOARD_ACCESS
+                    .get()
+                    .await
+                    .lock()
+                    .await
+                    .board_hal
+                    .clear_progress()
+                    .await;
+                conn.initiate_response(
+                    409,
+                    Some(
+                        format!(
+                            "Checksum mismatch expected {} got {}",
+                            expected_crc, actual_crc
+                        )
+                        .as_str(),
+                    ),
+                    &[],
+                )
+                .await?;
+                return Ok(Some(409));
+            }
+            break;
+        }
+        chunk += 1;
+    }
+    // Second pass: stream data
+    conn.initiate_response(
+        200,
+        Some("OK"),
+        &[
+            ("Access-Control-Allow-Origin", "*"),
+            ("Access-Control-Allow-Headers", "*"),
+            ("Access-Control-Allow-Methods", "*"),
+        ],
+    )
+    .await?;
+
+    let mut chunk = 0_usize;
+    loop {
+        let mut board = BOARD_ACCESS.get().await.lock().await;
+        board.board_hal.progress(chunk as u32).await;
+        let (buf, len, _expected_crc) = board
+            .board_hal
+            .get_rtc_module()
+            .get_backup_config(chunk)
+            .await?;
+
+        if len == 0 {
+            break;
+        }
+
+        conn.write_all(&buf[..len]).await?;
+
+        if len < buf.len() {
+            break;
+        }
+        chunk += 1;
+    }
+    BOARD_ACCESS
+        .get()
+        .await
+        .lock()
+        .await
+        .board_hal
+        .clear_progress()
+        .await;
+    Ok(Some(200))
+}
+
+pub(crate) async fn backup_config<T, const N: usize>(
+    conn: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>>
+where
+    T: Read + Write,
+{
+    let mut offset = 0_usize;
+    let mut buf = [0_u8; 32];
+
+    let mut checksum = X25.digest();
+
+    let mut counter = 0;
+    loop {
+        let to_write = conn.read(&mut buf).await?;
+        if to_write == 0 {
+            info!("backup finished");
+            break;
+        } else {
+            let mut board = BOARD_ACCESS.get().await.lock().await;
+            board.board_hal.progress(counter).await;
+
+            counter = counter + 1;
+            board
+                .board_hal
+                .get_rtc_module()
+                .backup_config(offset, &buf[0..to_write])
+                .await?;
+            checksum.update(&buf[0..to_write]);
+        }
+        offset = offset + to_write;
+    }
+
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    board
+        .board_hal
+        .get_rtc_module()
+        .backup_config_finalize(checksum.finalize(), offset)
+        .await?;
+    board.board_hal.clear_progress().await;
+    conn.initiate_response(
+        200,
+        Some("OK"),
+        &[
+            ("Access-Control-Allow-Origin", "*"),
+            ("Access-Control-Allow-Headers", "*"),
+            ("Access-Control-Allow-Methods", "*"),
+        ],
+    )
+    .await?;
+    Ok(Some("saved".to_owned()))
+}
+
+pub(crate) async fn backup_info<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> Result<Option<String>, FatError>
+where
+    T: Read + Write,
+{
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let header = board.board_hal.get_rtc_module().get_backup_info().await;
+    let json = match header {
+        Ok(h) => {
+            let timestamp = DateTime::from_timestamp_millis(h.timestamp).unwrap();
+            let wbh = WebBackupHeader {
+                timestamp: timestamp.to_rfc3339(),
+                size: h.size,
+            };
+            serde_json::to_string(&wbh)?
+        }
+        Err(err) => {
+            let wbh = WebBackupHeader {
+                timestamp: err.to_string(),
+                size: 0,
+            };
+            serde_json::to_string(&wbh)?
+        }
+    };
+    Ok(Some(json))
+}

Software/MainBoard/rust/src/webserver/file_manager.rs

@@ -0,0 +1,160 @@
+use crate::fat_error::{FatError, FatResult};
+use crate::webserver::read_up_to_bytes_from_request;
+use crate::BOARD_ACCESS;
+use alloc::borrow::ToOwned;
+use alloc::format;
+use alloc::string::String;
+use edge_http::io::server::Connection;
+use edge_http::Method;
+use embedded_io_async::{Read, Write};
+use log::info;
+
+pub(crate) async fn list_files<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let result = board.board_hal.get_esp().list_files().await?;
+    let file_list_json = serde_json::to_string(&result)?;
+    Ok(Some(file_list_json))
+}
+pub(crate) async fn file_operations<T, const N: usize>(
+    conn: &mut Connection<'_, T, { N }>,
+    method: Method,
+    path: &&str,
+    prefix: &&str,
+) -> Result<Option<u32>, FatError>
+where
+    T: Read + Write,
+{
+    let filename = &path[prefix.len()..];
+    info!("file request for {} with method {}", filename, method);
+    Ok(match method {
+        Method::Delete => {
+            let mut board = BOARD_ACCESS.get().await.lock().await;
+            board
+                .board_hal
+                .get_esp()
+                .delete_file(filename.to_owned())
+                .await?;
+            conn.initiate_response(
+                200,
+                Some("OK"),
+                &[
+                    ("Access-Control-Allow-Origin", "*"),
+                    ("Access-Control-Allow-Headers", "*"),
+                    ("Access-Control-Allow-Methods", "*"),
+                ],
+            )
+            .await?;
+            Some(200)
+        }
+        Method::Get => {
+            let disposition = format!("attachment; filename=\"{filename}\"");
+            let size = {
+                let mut board = BOARD_ACCESS.get().await.lock().await;
+                board
+                    .board_hal
+                    .get_esp()
+                    .get_size(filename.to_owned())
+                    .await?
+            };
+
+            conn.initiate_response(
+                200,
+                Some("OK"),
+                &[
+                    ("Content-Type", "application/octet-stream"),
+                    ("Content-Disposition", disposition.as_str()),
+                    ("Content-Length", &format!("{}", size)),
+                    ("Access-Control-Allow-Origin", "*"),
+                    ("Access-Control-Allow-Headers", "*"),
+                    ("Access-Control-Allow-Methods", "*"),
+                ],
+            )
+            .await?;
+
+            let mut chunk = 0;
+            loop {
+                let mut board = BOARD_ACCESS.get().await.lock().await;
+                board.board_hal.progress(chunk).await;
+                let read_chunk = board
+                    .board_hal
+                    .get_esp()
+                    .get_file(filename.to_owned(), chunk)
+                    .await?;
+                let length = read_chunk.1;
+                if length == 0 {
+                    info!("file request for {} finished", filename);
+                    break;
+                }
+                let data = &read_chunk.0[0..length];
+                conn.write_all(data).await?;
+                if length < read_chunk.0.len() {
+                    info!("file request for {} finished", filename);
+                    break;
+                }
+                chunk = chunk + 1;
+            }
+            BOARD_ACCESS
+                .get()
+                .await
+                .lock()
+                .await
+                .board_hal
+                .clear_progress()
+                .await;
+            Some(200)
+        }
+        Method::Post => {
+            {
+                let mut board = BOARD_ACCESS.get().await.lock().await;
+                //ensure the file is deleted first; otherwise we would need to truncate the file which will not work with streaming
+                let _ = board
+                    .board_hal
+                    .get_esp()
+                    .delete_file(filename.to_owned())
+                    .await;
+            }
+
+            let mut offset = 0_usize;
+            let mut chunk = 0;
+            loop {
+                let buf = read_up_to_bytes_from_request(conn, Some(4096)).await?;
+                if buf.len() == 0 {
+                    info!("file request for {} finished", filename);
+                    break;
+                } else {
+                    let mut board = BOARD_ACCESS.get().await.lock().await;
+                    board.board_hal.progress(chunk as u32).await;
+                    board
+                        .board_hal
+                        .get_esp()
+                        .write_file(filename.to_owned(), offset as u32, &buf)
+                        .await?;
+                }
+                offset = offset + buf.len();
+                chunk = chunk + 1;
+            }
+            BOARD_ACCESS
+                .get()
+                .await
+                .lock()
+                .await
+                .board_hal
+                .clear_progress()
+                .await;
+            conn.initiate_response(
+                200,
+                Some("OK"),
+                &[
+                    ("Access-Control-Allow-Origin", "*"),
+                    ("Access-Control-Allow-Headers", "*"),
+                    ("Access-Control-Allow-Methods", "*"),
+                ],
+            )
+            .await?;
+            Some(200)
+        }
+        _ => None,
+    })
+}

Software/MainBoard/rust/src/webserver/get_json.rs

@@ -0,0 +1,186 @@
+use core::str::FromStr;
+use crate::fat_error::{FatError, FatResult};
+use crate::hal::{esp_time, PLANT_COUNT};
+use crate::log::LogMessage;
+use crate::plant_state::{MoistureSensorState, PlantState};
+use crate::tank::determine_tank_state;
+use crate::{get_version, BOARD_ACCESS};
+use alloc::format;
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+use chrono_tz::Tz;
+use edge_http::io::server::Connection;
+use embedded_io_async::{Read, Write};
+use log::info;
+use serde::Serialize;
+
+#[derive(Serialize, Debug)]
+struct LoadData<'a> {
+    rtc: &'a str,
+    native: &'a str,
+}
+#[derive(Serialize, Debug)]
+struct Moistures {
+    moisture_a: Vec<String>,
+    moisture_b: Vec<String>,
+}
+#[derive(Serialize, Debug)]
+struct SolarState {
+    mppt_voltage: f32,
+    mppt_current: f32,
+    is_day: bool,
+}
+pub(crate) async fn get_live_moisture<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>>
+where
+    T: Read + Write,
+{
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let moistures = board.board_hal.measure_moisture_hz().await?;
+    let mut plant_state = Vec::new();
+    for i in 0..PLANT_COUNT {
+        plant_state.push(PlantState::read_hardware_state(moistures, i, &mut board).await);
+    }
+    let a = Vec::from_iter(plant_state.iter().map(|s| match &s.sensor_a {
+        MoistureSensorState::Disabled => "disabled".to_string(),
+        MoistureSensorState::MoistureValue {
+            raw_hz,
+            moisture_percent,
+        } => {
+            format!("{moisture_percent:.2}% {raw_hz}hz",)
+        }
+        MoistureSensorState::SensorError(err) => format!("{err:?}"),
+    }));
+    let b = Vec::from_iter(plant_state.iter().map(|s| match &s.sensor_b {
+        MoistureSensorState::Disabled => "disabled".to_string(),
+        MoistureSensorState::MoistureValue {
+            raw_hz,
+            moisture_percent,
+        } => {
+            format!("{moisture_percent:.2}% {raw_hz}hz",)
+        }
+        MoistureSensorState::SensorError(err) => format!("{err:?}"),
+    }));
+
+    let data = Moistures {
+        moisture_a: a,
+        moisture_b: b,
+    };
+    let json = serde_json::to_string(&data)?;
+
+    Ok(Some(json))
+}
+
+pub(crate) async fn tank_info<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> Result<Option<String>, FatError>
+where
+    T: Read + Write,
+{
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let tank_state = determine_tank_state(&mut board).await;
+    //should be multisampled
+    let sensor = board.board_hal.get_tank_sensor()?;
+
+    let water_temp: FatResult<f32> = sensor.water_temperature_c().await;
+    Ok(Some(serde_json::to_string(&tank_state.as_mqtt_info(
+        &board.board_hal.get_config().tank,
+        &water_temp,
+    ))?))
+}
+
+pub(crate) async fn get_timezones() -> FatResult<Option<String>> {
+    // Get all timezones compiled into the binary from chrono-tz
+    let timezones: Vec<&'static str> = chrono_tz::TZ_VARIANTS.iter().map(|tz| tz.name()).collect();
+    let json = serde_json::to_string(&timezones)?;
+    Ok(Some(json))
+}
+
+pub(crate) async fn get_solar_state<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let state = SolarState {
+        mppt_voltage: board.board_hal.get_mptt_voltage().await?.as_millivolts() as f32,
+        mppt_current: board.board_hal.get_mptt_current().await?.as_milliamperes() as f32,
+        is_day: board.board_hal.is_day(),
+    };
+    Ok(Some(serde_json::to_string(&state)?))
+}
+
+pub(crate) async fn get_version_web<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    Ok(Some(serde_json::to_string(&get_version(&mut board).await)?))
+}
+
+pub(crate) async fn get_config<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let json = serde_json::to_string(&board.board_hal.get_config())?;
+    Ok(Some(json))
+}
+
+pub(crate) async fn get_battery_state<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let battery_state = board
+        .board_hal
+        .get_battery_monitor()
+        .get_battery_state()
+        .await?;
+    Ok(Some(serde_json::to_string(&battery_state)?))
+}
+
+pub(crate) async fn get_time<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let conf = board.board_hal.get_config();
+
+    let tz:Tz = match conf.timezone.as_ref(){
+        None => {
+            Tz::UTC
+        }
+        Some(tz_string) => {
+            match Tz::from_str(tz_string) {
+                Ok(tz) => {
+                    tz
+                }
+                Err(err) => {
+                    info!("failed parsing timezone {}", err);
+                    Tz::UTC
+                }
+            }
+        }
+    };
+
+    let native = esp_time().await.with_timezone(&tz).to_rfc3339();
+
+    let rtc = match board.board_hal.get_rtc_module().get_rtc_time().await {
+        Ok(time) => time.with_timezone(&tz).to_rfc3339(),
+        Err(err) => {
+            format!("Error getting time: {}", err)
+        }
+    };
+
+    let data = LoadData {
+        rtc: rtc.as_str(),
+        native: native.as_str(),
+    };
+    let json = serde_json::to_string(&data)?;
+
+    Ok(Some(json))
+}
+
+pub(crate) async fn get_log_localization_config<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>> {
+    Ok(Some(serde_json::to_string(
+        &LogMessage::to_log_localisation_config(),
+    )?))
+}

Software/MainBoard/rust/src/webserver/get_log.rs

@@ -0,0 +1,36 @@
+use crate::fat_error::FatResult;
+use crate::log::LOG_ACCESS;
+use edge_http::io::server::Connection;
+use embedded_io_async::{Read, Write};
+
+pub(crate) async fn get_log<T, const N: usize>(
+    conn: &mut Connection<'_, T, N>,
+) -> FatResult<Option<u32>>
+where
+    T: Read + Write,
+{
+    let log = LOG_ACCESS.lock().await.get();
+    conn.initiate_response(
+        200,
+        Some("OK"),
+        &[
+            ("Content-Type", "text/javascript"),
+            ("Access-Control-Allow-Origin", "*"),
+            ("Access-Control-Allow-Headers", "*"),
+            ("Access-Control-Allow-Methods", "*"),
+        ],
+    )
+    .await?;
+    conn.write_all("[".as_bytes()).await?;
+    let mut append = false;
+    for entry in log {
+        if append {
+            conn.write_all(",".as_bytes()).await?;
+        }
+        append = true;
+        let json = serde_json::to_string(&entry)?;
+        conn.write_all(json.as_bytes()).await?;
+    }
+    conn.write_all("]".as_bytes()).await?;
+    Ok(Some(200))
+}

Software/MainBoard/rust/src/webserver/get_static.rs

@@ -0,0 +1,50 @@
+use crate::fat_error::FatError;
+use edge_http::io::server::Connection;
+use embedded_io_async::{Read, Write};
+
+pub(crate) async fn serve_favicon<T, const N: usize>(
+    conn: &mut Connection<'_, T, { N }>,
+) -> Result<Option<u32>, FatError>
+where
+    T: Read + Write,
+{
+    conn.initiate_response(200, Some("OK"), &[("Content-Type", "image/x-icon")])
+        .await?;
+    conn.write_all(include_bytes!("favicon.ico")).await?;
+    Ok(Some(200))
+}
+
+pub(crate) async fn serve_index<T, const N: usize>(
+    conn: &mut Connection<'_, T, { N }>,
+) -> Result<Option<u32>, FatError>
+where
+    T: Read + Write,
+{
+    conn.initiate_response(
+        200,
+        Some("OK"),
+        &[("Content-Type", "text/html"), ("Content-Encoding", "gzip")],
+    )
+    .await?;
+    conn.write_all(include_bytes!("index.html.gz")).await?;
+    Ok(Some(200))
+}
+
+pub(crate) async fn serve_bundle<T, const N: usize>(
+    conn: &mut Connection<'_, T, { N }>,
+) -> Result<Option<u32>, FatError>
+where
+    T: Read + Write,
+{
+    conn.initiate_response(
+        200,
+        Some("OK"),
+        &[
+            ("Content-Type", "text/javascript"),
+            ("Content-Encoding", "gzip"),
+        ],
+    )
+    .await?;
+    conn.write_all(include_bytes!("bundle.js.gz")).await?;
+    Ok(Some(200))
+}

Software/MainBoard/rust/src/webserver/mod.rs

@@ -0,0 +1,302 @@
+//offer ota and config mode
+
+mod backup_manager;
+mod file_manager;
+mod get_json;
+mod get_log;
+mod get_static;
+mod ota;
+mod post_json;
+
+use crate::fat_error::{FatError, FatResult};
+use crate::webserver::backup_manager::{backup_config, backup_info, get_backup_config};
+use crate::webserver::file_manager::{file_operations, list_files};
+use crate::webserver::get_json::{
+    get_battery_state, get_config, get_live_moisture, get_log_localization_config, get_solar_state,
+    get_time, get_timezones, get_version_web, tank_info,
+};
+use crate::webserver::get_log::get_log;
+use crate::webserver::get_static::{serve_bundle, serve_favicon, serve_index};
+use crate::webserver::ota::ota_operations;
+use crate::webserver::post_json::{
+    board_test, night_lamp_test, pump_test, set_config, wifi_scan, write_time, detect_sensors,
+};
+use crate::{bail, BOARD_ACCESS};
+use alloc::borrow::ToOwned;
+use alloc::string::{String, ToString};
+use alloc::sync::Arc;
+use alloc::vec::Vec;
+use core::fmt::{Debug, Display};
+use core::net::{IpAddr, Ipv4Addr, SocketAddr};
+use core::result::Result::Ok;
+use core::sync::atomic::{AtomicBool, Ordering};
+use edge_http::io::server::{Connection, Handler, Server};
+use edge_http::Method;
+use edge_nal::TcpBind;
+use edge_nal_embassy::{Tcp, TcpBuffers};
+use embassy_net::Stack;
+use embassy_time::Instant;
+use embedded_io_async::{Read, Write};
+use log::{error, info};
+// fn ota(
+//     request: &mut Request<&mut EspHttpConnection>,
+// ) -> Result<Option<std::string::String>, anyhow::Error> {
+//     let mut board = BOARD_ACCESS.lock().unwrap();
+//     let mut ota = OtaUpdate::begin()?;
+//     log::info!("start ota");
+//
+//     //having a larger buffer is not really faster, requires more stack and prevents the progress bar from working ;)
+//     const BUFFER_SIZE: usize = 512;
+//     let mut buffer: [u8; BUFFER_SIZE] = [0; BUFFER_SIZE];
+//     let mut total_read: usize = 0;
+//     let mut lastiter = 0;
+//     loop {
+//         let read = request.read(&mut buffer)?;
+//         total_read += read;
+//         let to_write = &buffer[0..read];
+//         //delay for watchdog and wifi stuff
+//         board.board_hal.get_esp().delay.delay_ms(1);
+//
+//         let iter = (total_read / 1024) % 8;
+//         if iter != lastiter {
+//             board.board_hal.general_fault(iter % 5 == 0);
+//             for i in 0..PLANT_COUNT {
+//                 let _ = board.board_hal.fault(i, iter == i);
+//             }
+//             lastiter = iter;
+//         }
+//
+//         ota.write(to_write)?;
+//         if read == 0 {
+//             break;
+//         }
+//     }
+//     log::info!("wrote bytes ota {total_read}");
+//     log::info!("finish ota");
+//     let partition = ota.raw_partition();
+//     log::info!("finalizing and changing boot partition to {partition:?}");
+//
+//     let mut finalizer = ota.finalize()?;
+//     log::info!("changing boot partition");
+//     board.board_hal.get_esp().set_restart_to_conf(true);
+//     drop(board);
+//     finalizer.set_as_boot_partition()?;
+//     anyhow::Ok(None)
+// }
+//
+
+struct HTTPRequestRouter {
+    reboot_now: Arc<AtomicBool>,
+}
+
+impl Handler for HTTPRequestRouter {
+    type Error<E: Debug> = FatError;
+    async fn handle<'a, T, const N: usize>(
+        &self,
+        _task_id: impl Display + Copy,
+        conn: &mut Connection<'a, T, N>,
+    ) -> Result<(), FatError>
+    where
+        T: Read + Write,
+    {
+        let start = Instant::now();
+        let headers = conn.headers()?;
+
+        let method = headers.method;
+        let path = headers.path;
+
+        let prefix = "/file?filename=";
+        let status = if path.starts_with(prefix) {
+            file_operations(conn, method, &path, &prefix).await?
+        } else if path == "/ota" {
+            ota_operations(conn, method).await.map_err(|e| {
+                error!("Error handling ota: {}", e);
+                e
+            })?
+        } else {
+            match method {
+                Method::Get => match path {
+                    "/favicon.ico" => serve_favicon(conn).await?,
+                    "/" => serve_index(conn).await?,
+                    "/bundle.js" => serve_bundle(conn).await?,
+                    "/log" => get_log(conn).await?,
+                    "/get_backup_config" => get_backup_config(conn).await?,
+                    &_ => {
+                        let json = match path {
+                            "/version" => Some(get_version_web(conn).await),
+                            "/time" => Some(get_time(conn).await),
+                            "/battery" => Some(get_battery_state(conn).await),
+                            "/solar" => Some(get_solar_state(conn).await),
+                            "/get_config" => Some(get_config(conn).await),
+                            "/files" => Some(list_files(conn).await),
+                            "/log_localization" => Some(get_log_localization_config(conn).await),
+                            "/tank" => Some(tank_info(conn).await),
+                            "/backup_info" => Some(backup_info(conn).await),
+                            "/timezones" => Some(get_timezones().await),
+                            "/moisture" => Some(get_live_moisture(conn).await),
+                            _ => None,
+                        };
+                        match json {
+                            None => None,
+                            Some(json) => Some(handle_json(conn, json).await?),
+                        }
+                    }
+                },
+                Method::Post => {
+                    let json = match path {
+                        "/wifiscan" => Some(wifi_scan(conn).await),
+                        "/set_config" => Some(set_config(conn).await),
+                        "/time" => Some(write_time(conn).await),
+                        "/backup_config" => Some(backup_config(conn).await),
+                        "/pumptest" => Some(pump_test(conn).await),
+                        "/lamptest" => Some(night_lamp_test(conn).await),
+                        "/boardtest" => Some(board_test().await),
+                        "/detect_sensors" => Some(detect_sensors().await),
+                        "/reboot" => {
+                            let mut board = BOARD_ACCESS.get().await.lock().await;
+                            board.board_hal.get_esp().set_restart_to_conf(true);
+                            self.reboot_now.store(true, Ordering::Relaxed);
+                            Some(Ok(None))
+                        }
+                        "/exit" => {
+                            let mut board = BOARD_ACCESS.get().await.lock().await;
+                            board.board_hal.get_esp().set_restart_to_conf(false);
+                            self.reboot_now.store(true, Ordering::Relaxed);
+                            Some(Ok(None))
+                        }
+                        _ => None,
+                    };
+                    match json {
+                        None => None,
+                        Some(json) => Some(handle_json(conn, json).await?),
+                    }
+                }
+                Method::Options | Method::Delete | Method::Head | Method::Put => None,
+                _ => None,
+            }
+        };
+        let code = match status {
+            None => {
+                conn.initiate_response(404, Some("Not found"), &[]).await?;
+                404
+            }
+            Some(code) => code,
+        };
+
+        conn.complete().await?;
+        let response_time = Instant::now().duration_since(start).as_millis();
+
+        info!("\"{method} {path}\" {code} {response_time}ms");
+        Ok(())
+    }
+}
+
+async fn read_up_to_bytes_from_request<T, const N: usize>(
+    request: &mut Connection<'_, T, N>,
+    limit: Option<usize>,
+) -> FatResult<Vec<u8>>
+where
+    T: Read + Write,
+{
+    let max_read = limit.unwrap_or(1024);
+    let mut data_store = Vec::new();
+    let mut total_read = 0;
+    loop {
+        let left = max_read - total_read;
+        let mut buf = [0_u8; 64];
+        let s_buf = if buf.len() <= left {
+            &mut buf
+        } else {
+            &mut buf[0..left]
+        };
+        let read = request.read(s_buf).await?;
+        if read == 0 {
+            break;
+        }
+        let actual_data = &s_buf[0..read];
+        total_read += read;
+        if total_read > max_read {
+            bail!("Request too large {total_read} > {max_read}");
+        }
+        data_store.push(actual_data.to_owned());
+    }
+    let final_buffer = data_store.concat();
+    Ok(final_buffer)
+}
+
+#[embassy_executor::task]
+pub async fn http_server(reboot_now: Arc<AtomicBool>, stack: Stack<'static>) {
+    let buffer: TcpBuffers<2, 1024, 1024> = TcpBuffers::new();
+    let tcp = Tcp::new(stack, &buffer);
+    let acceptor = tcp
+        .bind(SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 80))
+        .await
+        .unwrap();
+
+    let mut server: Server<2, 512, 15> = Server::new();
+    server
+        .run(Some(5000), acceptor, HTTPRequestRouter { reboot_now })
+        .await
+        .expect("Tcp stack error");
+    info!("Webserver started and waiting for connections");
+
+    //TODO https if mbed_esp lands
+}
+
+async fn handle_json<'a, T, const N: usize>(
+    conn: &mut Connection<'a, T, N>,
+    chain: FatResult<Option<String>>,
+) -> FatResult<u32>
+where
+    T: Read + Write,
+    <T as embedded_io_async::ErrorType>::Error: Debug,
+{
+    match chain {
+        Ok(answer) => match answer {
+            Some(json) => {
+                conn.initiate_response(
+                    200,
+                    Some("OK"),
+                    &[
+                        ("Access-Control-Allow-Origin", "*"),
+                        ("Access-Control-Allow-Headers", "*"),
+                        ("Access-Control-Allow-Methods", "*"),
+                        ("Content-Type", "application/json"),
+                    ],
+                )
+                .await?;
+                conn.write_all(json.as_bytes()).await?;
+                Ok(200)
+            }
+            None => {
+                conn.initiate_response(
+                    200,
+                    Some("OK"),
+                    &[
+                        ("Access-Control-Allow-Origin", "*"),
+                        ("Access-Control-Allow-Headers", "*"),
+                        ("Access-Control-Allow-Methods", "*"),
+                    ],
+                )
+                .await?;
+                Ok(200)
+            }
+        },
+        Err(err) => {
+            let error_text = err.to_string();
+            info!("error handling process {}", error_text);
+            conn.initiate_response(
+                500,
+                Some("OK"),
+                &[
+                    ("Access-Control-Allow-Origin", "*"),
+                    ("Access-Control-Allow-Headers", "*"),
+                    ("Access-Control-Allow-Methods", "*"),
+                ],
+            )
+            .await?;
+            conn.write_all(error_text.as_bytes()).await?;
+            Ok(500)
+        }
+    }
+}

Software/MainBoard/rust/src/webserver/ota.rs

@@ -0,0 +1,76 @@
+use crate::fat_error::FatError;
+use crate::webserver::read_up_to_bytes_from_request;
+use crate::BOARD_ACCESS;
+use edge_http::io::server::Connection;
+use edge_http::Method;
+use embedded_io_async::{Read, Write};
+use log::info;
+
+pub(crate) async fn ota_operations<T, const N: usize>(
+    conn: &mut Connection<'_, T, { N }>,
+    method: Method,
+) -> Result<Option<u32>, FatError>
+where
+    T: Read + Write,
+{
+    Ok(match method {
+        Method::Options => {
+            conn.initiate_response(
+                200,
+                Some("OK"),
+                &[
+                    ("Access-Control-Allow-Origin", "*"),
+                    ("Access-Control-Allow-Headers", "*"),
+                    ("Access-Control-Allow-Methods", "*"),
+                ],
+            )
+            .await?;
+            Some(200)
+        }
+        Method::Post => {
+            let mut offset = 0_usize;
+            let mut chunk = 0;
+            loop {
+                let buf = read_up_to_bytes_from_request(conn, Some(4096)).await?;
+                if buf.len() == 0 {
+                    info!("file request for  ota finished");
+                    let mut board = BOARD_ACCESS.get().await.lock().await;
+                    board.board_hal.get_esp().finalize_ota().await?;
+                    break;
+                } else {
+                    let mut board = BOARD_ACCESS.get().await.lock().await;
+                    board.board_hal.progress(chunk as u32).await;
+                    // Erase next block if we are at a 4K boundary (including the first block at offset 0)
+                    info!("erasing and writing block 0x{offset:x}");
+                    board
+                        .board_hal
+                        .get_esp()
+                        .write_ota(offset as u32, &*buf)
+                        .await?;
+                }
+                offset = offset + buf.len();
+                chunk = chunk + 1;
+            }
+            BOARD_ACCESS
+                .get()
+                .await
+                .lock()
+                .await
+                .board_hal
+                .clear_progress()
+                .await;
+            conn.initiate_response(
+                200,
+                Some("OK"),
+                &[
+                    ("Access-Control-Allow-Origin", "*"),
+                    ("Access-Control-Allow-Headers", "*"),
+                    ("Access-Control-Allow-Methods", "*"),
+                ],
+            )
+            .await?;
+            Some(200)
+        }
+        _ => None,
+    })
+}

Software/MainBoard/rust/src/webserver/post_json.rs

@@ -0,0 +1,119 @@
+use crate::config::PlantControllerConfig;
+use crate::fat_error::FatResult;
+use crate::hal::esp_set_time;
+use crate::webserver::read_up_to_bytes_from_request;
+use crate::{do_secure_pump, BOARD_ACCESS};
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+use chrono::DateTime;
+use edge_http::io::server::Connection;
+use embedded_io_async::{Read, Write};
+use log::info;
+use serde::{Deserialize, Serialize};
+
+#[derive(Deserialize)]
+pub struct NightLampCommand {
+    active: bool,
+}
+#[derive(Serialize, Debug)]
+struct SSIDList {
+    ssids: Vec<String>,
+}
+#[derive(Deserialize, Debug)]
+struct SetTime<'a> {
+    time: &'a str,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+pub struct TestPump {
+    pump: usize,
+}
+
+pub(crate) async fn wifi_scan<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    info!("start wifi scan");
+    let mut ssids: Vec<String> = Vec::new();
+    let scan_result = board.board_hal.get_esp().wifi_scan().await?;
+    scan_result
+        .iter()
+        .for_each(|s| ssids.push(s.ssid.to_string()));
+    let ssid_json = serde_json::to_string(&SSIDList { ssids })?;
+    info!("Sending ssid list {}", &ssid_json);
+    Ok(Some(ssid_json))
+}
+
+pub(crate) async fn board_test() -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    board.board_hal.test().await?;
+    Ok(None)
+}
+
+pub(crate) async fn detect_sensors() -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let result = board.board_hal.detect_sensors().await?;
+    let json = serde_json::to_string(&result)?;
+    Ok(Some(json))
+}
+
+pub(crate) async fn pump_test<T, const N: usize>(
+    request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>>
+where
+    T: Read + Write,
+{
+    let actual_data = read_up_to_bytes_from_request(request, None).await?;
+    let pump_test: TestPump = serde_json::from_slice(&actual_data)?;
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+
+    let config = &board.board_hal.get_config().plants[pump_test.pump].clone();
+    let pump_result = do_secure_pump(&mut board, pump_test.pump, config, false).await;
+    //ensure it is disabled before unwrapping
+    board.board_hal.pump(pump_test.pump, false).await?;
+
+    Ok(Some(serde_json::to_string(&pump_result?)?))
+}
+
+pub(crate) async fn night_lamp_test<T, const N: usize>(
+    request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>>
+where
+    T: Read + Write,
+{
+    let actual_data = read_up_to_bytes_from_request(request, None).await?;
+    let light_command: NightLampCommand = serde_json::from_slice(&actual_data)?;
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    board.board_hal.light(light_command.active).await?;
+    Ok(None)
+}
+
+pub(crate) async fn write_time<T, const N: usize>(
+    request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>>
+where
+    T: Read + Write,
+{
+    let actual_data = read_up_to_bytes_from_request(request, None).await?;
+    let time: SetTime = serde_json::from_slice(&actual_data)?;
+    let parsed = DateTime::parse_from_rfc3339(time.time).unwrap();
+    esp_set_time(parsed).await?;
+    Ok(None)
+}
+
+pub(crate) async fn set_config<T, const N: usize>(
+    request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>>
+where
+    T: Read + Write,
+{
+    let all = read_up_to_bytes_from_request(request, Some(4096)).await?;
+    let length = all.len();
+    let config: PlantControllerConfig = serde_json::from_slice(&all)?;
+
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    board.board_hal.get_esp().save_config(all).await?;
+    info!("Wrote config config {:?} with size {}", config, length);
+    board.board_hal.set_config(config);
+    Ok(Some("Ok".to_string()))
+}