splitting wip

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(())
+    }
+}