PlantCtrl/rust/src/hal/initial_hal.rs

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, Sensor};
use crate::{
    bail,
    config::PlantControllerConfig,
    hal::battery::{BatteryInteraction, NoBatteryMonitor},
};
use async_trait::async_trait;
use chrono::{DateTime, FixedOffset, 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]
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]
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 get_time(&mut self) -> DateTime<Utc> {
        self.esp.get_time()
    }

    async fn set_time(&mut self, time: &DateTime<FixedOffset>) -> FatResult<()> {
        self.rtc.set_rtc_time(&time.to_utc()).await?;
        self.esp.set_time(time.to_utc());
        Ok(())
    }

    async fn set_charge_indicator(&mut self, _charging: bool) -> Result<(), FatError> {
        bail!("Please configure board revision")
    }

    async fn deep_sleep_ms(&mut self, duration_in_ms: u64) -> ! {
        self.esp.deep_sleep_ms(duration_in_ms);
    }
    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,
        _plant: usize,
        _sensor: Sensor,
    ) -> Result<f32, 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")
    }
}