splitting wip

rust/src/hal/esp.rs

@@ -1,27 +1,42 @@
 use crate::config::{NetworkConfig, PlantControllerConfig};
-use crate::hal::{CONSECUTIVE_WATERING_PLANT, LAST_WATERING_TIMESTAMP, LOW_VOLTAGE_DETECTED, PLANT_COUNT, RESTART_TO_CONF};
+use crate::hal::PLANT_COUNT;
 use crate::log::{log, LogMessage};
+use crate::STAY_ALIVE;
 use anyhow::{anyhow, bail, Context};
+use chrono::{DateTime, Utc};
 use embedded_svc::ipv4::IpInfo;
-use embedded_svc::wifi::{AccessPointConfiguration, AuthMethod, ClientConfiguration, Configuration};
+use embedded_svc::mqtt::client::QoS::{AtLeastOnce, ExactlyOnce};
+use embedded_svc::wifi::{AccessPointConfiguration, AccessPointInfo, AuthMethod, ClientConfiguration, Configuration};
 use esp_idf_hal::delay::Delay;
-use esp_idf_hal::gpio::PinDriver;
+use esp_idf_hal::gpio::{Level, PinDriver};
 use esp_idf_svc::mqtt::client::{EspMqttClient, LwtConfiguration, MqttClientConfiguration};
+use esp_idf_svc::wifi::config::{ScanConfig, ScanType};
 use esp_idf_svc::wifi::EspWifi;
 use esp_idf_sys::{esp_spiffs_info, vTaskDelay};
+use serde::Serialize;
 use std::ffi::CString;
 use std::fs;
 use std::fs::File;
 use std::path::Path;
 use std::result::Result::Ok as OkStd;
 use std::str::FromStr;
-use std::sync::{Arc, Mutex};
 use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
 use std::time::Duration;
-use embedded_svc::mqtt::client::QoS::{AtLeastOnce, ExactlyOnce};
-use esp_idf_hal::i2c::I2cDriver;
-use serde::Serialize;
-use crate::STAY_ALIVE;
+use esp_idf_svc::sntp;
+use esp_idf_svc::sntp::SyncStatus;
+use esp_idf_svc::systime::EspSystemTime;
+
+
+#[link_section = ".rtc.data"]
+static mut LAST_WATERING_TIMESTAMP: [i64; PLANT_COUNT] = [0; PLANT_COUNT];
+#[link_section = ".rtc.data"]
+static mut CONSECUTIVE_WATERING_PLANT: [u32; PLANT_COUNT] = [0; PLANT_COUNT];
+#[link_section = ".rtc.data"]
+static mut LOW_VOLTAGE_DETECTED: bool = false;
+#[link_section = ".rtc.data"]
+static mut RESTART_TO_CONF: bool = false;
+
 
 #[derive(Serialize, Debug)]
 pub struct FileInfo {
@@ -61,8 +76,84 @@ impl ESP<'_> {
     const CONFIG_FILE: &'static str = "/spiffs/config.cfg";
     const BASE_PATH: &'static str = "/spiffs";
 
+    pub(crate) fn mode_override_pressed(&mut self) -> bool {
+        self.boot_button.get_level() == Level::Low
+    }
+    pub(crate) fn sntp(&mut self, max_wait_ms: u32) -> anyhow::Result<DateTime<Utc>> {
+        let sntp = sntp::EspSntp::new_default()?;
+        let mut counter = 0;
+        while sntp.get_sync_status() != SyncStatus::Completed {
+            self.delay.delay_ms(100);
+            counter += 100;
+            if counter > max_wait_ms {
+                bail!("Reached sntp timeout, aborting")
+            }
+        }
+        self.time()
+    }
+    pub(crate) fn time(&mut self) -> anyhow::Result<DateTime<Utc>> {
+        let time = EspSystemTime {}.now().as_millis();
+        let smaller_time = time as i64;
+        let local_time = DateTime::from_timestamp_millis(smaller_time)
+            .ok_or(anyhow!("could not convert timestamp"))?;
+        anyhow::Ok(local_time)
+    }
+    pub(crate) fn wifi_scan(&mut self) -> anyhow::Result<Vec<AccessPointInfo>> {
+        self.wifi_driver.start_scan(
+            &ScanConfig {
+                scan_type: ScanType::Passive(Duration::from_secs(5)),
+                show_hidden: false,
+                ..Default::default()
+            },
+            true,
+        )?;
+        anyhow::Ok(self.wifi_driver.get_scan_result()?)
+    }
+
+    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 = true;
+        }
+    }
+    pub(crate) fn clear_low_voltage_in_cycle(&mut self) {
+        unsafe {
+            LOW_VOLTAGE_DETECTED = false;
+        }
+    }
+
+    pub(crate) fn low_voltage_in_cycle(&mut self) -> bool {
+        unsafe {
+            LOW_VOLTAGE_DETECTED
+        }
+    }
+    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 }
+    }
+    pub(crate) fn set_restart_to_conf(&mut self, to_conf: bool) {
+        unsafe {
+            RESTART_TO_CONF = to_conf;
+        }
+    }
+
     pub(crate) fn wifi_ap(&mut self) -> anyhow::Result<()> {
-        let ssid = match self.get_config(){
+        let ssid = match self.load_config(){
             Ok(config) => {
                 config.network.ap_ssid.clone()
             }
@@ -145,12 +236,12 @@ impl ESP<'_> {
         log(LogMessage::WifiInfo, 0, 0, "", &format!("{address:?}"));
         anyhow::Ok(address)
     }
-    pub(crate) fn get_config(&mut self) -> anyhow::Result<PlantControllerConfig> {
+    pub(crate) fn load_config(&mut self) -> anyhow::Result<PlantControllerConfig> {
         let cfg = File::open(Self::CONFIG_FILE)?;
         let config: PlantControllerConfig = serde_json::from_reader(cfg)?;
         anyhow::Ok(config)
     }
-    pub(crate) fn set_config(&mut self, config: &PlantControllerConfig) -> anyhow::Result<()> {
+    pub(crate) fn save_config(&mut self, config: &PlantControllerConfig) -> anyhow::Result<()> {
         let mut cfg = File::create(Self::CONFIG_FILE)?;
         serde_json::to_writer(&mut cfg, &config)?;
         println!("Wrote config config {:?}", config);
@@ -227,7 +318,7 @@ impl ESP<'_> {
                                 filename: file.file_name().into_string().unwrap(),
                                 size: file
                                     .metadata()
-                                    .and_then(|it| anyhow::Result::Ok(it.len()))
+                                    .and_then(|it| Ok(it.len()))
                                     .unwrap_or_default()
                                     as usize,
                             };

rust/src/hal/initial_hal.rs

@@ -0,0 +1,99 @@
+use crate::hal::{deep_sleep, BackupHeader, BoardInteraction, Sensor};
+use anyhow::{bail, Result};
+use chrono::{DateTime, Utc};
+use embedded_hal::digital::OutputPin;
+use esp_idf_hal::gpio::{InputOutput, PinDriver};
+use crate::config::{BoardHardware, PlantControllerConfig};
+use crate::hal::battery::{BatteryInteraction, BatteryMonitor};
+use crate::hal::esp::ESP;
+
+pub struct Initial<'a> {
+    pub(crate) general_fault: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+    pub(crate) esp: ESP<'a>,
+    pub(crate) config: PlantControllerConfig,
+}
+
+impl BoardInteraction<'_> for Initial<'_> {
+    fn get_esp<'a>(&mut self) -> &mut ESP<'a> {
+        &mut self.esp
+    }
+
+    fn get_config(&mut self) -> &PlantControllerConfig {
+        &self.config
+    }
+
+    fn get_battery_monitor(&mut self) -> Box<dyn BatteryInteraction> {
+        let v = BatteryMonitor::Disabled {
+
+        };
+        Box::new(v) as Box<dyn BatteryInteraction>
+    }
+
+    fn set_charge_indicator(&mut self, charging: bool) -> Result<()> {
+        bail!("Please configure board revision")
+    }
+
+    fn deep_sleep(&mut self, duration_in_ms: u64) -> ! {
+        deep_sleep(duration_in_ms)
+    }
+
+    fn get_backup_info(&mut self) -> Result<BackupHeader> {
+        bail!("Please configure board revision")
+    }
+
+    fn get_backup_config(&mut self) -> Result<Vec<u8>> {
+        bail!("Please configure board revision")
+    }
+
+    fn backup_config(&mut self, bytes: &[u8]) -> Result<()> {
+        bail!("Please configure board revision")
+    }
+
+    fn is_day(&self) -> bool {
+        false
+    }
+
+    fn water_temperature_c(&mut self) -> Result<f32> {
+        bail!("Please configure board revision")
+    }
+
+    fn tank_sensor_voltage(&mut self) -> Result<f32> {
+        bail!("Please configure board revision")
+    }
+    fn light(&mut self, enable: bool) -> Result<()> {
+        bail!("Please configure board revision")
+    }
+
+    fn pump(&mut self, plant: usize, enable: bool) -> Result<()> {
+        bail!("Please configure board revision")
+    }
+    fn fault(&mut self, plant: usize, _enable: bool) -> Result<()> {
+        bail!("Please configure board revision")
+    }
+    fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> Result<f32> {
+        bail!("Please configure board revision")
+    }
+
+    fn general_fault(&mut self, enable: bool) {
+        let _ = self.general_fault.set_state(enable.into());
+    }
+
+    fn factory_reset(&mut self) -> Result<()> {
+        bail!("Please configure board revision")
+    }
+
+    fn get_rtc_time(&mut self) -> Result<DateTime<Utc>> {
+        bail!("Please configure board revision")
+    }
+
+    fn set_rtc_time(&mut self, time: &DateTime<Utc>) -> Result<()> {
+        bail!("Please configure board revision")
+    }
+    fn test_pump(&mut self, plant: usize) -> Result<()> {
+        bail!("Please configure board revision")
+    }
+
+    fn test(&mut self) -> Result<()> {
+        bail!("Please configure board revision")
+    }
+}

rust/src/hal/v3_hal.rs

@@ -0,0 +1,621 @@
+use crate::hal::esp::ESP;
+use crate::hal::{deep_sleep, BackupHeader, BoardInteraction, FreePeripherals, Sensor, V3Constants, I2C_DRIVER, PLANT_COUNT, REPEAT_MOIST_MEASURE, TANK_MULTI_SAMPLE, X25};
+use crate::log::{log, LogMessage};
+use anyhow::{anyhow, bail, Ok, Result};
+use chrono::{DateTime, Utc};
+use ds18b20::Ds18b20;
+use ds323x::{DateTimeAccess, Ds323x};
+use eeprom24x::{Eeprom24x, Eeprom24xTrait, SlaveAddr};
+use embedded_hal::digital::OutputPin;
+use embedded_hal_bus::i2c::MutexDevice;
+use esp_idf_hal::adc::oneshot::{AdcChannelDriver, AdcDriver};
+use esp_idf_hal::delay::Delay;
+use esp_idf_hal::gpio::{AnyInputPin, Gpio5, IOPin, InputOutput, PinDriver, Pull};
+use esp_idf_hal::i2c::I2cDriver;
+use esp_idf_hal::pcnt::{PcntChannel, PcntChannelConfig, PcntControlMode, PcntCountMode, PcntDriver, PinIndex};
+use esp_idf_sys::{gpio_hold_dis, gpio_hold_en, vTaskDelay, EspError};
+use one_wire_bus::OneWire;
+use plant_ctrl2::sipo::ShiftRegister40;
+use std::result::Result::Ok as OkStd;
+use esp_idf_hal::adc::{attenuation, Resolution};
+use esp_idf_hal::adc::oneshot::config::AdcChannelConfig;
+use crate::config::PlantControllerConfig;
+use crate::hal::battery::{BatteryInteraction, BatteryMonitor};
+
+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;
+
+pub struct V3<'a> {
+    config: PlantControllerConfig,
+    battery_monitor: Box<dyn BatteryInteraction>,
+    esp: ESP<'a>,
+    shift_register: ShiftRegister40<
+        PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+        PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+        PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+    >,
+    shift_register_enable_invert:
+        PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, esp_idf_hal::gpio::Output>,
+    tank_channel: AdcChannelDriver<'a, Gpio5, AdcDriver<'a, esp_idf_hal::adc::ADC1>>,
+    solar_is_day: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, esp_idf_hal::gpio::Input>,
+    light: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+    main_pump: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+    tank_power: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+    general_fault: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+    signal_counter: PcntDriver<'a>,
+    one_wire_bus: OneWire<PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>>,
+    rtc:
+        Ds323x<ds323x::interface::I2cInterface<MutexDevice<'a, I2cDriver<'a>>>, ds323x::ic::DS3231>,
+    eeprom: Eeprom24x<
+        MutexDevice<'a, I2cDriver<'a>>,
+        eeprom24x::page_size::B32,
+        eeprom24x::addr_size::TwoBytes,
+        eeprom24x::unique_serial::No,
+    >,
+}
+
+pub(crate) fn create_v3(peripherals: FreePeripherals, esp: ESP, config: PlantControllerConfig, battery_monitor: Box<dyn BatteryInteraction>) -> Result<Box<dyn BoardInteraction + '_>> {
+    let mut clock = PinDriver::input_output(peripherals.gpio15.downgrade())?;
+    clock.set_pull(Pull::Floating)?;
+    let mut latch = PinDriver::input_output(peripherals.gpio3.downgrade())?;
+    latch.set_pull(Pull::Floating)?;
+    let mut data = PinDriver::input_output(peripherals.gpio23.downgrade())?;
+    data.set_pull(Pull::Floating)?;
+    let shift_register = ShiftRegister40::new(clock, latch, data);
+    //disable all
+    for mut pin in shift_register.decompose() {
+        pin.set_low()?;
+    }
+
+    let awake = &mut shift_register.decompose()[AWAKE];
+    awake.set_high()?;
+
+    let charging = &mut shift_register.decompose()[CHARGING];
+    charging.set_high()?;
+
+    let ms0 = &mut shift_register.decompose()[MS_0];
+    ms0.set_low()?;
+    let ms1 = &mut shift_register.decompose()[MS_1];
+    ms1.set_low()?;
+    let ms2 = &mut shift_register.decompose()[MS_2];
+    ms2.set_low()?;
+    let ms3 = &mut shift_register.decompose()[MS_3];
+    ms3.set_low()?;
+
+    let ms4 = &mut shift_register.decompose()[MS_4];
+    ms4.set_high()?;
+
+    println!("Init battery driver");
+
+    println!("Init rtc driver");
+    let mut rtc = Ds323x::new_ds3231(MutexDevice::new(&I2C_DRIVER));
+
+    println!("Init rtc eeprom driver");
+    let mut eeprom = {
+        Eeprom24x::new_24x32(
+            MutexDevice::new(&I2C_DRIVER),
+            SlaveAddr::Alternative(true, true, true),
+        )
+    };
+
+    let mut one_wire_pin = PinDriver::input_output_od(peripherals.gpio18.downgrade())?;
+    one_wire_pin.set_pull(Pull::Floating)?;
+
+    let rtc_time = rtc.datetime();
+    match rtc_time {
+        OkStd(tt) => {
+            println!("Rtc Module reports time at UTC {}", tt);
+        }
+        Err(err) => {
+            println!("Rtc Module could not be read {:?}", err);
+        }
+    }
+    match eeprom.read_byte(0) {
+        OkStd(byte) => {
+            println!("Read first byte with status {}", byte);
+        }
+        Err(err) => {
+            println!("Eeprom could not read first byte {:?}", err);
+        }
+    }
+
+    let mut signal_counter = PcntDriver::new(
+        peripherals.pcnt0,
+        Some(peripherals.gpio22),
+        Option::<AnyInputPin>::None,
+        Option::<AnyInputPin>::None,
+        Option::<AnyInputPin>::None,
+    )?;
+
+    signal_counter.channel_config(
+        PcntChannel::Channel0,
+        PinIndex::Pin0,
+        PinIndex::Pin1,
+        &PcntChannelConfig {
+            lctrl_mode: PcntControlMode::Keep,
+            hctrl_mode: PcntControlMode::Keep,
+            pos_mode: PcntCountMode::Increment,
+            neg_mode: PcntCountMode::Hold,
+            counter_h_lim: i16::MAX,
+            counter_l_lim: 0,
+        },
+    )?;
+
+    let adc_config = AdcChannelConfig {
+        attenuation: attenuation::DB_11,
+        resolution: Resolution::Resolution12Bit,
+        calibration: esp_idf_hal::adc::oneshot::config::Calibration::Curve,
+    };
+    let tank_driver = AdcDriver::new(peripherals.adc1)?;
+    let tank_channel: AdcChannelDriver<Gpio5, AdcDriver<esp_idf_hal::adc::ADC1>> =
+        AdcChannelDriver::new(tank_driver, peripherals.gpio5, &adc_config)?;
+
+    let mut solar_is_day = PinDriver::input(peripherals.gpio7.downgrade())?;
+    solar_is_day.set_pull(Pull::Floating)?;
+
+    let mut light = PinDriver::input_output(peripherals.gpio10.downgrade())?;
+    light.set_pull(Pull::Floating)?;
+
+    let mut main_pump = PinDriver::input_output(peripherals.gpio2.downgrade())?;
+    main_pump.set_pull(Pull::Floating)?;
+    main_pump.set_low()?;
+    let mut tank_power = PinDriver::input_output(peripherals.gpio11.downgrade())?;
+    tank_power.set_pull(Pull::Floating)?;
+    let mut general_fault = PinDriver::input_output(peripherals.gpio6.downgrade())?;
+    general_fault.set_pull(Pull::Floating)?;
+    general_fault.set_low()?;
+
+    let one_wire_bus = OneWire::new(one_wire_pin)
+        .map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
+
+    let mut shift_register_enable_invert = PinDriver::output(peripherals.gpio21.downgrade())?;
+
+    unsafe { gpio_hold_dis(shift_register_enable_invert.pin()) };
+    shift_register_enable_invert.set_low()?;
+    unsafe { gpio_hold_en(shift_register_enable_invert.pin()) };
+
+    Ok(Box::new(V3 {
+        config,
+        battery_monitor,
+        esp,
+        shift_register,
+        shift_register_enable_invert,
+        tank_channel,
+        solar_is_day,
+        light,
+        main_pump,
+        tank_power,
+        general_fault,
+        signal_counter,
+        one_wire_bus,
+        rtc,
+        eeprom,
+    }))
+}
+
+impl BoardInteraction<'_> for V3<'_> {
+    fn get_esp(&mut self) -> &mut ESP<'static> {
+        &mut self.esp
+    }
+
+    fn get_config(&mut self) -> &PlantControllerConfig {
+        &self.config
+    }
+
+    fn get_battery_monitor(&mut self) -> &mut Box<(dyn BatteryInteraction + 'static)> {
+        &mut self.battery_monitor
+    }
+
+    fn set_charge_indicator(&mut self, charging: bool) -> Result<()> {
+        Ok(self.shift_register.decompose()[CHARGING].set_state(charging.into())?)
+    }
+
+    fn deep_sleep(&mut self, duration_in_ms: u64) -> ! {
+        let _ = self.shift_register.decompose()[AWAKE].set_low();
+        deep_sleep(duration_in_ms)
+    }
+
+    fn get_backup_info(&mut self) -> Result<BackupHeader> {
+        let store = bincode::serialize(&BackupHeader::default())?.len();
+        let mut header_page_buffer = vec![0_u8; store];
+
+        self.eeprom
+            .read_data(0, &mut header_page_buffer)
+            .map_err(|err| anyhow!("Error reading eeprom header {:?}", err))?;
+
+        println!("Raw header is {:?} with size {}", header_page_buffer, store);
+        let header: BackupHeader = bincode::deserialize(&header_page_buffer)?;
+        Ok(header)
+    }
+
+    fn get_backup_config(&mut self) -> Result<Vec<u8>> {
+        let store = bincode::serialize(&BackupHeader::default())?.len();
+        let mut header_page_buffer = vec![0_u8; store];
+
+        self.eeprom
+            .read_data(0, &mut header_page_buffer)
+            .map_err(|err| anyhow!("Error reading eeprom header {:?}", err))?;
+
+        let header: BackupHeader = bincode::deserialize(&header_page_buffer)?;
+
+        //skip page 0, used by the header
+        let data_start_address = self.eeprom.page_size() as u32;
+        let mut data_buffer = vec![0_u8; header.size];
+        self.eeprom
+            .read_data(data_start_address, &mut data_buffer)
+            .map_err(|err| anyhow!("Error reading eeprom data {:?}", err))?;
+
+        let checksum = X25.checksum(&data_buffer);
+        if checksum != header.crc16 {
+            bail!(
+                "Invalid checksum, got {} but expected {}",
+                checksum,
+                header.crc16
+            );
+        }
+
+        Ok(data_buffer)
+    }
+
+    fn backup_config(&mut self, bytes: &[u8]) -> Result<()> {
+        let time = self.get_rtc_time()?.timestamp_millis();
+
+        let delay = Delay::new_default();
+
+        let checksum = X25.checksum(bytes);
+        let page_size = self.eeprom.page_size();
+
+        let header = BackupHeader {
+            crc16: checksum,
+            timestamp: time,
+            size: bytes.len(),
+        };
+
+        let encoded = bincode::serialize(&header)?;
+        if encoded.len() > page_size {
+            bail!(
+                "Size limit reached header is {}, but firest page is only {}",
+                encoded.len(),
+                page_size
+            )
+        }
+        let as_u8: &[u8] = &encoded;
+
+        match self.eeprom.write_page(0, as_u8) {
+            OkStd(_) => {}
+            Err(err) => bail!("Error writing eeprom {:?}", err),
+        };
+        delay.delay_ms(5);
+
+        let to_write = bytes.chunks(page_size);
+
+        let mut lastiter = 0;
+        let mut current_page = 1;
+        for chunk in to_write {
+            let address = current_page * page_size as u32;
+            self.eeprom
+                .write_page(address, chunk)
+                .map_err(|err| anyhow!("Error writing eeprom {:?}", err))?;
+            current_page += 1;
+
+            let iter = (current_page % 8) as usize;
+            if iter != lastiter {
+                for i in 0..PLANT_COUNT {
+                    let _ = self.fault(i, iter == i);
+                }
+                lastiter = iter;
+            }
+
+            delay.delay_ms(5);
+        }
+        Ok(())
+    }
+
+    fn is_day(&self) -> bool {
+        self.solar_is_day.get_level().into()
+    }
+
+    fn water_temperature_c(&mut self) -> Result<f32> {
+        self.one_wire_bus
+            .reset(&mut self.esp.delay)
+            .map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
+        let first = self.one_wire_bus.devices(false, &mut self.esp.delay).next();
+        if first.is_none() {
+            bail!("Not found any one wire  Ds18b20");
+        }
+        let device_address = first
+            .unwrap()
+            .map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
+
+        let water_temp_sensor = Ds18b20::new::<EspError>(device_address)
+            .map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
+
+        water_temp_sensor
+            .start_temp_measurement(&mut self.one_wire_bus, &mut self.esp.delay)
+            .map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
+        ds18b20::Resolution::Bits12.delay_for_measurement_time(&mut self.esp.delay);
+        let sensor_data = water_temp_sensor
+            .read_data(&mut self.one_wire_bus, &mut self.esp.delay)
+            .map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
+        if sensor_data.temperature == 85_f32 {
+            bail!("Ds18b20 dummy temperature returned");
+        }
+        Ok(sensor_data.temperature / 10_f32)
+    }
+
+    fn tank_sensor_voltage(&mut self) -> Result<f32> {
+        self.tank_power.set_high()?;
+        //let stabilize
+        self.esp.delay.delay_ms(100);
+
+        let mut store = [0_u16; TANK_MULTI_SAMPLE];
+        for multisample in 0..TANK_MULTI_SAMPLE {
+            let value = self.tank_channel.read()?;
+            store[multisample] = value;
+        }
+        self.tank_power.set_low()?;
+
+        store.sort();
+        let median_mv = store[6] as f32 / 1000_f32;
+        Ok(median_mv)
+    }
+    fn light(&mut self, enable: bool) -> Result<()> {
+        unsafe { gpio_hold_dis(self.light.pin()) };
+        self.light.set_state(enable.into())?;
+        unsafe { gpio_hold_en(self.light.pin()) };
+        Ok(())
+    }
+
+    fn pump(&mut self, plant: usize, enable: bool) -> Result<()> {
+        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}",),
+        };
+        //currently infallible error, keep for future as result anyway
+        self.shift_register.decompose()[index].set_state(enable.into())?;
+
+        if !enable {
+            self.main_pump.set_low()?;
+        }
+        Ok(())
+    }
+
+    fn fault(&mut self, plant: usize, enable: bool) -> Result<()> {
+        let index = match plant {
+            0 => FAULT_1,
+            1 => FAULT_2,
+            2 => FAULT_3,
+            3 => FAULT_4,
+            4 => FAULT_5,
+            5 => FAULT_6,
+            6 => FAULT_7,
+            7 => FAULT_8,
+            _ => panic!("Invalid plant id {}", plant),
+        };
+        self.shift_register.decompose()[index].set_state(enable.into())?;
+        Ok(())
+    }
+
+    fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> Result<f32> {
+        let mut results = [0_f32; REPEAT_MOIST_MEASURE];
+        for repeat in 0..REPEAT_MOIST_MEASURE {
+            self.signal_counter.counter_pause()?;
+            self.signal_counter.counter_clear()?;
+            //Disable all
+            self.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 pin_0 = &mut self.shift_register.decompose()[MS_0];
+            let pin_1 = &mut self.shift_register.decompose()[MS_1];
+            let pin_2 = &mut self.shift_register.decompose()[MS_2];
+            let pin_3 = &mut self.shift_register.decompose()[MS_3];
+            if is_bit_set(0) {
+                pin_0.set_high()?;
+            } else {
+                pin_0.set_low()?;
+            }
+            if is_bit_set(1) {
+                pin_1.set_high()?;
+            } else {
+                pin_1.set_low()?;
+            }
+            if is_bit_set(2) {
+                pin_2.set_high()?;
+            } else {
+                pin_2.set_low()?;
+            }
+            if is_bit_set(3) {
+                pin_3.set_high()?;
+            } else {
+                pin_3.set_low()?;
+            }
+
+            self.shift_register.decompose()[MS_4].set_low()?;
+            self.shift_register.decompose()[SENSOR_ON].set_high()?;
+
+            let measurement = 100; // TODO what is this scaling factor? what is its purpose?
+            let factor = 1000f32 / measurement as f32;
+
+            //give some time to stabilize
+            self.esp.delay.delay_ms(10);
+            self.signal_counter.counter_resume()?;
+            self.esp.delay.delay_ms(measurement);
+            self.signal_counter.counter_pause()?;
+            self.shift_register.decompose()[MS_4].set_high()?;
+            self.shift_register.decompose()[SENSOR_ON].set_low()?;
+            self.esp.delay.delay_ms(10);
+            let unscaled = self.signal_counter.get_counter_value()? as i32;
+            let hz = unscaled as f32 * factor;
+            log(
+                LogMessage::RawMeasure,
+                unscaled as u32,
+                hz as u32,
+                &plant.to_string(),
+                &format!("{sensor:?}"),
+            );
+            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)
+    }
+
+    fn general_fault(&mut self, enable: bool) {
+        unsafe { gpio_hold_dis(self.general_fault.pin()) };
+        self.general_fault.set_state(enable.into()).unwrap();
+        unsafe { gpio_hold_en(self.general_fault.pin()) };
+    }
+
+    fn factory_reset(&mut self) -> Result<()> {
+        println!("factory resetting");
+        self.esp.delete_config()?;
+        //destroy backup header
+        let dummy: [u8; 0] = [];
+        self.backup_config(&dummy)?;
+        Ok(())
+    }
+
+    fn get_rtc_time(&mut self) -> Result<DateTime<Utc>> {
+        match self.rtc.datetime() {
+            OkStd(rtc_time) => Ok(rtc_time.and_utc()),
+            Err(err) => {
+                bail!("Error getting rtc time {:?}", err)
+            }
+        }
+    }
+
+    fn set_rtc_time(&mut self, time: &DateTime<Utc>) -> Result<()> {
+        let naive_time = time.naive_utc();
+        match self.rtc.set_datetime(&naive_time) {
+            OkStd(_) => Ok(()),
+            Err(err) => {
+                bail!("Error getting rtc time {:?}", err)
+            }
+        }
+    }
+
+    fn test_pump(&mut self, plant: usize) -> Result<()> {
+        self.pump(plant, true)?;
+        unsafe { vTaskDelay(30000) };
+        self.pump(plant, false)?;
+        Ok(())
+    }
+
+    fn test(&mut self) -> Result<()> {
+        self.general_fault(true);
+        self.esp.delay.delay_ms(100);
+        self.general_fault(false);
+        self.esp.delay.delay_ms(100);
+        self.light(true)?;
+        self.esp.delay.delay_ms(500);
+        self.light(false)?;
+        self.esp.delay.delay_ms(500);
+        for i in 0..PLANT_COUNT {
+            self.fault(i, true)?;
+            self.esp.delay.delay_ms(500);
+            self.fault(i, false)?;
+            self.esp.delay.delay_ms(500);
+        }
+        for i in 0..PLANT_COUNT {
+            self.pump(i, true)?;
+            self.esp.delay.delay_ms(100);
+            self.pump(i, false)?;
+            self.esp.delay.delay_ms(100);
+        }
+        for plant in 0..PLANT_COUNT {
+            let a = self.measure_moisture_hz(plant, Sensor::A);
+            let b = self.measure_moisture_hz(plant, Sensor::B);
+            let aa = match a {
+                OkStd(a) => a as u32,
+                Err(_) => u32::MAX,
+            };
+            let bb = match b {
+                OkStd(b) => b as u32,
+                Err(_) => u32::MAX,
+            };
+            log(LogMessage::TestSensor, aa, bb, &plant.to_string(), "");
+        }
+        self.esp.delay.delay_ms(10);
+        Ok(())
+    }
+}

rust/src/hal/v4_hal.rs

@@ -0,0 +1,530 @@
+use anyhow::{anyhow, bail};
+use chrono::{DateTime, Utc};
+use ds18b20::Ds18b20;
+use ds323x::{DateTimeAccess, Ds323x};
+use eeprom24x::{Eeprom24x, Eeprom24xTrait, SlaveAddr};
+use embedded_hal::digital::OutputPin;
+use embedded_hal_bus::i2c::MutexDevice;
+use esp_idf_hal::adc::oneshot::{AdcChannelDriver, AdcDriver};
+use esp_idf_hal::delay::Delay;
+use esp_idf_hal::gpio::{AnyInputPin, Gpio5, IOPin, InputOutput, Output, PinDriver, Pull};
+use esp_idf_hal::i2c::I2cDriver;
+use esp_idf_hal::pcnt::{PcntChannel, PcntChannelConfig, PcntControlMode, PcntCountMode, PcntDriver, PinIndex};
+use esp_idf_sys::{gpio_hold_dis, gpio_hold_en, vTaskDelay, EspError};
+use one_wire_bus::OneWire;
+use pca9535::{GPIOBank, Pca9535Immediate, StandardExpanderInterface};
+use crate::hal::{deep_sleep, BackupHeader, BoardInteraction, FreePeripherals, Sensor, I2C_DRIVER, PLANT_COUNT, REPEAT_MOIST_MEASURE, TANK_MULTI_SAMPLE, X25};
+use crate::hal::esp::ESP;
+use std::result::Result::Ok as OkStd;
+use esp_idf_hal::adc::{attenuation, Resolution};
+use esp_idf_hal::adc::oneshot::config::AdcChannelConfig;
+use crate::config::PlantControllerConfig;
+use crate::hal::battery::{BatteryInteraction, BatteryMonitor};
+use crate::log::{log, LogMessage};
+
+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 struct V4<'a> {
+    esp: ESP<'a>,
+    battery_monitor: Box<dyn BatteryInteraction>,
+    config: PlantControllerConfig,
+    tank_channel: AdcChannelDriver<'a, Gpio5, AdcDriver<'a, esp_idf_hal::adc::ADC1>>,
+    solar_is_day: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, esp_idf_hal::gpio::Input>,
+    signal_counter: PcntDriver<'a>,
+    charge_indicator: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+    awake: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, Output>,
+    light: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+    tank_power: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+    one_wire_bus: OneWire<PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>>,
+    rtc:
+        Ds323x<ds323x::interface::I2cInterface<MutexDevice<'a, I2cDriver<'a>>>, ds323x::ic::DS3231>,
+    eeprom: Eeprom24x<
+        MutexDevice<'a, I2cDriver<'a>>,
+        eeprom24x::page_size::B32,
+        eeprom24x::addr_size::TwoBytes,
+        eeprom24x::unique_serial::No,
+    >,
+    general_fault: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+    pump_expander: Pca9535Immediate<MutexDevice<'a, I2cDriver<'a>>>,
+    sensor_expander: Pca9535Immediate<MutexDevice<'a, I2cDriver<'a>>>,
+}
+
+
+pub(crate) fn create_v4(peripherals: FreePeripherals, esp:ESP, config:PlantControllerConfig, battery_monitor: Box<dyn BatteryInteraction>) -> anyhow::Result<Box<dyn BoardInteraction + '_>> {
+    let mut awake = PinDriver::output(peripherals.gpio15.downgrade())?;
+    awake.set_high()?;
+
+    let mut general_fault = PinDriver::input_output(peripherals.gpio6.downgrade())?;
+    general_fault.set_pull(Pull::Floating)?;
+    general_fault.set_low()?;
+
+    println!("Init rtc driver");
+    let mut rtc = Ds323x::new_ds3231(MutexDevice::new(&I2C_DRIVER));
+
+    println!("Init rtc eeprom driver");
+    let mut eeprom = {
+        Eeprom24x::new_24x32(
+            MutexDevice::new(&I2C_DRIVER),
+            SlaveAddr::Alternative(true, true, true),
+        )
+    };
+
+    let mut one_wire_pin = PinDriver::input_output_od(peripherals.gpio18.downgrade())?;
+    one_wire_pin.set_pull(Pull::Floating)?;
+
+    let one_wire_bus = OneWire::new(one_wire_pin)
+        .map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
+
+    let rtc_time = rtc.datetime();
+    match rtc_time {
+        OkStd(tt) => {
+            println!("Rtc Module reports time at UTC {}", tt);
+        }
+        Err(err) => {
+            println!("Rtc Module could not be read {:?}", err);
+        }
+    }
+    match eeprom.read_byte(0) {
+        OkStd(byte) => {
+            println!("Read first byte with status {}", byte);
+        }
+        Err(err) => {
+            println!("Eeprom could not read first byte {:?}", err);
+        }
+    }
+
+    let mut signal_counter = PcntDriver::new(
+        peripherals.pcnt0,
+        Some(peripherals.gpio22),
+        Option::<AnyInputPin>::None,
+        Option::<AnyInputPin>::None,
+        Option::<AnyInputPin>::None,
+    )?;
+
+    signal_counter.channel_config(
+        PcntChannel::Channel0,
+        PinIndex::Pin0,
+        PinIndex::Pin1,
+        &PcntChannelConfig {
+            lctrl_mode: PcntControlMode::Keep,
+            hctrl_mode: PcntControlMode::Keep,
+            pos_mode: PcntCountMode::Increment,
+            neg_mode: PcntCountMode::Hold,
+            counter_h_lim: i16::MAX,
+            counter_l_lim: 0,
+        },
+    )?;
+
+    let adc_config = AdcChannelConfig {
+        attenuation: attenuation::DB_11,
+        resolution: Resolution::Resolution12Bit,
+        calibration: esp_idf_hal::adc::oneshot::config::Calibration::Curve,
+    };
+    let tank_driver = AdcDriver::new(peripherals.adc1)?;
+    let tank_channel: AdcChannelDriver<Gpio5, AdcDriver<esp_idf_hal::adc::ADC1>> =
+        AdcChannelDriver::new(tank_driver, peripherals.gpio5, &adc_config)?;
+
+    let mut solar_is_day = PinDriver::input(peripherals.gpio7.downgrade())?;
+    solar_is_day.set_pull(Pull::Floating)?;
+
+    let mut light = PinDriver::input_output(peripherals.gpio10.downgrade())?;
+    light.set_pull(Pull::Floating)?;
+
+    let mut tank_power = PinDriver::input_output(peripherals.gpio11.downgrade())?;
+    tank_power.set_pull(Pull::Floating)?;
+
+    let mut charge_indicator = PinDriver::input_output(peripherals.gpio3.downgrade())?;
+    charge_indicator.set_pull(Pull::Floating)?;
+    charge_indicator.set_low()?;
+
+    let mut pump_expander = Pca9535Immediate::new(MutexDevice::new(&I2C_DRIVER), 32);
+
+    //todo error handing if init error
+    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 mut sensor_expander = Pca9535Immediate::new(MutexDevice::new(&I2C_DRIVER), 34);
+    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);
+    }
+
+    let v = V4 {
+        esp,
+        awake,
+        tank_channel,
+        solar_is_day,
+        signal_counter,
+        light,
+        tank_power,
+        one_wire_bus,
+        rtc,
+        eeprom,
+        general_fault,
+        pump_expander,
+        sensor_expander,
+        charge_indicator,
+        config,
+        battery_monitor,
+    };
+    Ok(Box::new(v))
+}
+
+impl BoardInteraction<'_> for V4<'_> {
+    fn get_esp(&mut self) -> &mut ESP<'_> {
+        &mut self.esp
+    }
+
+    fn get_config(&mut self) -> &PlantControllerConfig {
+        &self.config
+    }
+
+    fn get_battery_monitor(&mut self) -> &mut Box<dyn BatteryInteraction> {
+        &mut self.battery_monitor
+    }
+
+    fn set_charge_indicator(&mut self, charging: bool) -> anyhow::Result<()> {
+        self.charge_indicator.set_state(charging.into()).expect("cannot fail");
+        Ok(())
+    }
+
+    fn deep_sleep(&mut self, duration_in_ms: u64) -> ! {
+        self.awake.set_low().unwrap();
+        deep_sleep(duration_in_ms);
+    }
+
+    fn get_backup_info(&mut self) -> anyhow::Result<BackupHeader> {
+        let store = bincode::serialize(&BackupHeader::default())?.len();
+        let mut header_page_buffer = vec![0_u8; store];
+
+        self.eeprom
+            .read_data(0, &mut header_page_buffer)
+            .map_err(|err| anyhow!("Error reading eeprom header {:?}", err))?;
+
+        println!("Raw header is {:?} with size {}", header_page_buffer, store);
+        let header: BackupHeader = bincode::deserialize(&header_page_buffer)?;
+        anyhow::Ok(header)
+    }
+
+    fn get_backup_config(&mut self) -> anyhow::Result<Vec<u8>> {
+        let store = bincode::serialize(&BackupHeader::default())?.len();
+        let mut header_page_buffer = vec![0_u8; store];
+
+        self.eeprom
+            .read_data(0, &mut header_page_buffer)
+            .map_err(|err| anyhow!("Error reading eeprom header {:?}", err))?;
+
+        let header: BackupHeader = bincode::deserialize(&header_page_buffer)?;
+
+        //skip page 0, used by the header
+        let data_start_address = self.eeprom.page_size() as u32;
+        let mut data_buffer = vec![0_u8; header.size];
+        self.eeprom
+            .read_data(data_start_address, &mut data_buffer)
+            .map_err(|err| anyhow!("Error reading eeprom data {:?}", err))?;
+
+        let checksum = X25.checksum(&data_buffer);
+        if checksum != header.crc16 {
+            bail!(
+                "Invalid checksum, got {} but expected {}",
+                checksum,
+                header.crc16
+            );
+        }
+
+        anyhow::Ok(data_buffer)
+    }
+
+    fn backup_config(&mut self, bytes: &[u8]) -> anyhow::Result<()> {
+        let time = self.get_rtc_time()?.timestamp_millis();
+
+        let delay = Delay::new_default();
+
+        let checksum = X25.checksum(bytes);
+        let page_size = self.eeprom.page_size();
+
+        let header = BackupHeader {
+            crc16: checksum,
+            timestamp: time,
+            size: bytes.len(),
+        };
+
+        let encoded = bincode::serialize(&header)?;
+        if encoded.len() > page_size {
+            bail!(
+                "Size limit reached header is {}, but firest page is only {}",
+                encoded.len(),
+                page_size
+            )
+        }
+        let as_u8: &[u8] = &encoded;
+
+        match self.eeprom.write_page(0, as_u8) {
+            OkStd(_) => {}
+            Err(err) => bail!("Error writing eeprom {:?}", err),
+        };
+        delay.delay_ms(5);
+
+        let to_write = bytes.chunks(page_size);
+
+        let mut lastiter = 0;
+        let mut current_page = 1;
+        for chunk in to_write {
+            let address = current_page * page_size as u32;
+            self.eeprom
+                .write_page(address, chunk)
+                .map_err(|err| anyhow!("Error writing eeprom {:?}", err))?;
+            current_page += 1;
+
+            let iter = (current_page % 8) as usize;
+            if iter != lastiter {
+                for i in 0..PLANT_COUNT {
+                    let _ = self.fault(i, iter == i);
+                }
+                lastiter = iter;
+            }
+
+            delay.delay_ms(5);
+        }
+        anyhow::Ok(())
+    }
+
+    fn is_day(&self) -> bool {
+        self.solar_is_day.get_level().into()
+    }
+
+    fn water_temperature_c(&mut self) -> anyhow::Result<f32> {
+        self.one_wire_bus
+            .reset(&mut self.esp.delay)
+            .map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
+        let first = self.one_wire_bus.devices(false, &mut self.esp.delay).next();
+        if first.is_none() {
+            bail!("Not found any one wire  Ds18b20");
+        }
+        let device_address = first
+            .unwrap()
+            .map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
+
+        let water_temp_sensor = Ds18b20::new::<EspError>(device_address)
+            .map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
+
+        water_temp_sensor
+            .start_temp_measurement(&mut self.one_wire_bus, &mut self.esp.delay)
+            .map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
+        ds18b20::Resolution::Bits12.delay_for_measurement_time(&mut self.esp.delay);
+        let sensor_data = water_temp_sensor
+            .read_data(&mut self.one_wire_bus, &mut self.esp.delay)
+            .map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
+        if sensor_data.temperature == 85_f32 {
+            bail!("Ds18b20 dummy temperature returned");
+        }
+        anyhow::Ok(sensor_data.temperature / 10_f32)
+    }
+
+    fn tank_sensor_voltage(&mut self) -> anyhow::Result<f32> {
+        self.tank_power.set_high()?;
+        //let stabilize
+        self.esp.delay.delay_ms(100);
+
+        let mut store = [0_u16; TANK_MULTI_SAMPLE];
+        for multisample in 0..TANK_MULTI_SAMPLE {
+            let value = self.tank_channel.read()?;
+            store[multisample] = value;
+        }
+        self.tank_power.set_low()?;
+
+        store.sort();
+        let median_mv = store[6] as f32 / 1000_f32;
+        anyhow::Ok(median_mv)
+    }
+
+    fn light(&mut self, enable: bool) -> anyhow::Result<()> {
+        unsafe { gpio_hold_dis(self.light.pin()) };
+        self.light.set_state(enable.into())?;
+        unsafe { gpio_hold_en(self.light.pin()) };
+        anyhow::Ok(())
+    }
+
+    fn pump(&mut self, plant: usize, enable: bool) -> anyhow::Result<()> {
+        if enable {
+            self.pump_expander.pin_set_high(GPIOBank::Bank0, plant.try_into()?)?;
+        } else {
+            self.pump_expander.pin_set_low(GPIOBank::Bank0, plant.try_into()?)?;
+        }
+        anyhow::Ok(())
+    }
+
+    fn fault(&mut self, plant: usize, enable: bool) -> anyhow::Result<()> {
+        if enable {
+            self.pump_expander.pin_set_high(GPIOBank::Bank1, plant.try_into()?)?
+        } else {
+            self.pump_expander.pin_set_low(GPIOBank::Bank1, plant.try_into()?)?
+        }
+        anyhow::Ok(())
+    }
+
+    fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> anyhow::Result<f32> {
+        let mut results = [0_f32; REPEAT_MOIST_MEASURE];
+        for repeat in 0..REPEAT_MOIST_MEASURE {
+            self.signal_counter.counter_pause()?;
+            self.signal_counter.counter_clear()?;
+
+
+            //Disable all
+            self.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) {
+                self.sensor_expander.pin_set_high(GPIOBank::Bank0, MS0)?;
+            } else {
+                self.sensor_expander.pin_set_low(GPIOBank::Bank0, MS0)?;
+            }
+            if is_bit_set(1) {
+                self.sensor_expander.pin_set_high(GPIOBank::Bank0, MS1)?;
+            } else {
+                self.sensor_expander.pin_set_low(GPIOBank::Bank0, MS1)?;
+            }
+            if is_bit_set(2) {
+                self.sensor_expander.pin_set_high(GPIOBank::Bank0, MS2)?;
+            } else {
+                self.sensor_expander.pin_set_low(GPIOBank::Bank0, MS2)?;
+            }
+            if is_bit_set(3) {
+                self.sensor_expander.pin_set_high(GPIOBank::Bank0, MS3)?;
+            } else {
+                self.sensor_expander.pin_set_low(GPIOBank::Bank0, MS3)?;
+            }
+
+            self.sensor_expander.pin_set_low(GPIOBank::Bank0, MS4)?;
+            self.sensor_expander.pin_set_high(GPIOBank::Bank0, SENSOR_ON)?;
+
+            let delay = Delay::new_default();
+            let measurement = 100; // TODO what is this scaling factor? what is its purpose?
+            let factor = 1000f32 / measurement as f32;
+
+            //give some time to stabilize
+            delay.delay_ms(10);
+            self.signal_counter.counter_resume()?;
+            delay.delay_ms(measurement);
+            self.signal_counter.counter_pause()?;
+            self.sensor_expander.pin_set_high(GPIOBank::Bank0, MS4)?;
+            self.sensor_expander.pin_set_low(GPIOBank::Bank0, SENSOR_ON)?;
+            self.sensor_expander.pin_set_low(GPIOBank::Bank0, MS0)?;
+            self.sensor_expander.pin_set_low(GPIOBank::Bank0, MS1)?;
+            self.sensor_expander.pin_set_low(GPIOBank::Bank0, MS2)?;
+            self.sensor_expander.pin_set_low(GPIOBank::Bank0, MS3)?;
+            delay.delay_ms(10);
+            let unscaled = self.signal_counter.get_counter_value()? as i32;
+            let hz = unscaled as f32 * factor;
+            log(
+                LogMessage::RawMeasure,
+                unscaled as u32,
+                hz as u32,
+                &plant.to_string(),
+                &format!("{sensor:?}"),
+            );
+            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];
+        anyhow::Ok(median)
+    }
+
+    fn general_fault(&mut self, enable: bool) {
+        unsafe { gpio_hold_dis(self.general_fault.pin()) };
+        self.general_fault.set_state(enable.into()).unwrap();
+        unsafe { gpio_hold_en(self.general_fault.pin()) };
+    }
+
+    fn factory_reset(&mut self) -> anyhow::Result<()> {
+        println!("factory resetting");
+        self.esp.delete_config()?;
+        //destroy backup header
+        let dummy: [u8; 0] = [];
+        self.backup_config(&dummy)?;
+
+        anyhow::Ok(())
+    }
+
+    fn get_rtc_time(&mut self) -> anyhow::Result<DateTime<Utc>> {
+        match self.rtc.datetime() {
+            OkStd(rtc_time) => anyhow::Ok(rtc_time.and_utc()),
+            Err(err) => {
+                bail!("Error getting rtc time {:?}", err)
+            }
+        }
+    }
+
+    fn set_rtc_time(&mut self, time: &DateTime<Utc>) -> anyhow::Result<()> {
+        let naive_time = time.naive_utc();
+        match self.rtc.set_datetime(&naive_time) {
+            OkStd(_) => anyhow::Ok(()),
+            Err(err) => {
+                bail!("Error getting rtc time {:?}", err)
+            }
+        }
+    }
+
+    fn test_pump(&mut self, plant: usize) -> anyhow::Result<()> {
+        self.pump(plant, true)?;
+        self.esp.delay.delay_ms(30000);
+        self.pump(plant, false)?;
+        anyhow::Ok(())
+    }
+
+    fn test(&mut self) -> anyhow::Result<()> {
+        self.general_fault(true);
+        self.esp.delay.delay_ms(100);
+        self.general_fault(false);
+        self.esp.delay.delay_ms(500);
+        self.light(true)?;
+        self.esp.delay.delay_ms(500);
+        self.light(false)?;
+        self.esp.delay.delay_ms(500);
+        for i in 0..PLANT_COUNT {
+            self.fault(i, true)?;
+            self.esp.delay.delay_ms(500);
+            self.fault(i, false)?;
+            self.esp.delay.delay_ms(500);
+        }
+        for i in 0..PLANT_COUNT {
+            self.pump(i, true)?;
+            self.esp.delay.delay_ms(100);
+            self.pump(i, false)?;
+            self.esp.delay.delay_ms(100);
+        }
+        for plant in 0..PLANT_COUNT {
+            let a = self.measure_moisture_hz(plant, Sensor::A);
+            let b = self.measure_moisture_hz(plant, Sensor::B);
+            let aa = match a {
+                OkStd(a) => a as u32,
+                Err(_) => u32::MAX,
+            };
+            let bb = match b {
+                OkStd(b) => b as u32,
+                Err(_) => u32::MAX,
+            };
+            log(LogMessage::TestSensor, aa, bb, &plant.to_string(), "");
+        }
+        self.esp.delay.delay_ms(10);
+        anyhow::Ok(())
+    }
+}