PlantCtrl/rust/src/hal/water.rs

use crate::bail;
use crate::FatError::FatError;
use embassy_time::Timer;
use esp_hal::delay::Delay;
use esp_hal::gpio::{Flex, OutputConfig, Pull};
use esp_println::println;
use onewire::{ds18b20, Device, DeviceSearch, OneWire, DS18B20};

pub struct TankSensor<'a> {
    one_wire_bus: OneWire<Flex<'a>>,
    // tank_channel: AdcChannelDriver<'a, Gpio5, AdcDriver<'a, ADC1>>,
    // tank_power: PinDriver<'a, AnyIOPin, InputOutput>,
    // flow_counter: PcntDriver<'a>,
    // delay: Delay,
}

impl<'a> TankSensor<'a> {
    pub(crate) fn create(
        mut one_wire_pin: Flex,
        // adc1: ADC1,
        // gpio5: Gpio5,
        // tank_power_pin: AnyIOPin,
        // flow_sensor_pin: AnyIOPin,
        // pcnt1: PCNT1,
    ) -> Result<TankSensor, FatError> {
        one_wire_pin.apply_output_config(&OutputConfig::default().with_pull(Pull::None));

        // 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(adc1).expect("Failed to configure ADC");
        // let tank_channel = AdcChannelDriver::new(tank_driver, gpio5, &adc_config)
        //     .expect("Failed to configure ADC channel");
        //
        // let mut tank_power =
        //     PinDriver::input_output(tank_power_pin).expect("Failed to configure pin");
        // tank_power
        //     .set_pull(Pull::Floating)
        //     .expect("Failed to set pull");
        //

        let one_wire_bus = OneWire::new(one_wire_pin, false);

        //
        // let mut flow_counter = PcntDriver::new(
        //     pcnt1,
        //     Some(flow_sensor_pin),
        //     Option::<AnyInputPin>::None,
        //     Option::<AnyInputPin>::None,
        //     Option::<AnyInputPin>::None,
        // )?;
        //
        // flow_counter.channel_config(
        //     PcntChannel::Channel1,
        //     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,
        //     },
        // )?;
        //
        Ok(TankSensor {
            one_wire_bus,
            //     tank_channel,
            //     tank_power,
            //     flow_counter,
            //     delay: Default::default(),
        })
    }

    pub fn reset_flow_meter(&mut self) {
        // self.flow_counter.counter_pause().unwrap();
        // self.flow_counter.counter_clear().unwrap();
    }

    pub fn start_flow_meter(&mut self) {
        //self.flow_counter.counter_resume().unwrap();
    }

    pub fn get_flow_meter_value(&mut self) -> i16 {
        //self.flow_counter.get_counter_value().unwrap()
        5_i16
    }

    pub fn stop_flow_meter(&mut self) -> i16 {
        //self.flow_counter.counter_pause().unwrap();
        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
        // self.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;
        let median_mv = 10_f32;
        Ok(median_mv)
    }
}