C3MA/PlantCtrl
5
0
Fork 0
Code Issues 8 Pull Requests Packages Projects Releases Wiki Activity

remove anyhow

Browse Source
This commit is contained in:
Empire Phoenix
2025-09-22 01:49:25 +02:00
parent c94f5bdb45
commit 1791f463b7
21 changed files with 2268 additions and 1982 deletions
Download Patch File Download Diff File Expand all files Collapse all files

426
rust/src/hal/v4_hal.rs Normal file
View File

@@ -0,0 +1,426 @@
use crate::config::PlantControllerConfig;
use crate::hal::battery::BatteryInteraction;
use crate::hal::esp::Esp;
use crate::hal::rtc::RTCModuleInteraction;
use crate::hal::water::TankSensor;
use crate::hal::{BoardInteraction, FreePeripherals, Sensor};
use alloc::boxed::Box;
use async_trait::async_trait;
//use embedded_hal_bus::i2c::MutexDevice;
use crate::bail;
use crate::FatError::FatError;
use esp_hal::gpio::{Flex, Level, Output, OutputConfig};
use measurements::{Current, Voltage};
// pub enum Charger<'a> {
// SolarMpptV1 {
// mppt_ina: SyncIna219<MutexDevice<'a, I2cDriver<'a>>, UnCalibrated>,
// solar_is_day: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, esp_idf_hal::gpio::Input>,
// charge_indicator: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
// },
// ErrorInit {},
// }
//
// 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) -> anyhow::Result<()> {
// match self {
// Self::SolarMpptV1 {
// charge_indicator, ..
// } => {
// charge_indicator.set_state(charging.into())?;
// }
// _ => {}
// }
// Ok(())
// }
//
// fn is_day(&self) -> bool {
// match self {
// Charger::SolarMpptV1 { solar_is_day, .. } => solar_is_day.get_level().into(),
// _ => true,
// }
// }
//
// fn get_mptt_voltage(&mut self) -> anyhow::Result<Voltage> {
// let voltage = match self {
// Charger::SolarMpptV1 { mppt_ina, .. } => mppt_ina
// .bus_voltage()
// .map(|v| Voltage::from_millivolts(v.voltage_mv() as f64))?,
// _ => {
// bail!("hardware error during init")
// }
// };
// Ok(voltage)
// }
//
// fn get_mptt_current(&mut self) -> anyhow::Result<Current> {
// let current = match self {
// Charger::SolarMpptV1 { mppt_ina, .. } => mppt_ina.shunt_voltage().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)
// })?,
// _ => {
// bail!("hardware error during init")
// }
// };
// Ok(current)
// }
// }
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<MutexDevice<'a, I2cDriver<'a>>>,
//pump_ina: Option<SyncIna219<MutexDevice<'a, I2cDriver<'a>>, UnCalibrated>>,
//sensor: SensorImpl<'a>,
extra1: Output<'a>,
extra2: Output<'a>,
}
struct InputOutput<'a> {
pin: Flex<'a>,
}
pub(crate) 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 mut extra1 = Output::new(peripherals.gpio6, Level::Low, OutputConfig::default());
let mut extra2 = Output::new(peripherals.gpio15, Level::Low, OutputConfig::default());
let one_wire_pin = Flex::new(peripherals.gpio18);
let tank_power_pin = peripherals.gpio11;
let flow_sensor_pin = peripherals.gpio4;
let tank_sensor = TankSensor::create(
one_wire_pin,
//peripherals.adc1,
//peripherals.gpio5,
//tank_power_pin,
//flow_sensor_pin,
//peripherals.pcnt1,
)?;
//
// let mut sensor_expander = Pca9535Immediate::new(MutexDevice::new(&I2C_DRIVER), 34);
// let sensor = match sensor_expander.pin_into_output(GPIOBank::Bank0, 0) {
// Ok(_) => {
// log::info!("SensorExpander answered");
// //pulse counter version
// 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,
// },
// )?;
//
// 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 timing = can::config::Timing::B25K;
// let config = can::config::Config::new().timing(timing);
// let can = can::CanDriver::new(
// peripherals.can,
// peripherals.gpio0,
// peripherals.gpio2,
// &config,
// )
// .unwrap();
//
// let frame = StandardId::new(0x042).unwrap();
// let tx_frame = Frame::new(frame, &[0, 1, 2, 3, 4, 5, 6, 7]).unwrap();
// can.transmit(&tx_frame, 1000).unwrap();
//
// if let Ok(rx_frame) = can.receive(1000) {
// log::info!("rx {:}:", rx_frame);
// }
// //can bus version
// SensorImpl::CanBus { can }
// }
// };
let mut solar_is_day = Output::new(peripherals.gpio7, Level::Low, Default::default());
let mut light = Output::new(peripherals.gpio10, Level::Low, Default::default());
let mut charge_indicator = Output::new(peripherals.gpio3, Level::Low, Default::default());
// let mut pump_expander = Pca9535Immediate::new(MutexDevice::new(&I2C_DRIVER), 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_ina = SyncIna219::new(
// MutexDevice::new(&I2C_DRIVER),
// Address::from_pins(Pin::Vcc, Pin::Gnd),
// );
//
// let charger = match mppt_ina {
// Ok(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,
// }
// }
// Err(_) => Charger::ErrorInit {},
// };
//
// let pump_ina = match SyncIna219::new(
// MutexDevice::new(&I2C_DRIVER),
// Address::from_pins(Pin::Gnd, Pin::Sda),
// ) {
// Ok(pump_ina) => Some(pump_ina),
// Err(err) => {
// log::info!("Error creating pump ina: {:?}", err);
// None
// }
// };
let v = V4 {
rtc_module,
esp,
awake,
tank_sensor,
light,
general_fault,
//pump_ina,
//pump_expander,
config,
battery_monitor,
//charger,
extra1,
extra2,
//sensor,
};
Ok(Box::new(v))
}
#[async_trait]
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
}
fn set_charge_indicator(&mut self, charging: bool) -> Result<(), FatError> {
bail!("not implemented");
// self.charger.set_charge_indicator(charging)
}
async fn deep_sleep(&mut self, duration_in_ms: u64) -> ! {
self.awake.set_low();
//self.charger.power_save();
self.esp.deep_sleep(duration_in_ms).await;
}
fn is_day(&self) -> bool {
false
//self.charger.is_day()
}
fn light(&mut self, enable: bool) -> Result<(), FatError> {
bail!("not implemented");
// unsafe { gpio_hold_dis(self.light.pin()) };
// self.light.set_state(enable.into())?;
// unsafe { gpio_hold_en(self.light.pin()) };
// anyhow::Ok(())
}
async fn pump(&mut self, plant: usize, enable: bool) -> Result<(), FatError> {
bail!("not implemented");
// 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(())
}
async fn pump_current(&mut self, _plant: usize) -> Result<Current, FatError> {
bail!("not implemented");
// //sensore 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(|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) -> Result<(), FatError> {
bail!("not implemented");
// 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(())
}
async fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> Result<f32, FatError> {
bail!("not implemented");
//self.sensor.measure_moisture_hz(plant, sensor)
}
async fn general_fault(&mut self, enable: bool) {
//FIXME unsafe { gpio_hold_dis(self.general_fault.pin()) };
self.general_fault.set_level(enable.into());
//FIXME unsafe { gpio_hold_en(self.general_fault.pin()) };
}
async fn test(&mut self) -> Result<(), FatError> {
// 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);
Ok(())
}
fn set_config(&mut self, config: PlantControllerConfig) {
self.config = config;
}
async fn get_mptt_voltage(&mut self) -> Result<Voltage, FatError> {
bail!("not implemented");
//self.charger.get_mptt_voltage()
}
async fn get_mptt_current(&mut self) -> Result<Current, FatError> {
bail!("not implemented");
//self.charger.get_mptt_current()
}
}