C3MA/PlantCtrl
4
0
Fork 0
Code Issues 7 Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: C3MA:bbbe6d846f20210eb5222eb2a323d64ecb9fdacd
Branches Tags
C3MA:develop
C3MA:feature/v4_modular
C3MA:refactor/plant-state-handling
C3MA:ollo-dev
C3MA:v2.x
C3MA:v1.x
C3MA:V3.0_first_run
C3MA:0.7-final
C3MA:0.9-final
..
compare: C3MA:7f8aec789c5d9702d988a060a8d96ecc57545dec
Branches Tags
C3MA:feature/v4_modular
C3MA:refactor/plant-state-handling
C3MA:develop
C3MA:ollo-dev
C3MA:v2.x
C3MA:v1.x
C3MA:V3.0_first_run
C3MA:0.7-final
C3MA:0.9-final

No commits in common. "bbbe6d846f20210eb5222eb2a323d64ecb9fdacd" and "7f8aec789c5d9702d988a060a8d96ecc57545dec" have entirely different histories.
bbbe6d846f ... 7f8aec789c

3 changed files with 85 additions and 124 deletions
Show Stats Expand all files Collapse all files

90
rust/src/main.rs
View File

@ -401,32 +401,41 @@ fn safe_main() -> anyhow::Result<()> {
let dry_run = false;
let tank_state = determine_tank_state(&mut board, &config);
let mut tank_state_mqtt = TankStateMQTT {
enough_water: tank_state.enough_water,
left_ml: tank_state.left_ml,
warn_level: tank_state.warn_level,
sensor_error: tank_state.sensor_error,
raw: tank_state.raw,
water_frozen: "".to_owned(),
};
let mut water_frozen = false;
let mut attempt = 1;
let water_temp: Result<f32, anyhow::Error> = loop {
let temp = board.water_temperature_c();
match &temp {
let mut temp: Option<f32> = None;
for _attempt in 0..5 {
let water_temperature = board.water_temperature_c();
match water_temperature {
Ok(res) => {
println!("Water temp is {}", res);
break temp
temp = Some(res);
break;
}
Err(err) => {
println!("Could not get water temp {} attempt {}", err, attempt)
println!("Could not get water temp {} attempt {}", err, _attempt)
}
}
if attempt == 5 {
break temp
}
attempt += 1;
};
if let Ok(res) = water_temp {
if res < WATER_FROZEN_THRESH {
water_frozen = true;
}
match temp {
Some(res) => {
println!("Water temp is {}", res);
if res < 4_f32 {
water_frozen = true;
}
tank_state_mqtt.water_frozen = water_frozen.to_string();
}
None => tank_state_mqtt.water_frozen = "tank sensor error".to_owned(),
}
match serde_json::to_string(&tank_state.as_mqtt_info(&config.tank, water_temp)) {
match serde_json::to_string(&tank_state_mqtt) {
Ok(state) => {
let _ = board.mqtt_publish(&config, "/water", state.as_bytes());
}
@ -602,7 +611,7 @@ fn determine_state_target_moisture_for_plant(
plant: usize,
state: &mut PlantState,
config: &PlantControllerConfig,
tank_state: &TankState,
tank_state: &TankInfo,
cur: DateTime<Tz>,
) {
let plant_config = &config.plants[plant];
@ -648,17 +657,10 @@ fn determine_state_target_moisture_for_plant(
if a_low || b_low {
state.dry = true;
match tank_state.enough_water(&config.tank) {
Err(_tank_err) => {
if !config.tank.tank_allow_pumping_if_sensor_error {
// ignore is ok
// wtf does this meen, shouldn't something happen if the configuration specifies
// that no water should flow if there was an error?
}
},
Ok(enough_water) => {
state.no_water = !enough_water
},
if tank_state.sensor_error && !config.tank.tank_allow_pumping_if_sensor_error {
//ignore is ok
} else if !tank_state.enough_water {
state.no_water = true;
}
}
let duration = TimeDelta::try_minutes(plant_config.pump_cooldown_min as i64).unwrap();
@ -699,7 +701,7 @@ fn determine_state_timer_only_for_plant(
plant: usize,
state: &mut PlantState,
config: &PlantControllerConfig,
tank_state: &TankState,
tank_state: &TankInfo,
cur: DateTime<Tz>,
) {
let plant_config = &config.plants[plant];
@ -714,15 +716,10 @@ fn determine_state_timer_only_for_plant(
state.next_pump = Some(europe_time);
state.cooldown = true;
} else {
match tank_state.enough_water(&config.tank) {
Err(_tank_err) => {
if !config.tank.tank_allow_pumping_if_sensor_error {
state.do_water = true;
}
},
Ok(enough_water) => {
state.no_water = !enough_water;
},
if tank_state.sensor_error && !config.tank.tank_allow_pumping_if_sensor_error {
state.do_water = true;
} else if !tank_state.enough_water {
state.no_water = true;
}
}
}
@ -742,7 +739,7 @@ fn determine_state_timer_and_deadzone_for_plant(
plant: usize,
state: &mut PlantState,
config: &PlantControllerConfig,
tank_state: &TankState,
tank_state: &TankInfo,
cur: DateTime<Tz>,
) {
let plant_config = &config.plants[plant];
@ -765,15 +762,10 @@ fn determine_state_timer_and_deadzone_for_plant(
state.out_of_work_hour = true;
}
if !state.cooldown && !state.out_of_work_hour {
match tank_state.enough_water(&config.tank) {
Err(_tank_err) => {
if !config.tank.tank_allow_pumping_if_sensor_error {
state.do_water = true;
}
},
Ok(enough_water) => {
state.no_water = !enough_water;
},
if tank_state.sensor_error && !config.tank.tank_allow_pumping_if_sensor_error {
state.do_water = true;
} else if !tank_state.enough_water {
state.no_water = true;
}
}
}
@ -791,7 +783,7 @@ fn determine_state_timer_and_deadzone_for_plant(
fn determine_plant_state(
plantstate: &mut [PlantState; PLANT_COUNT],
cur: DateTime<Tz>,
tank_state: &TankState,
tank_state: &TankInfo,
config: &PlantControllerConfig,
board: &mut std::sync::MutexGuard<'_, PlantCtrlBoard<'_>>,
) {

2
rust/src/plant_hal.rs
View File

@ -472,7 +472,7 @@ impl PlantCtrlBoard<'_> {
}
/// return median tank sensor value in milli volt
pub fn tank_sensor_voltage(&mut self) -> Result<f32> {
pub fn tank_sensor_voltage(&mut self) -> Result<u16> {
let delay = Delay::new_default();
self.tank_power.set_high()?;
//let stabilize

117
rust/src/tank.rs
View File

@ -1,25 +1,37 @@
use serde::Serialize;
use crate::{config::{PlantControllerConfig, TankConfig}, plant_hal::PlantCtrlBoard};
use crate::config::{self, PlantControllerConfig, TankConfig};
const OPEN_TANK_VOLTAGE: f32 = 3.0;
pub const WATER_FROZEN_THRESH: f32 = 4.0;
#[derive(Debug, Clone, Serialize)]
#[derive(Debug, PartialEq, Default)]
/// State data for water tank
///
/// TODO unify with TankStateMQTT
pub struct TankInfo {
/// is there enough water in the tank
enough_water: bool,
/// warning that water needs to be refilled soon
warn_level: bool,
/// estimation how many ml are still in tank
left_ml: u32,
/// if there is was an issue with the water level sensor
/// TODO merge with left_ml as Result<u32, error_type>
sensor_error: bool,
/// raw water sensor value
raw: u16,
}
pub enum TankError {
SensorDisabled,
SensorMissing(f32),
SensorValueError { value: f32, min: f32, max: f32 },
BoardError(String)
}
pub enum TankState {
TankSensorPresent(f32),
TankSensorError(TankError),
TankSensorPresent(u16),
TankSensorDisabled,
}
fn raw_volatge_to_divider_percent(raw_value_mv: f32) -> Result<f32, TankError> {
fn raw_volatge_to_divider_percent(raw_value_mv: u16) -> Result<f32, TankError> {
if raw_value_mv > OPEN_TANK_VOLTAGE {
return Err(TankError::SensorMissing(raw_value_mv));
}
@ -39,19 +51,19 @@ fn raw_volatge_to_divider_percent(raw_value_mv: f32) -> Result<f32, TankError> {
}
fn raw_voltage_to_tank_fill_percent(
raw_value_mv: f32,
raw_value_mv: u16,
config: &TankConfig,
) -> Result<f32, TankError> {
let divider_percent = raw_volatge_to_divider_percent(raw_value_mv)?;
if divider_percent < config.tank_empty_percent.into() || divider_percent > config.tank_full_percent.into() {
if s < config.tank_empty_percent || s > config.tank_full_percent {
return Err(TankError::SensorValueError {
value: divider_percent,
min: config.tank_empty_percent.into(),
max: config.tank_full_percent.into(),
min: config.tank_empty_percent,
max: config.tank_full_percent,
});
}
Ok((divider_percent - f32::from(config.tank_empty_percent)) * 100.
/ f32::from(config.tank_full_percent - config.tank_empty_percent))
Ok((divider_percent - config.tank_empty_percent) * 100
/ (config.tank_full_percent - config.tank_empty_percent))
}
@ -59,9 +71,8 @@ impl TankState {
pub fn left_ml(&self, config: &TankConfig) -> Result<f32, TankError> {
match self {
TankState::TankSensorDisabled => Err(TankError::SensorDisabled),
TankState::TankSensorError(err) => Err(err.clone()),
TankState::TankSensorPresent(raw_value_mv) => {
let tank_fill_percent = raw_voltage_to_tank_fill_percent(*raw_value_mv, config)?;
let tank_fill_percent = raw_voltage_to_tank_fill_percent(raw_value_mv, config)?;
//TODO(judge) move logging to more sensible place
//println!(
//"Tank sensor returned mv {} as {}% leaving {} ml useable",
@ -74,10 +85,9 @@ impl TankState {
pub fn enough_water(&self, config: &TankConfig) -> Result<bool, TankError> {
match self {
TankState::TankSensorDisabled => Err(TankError::SensorDisabled),
TankState::TankSensorError(err) => Err(err.clone()),
TankState::TankSensorPresent(raw_value_mv) => {
let tank_fill_percent = raw_voltage_to_tank_fill_percent(*raw_value_mv, config)?;
if tank_fill_percent > config.tank_empty_percent.into() {
let tank_fill_percent = raw_voltage_to_tank_fill_percent(raw_value_mv, config)?;
if tank_fill_percent > config.tank_empty_percent {
//TODO(judge) move logging to more sensible place
//println!(
//"Enough water, current percent is {}, minimum empty level is {}",
@ -94,10 +104,9 @@ impl TankState {
pub fn warn_level(&self, config: &TankConfig) -> Result<bool, TankError> {
match self {
TankState::TankSensorDisabled => Err(TankError::SensorDisabled),
TankState::TankSensorError(err) => Err(err.clone()),
TankState::TankSensorPresent(raw_value_mv) => {
let tank_fill_percent = raw_voltage_to_tank_fill_percent(*raw_value_mv, config)?;
if tank_fill_percent < config.tank_warn_percent.into() {
let tank_fill_percent = raw_voltage_to_tank_fill_percent(raw_value_mv, config)?;
if tank_fill_percent < config.tank_warn_percent {
//TODO(judge) move logging to more sensible place
//println!(
//"Low water, current percent is {}, minimum warn level is {}",
@ -112,32 +121,16 @@ impl TankState {
},
}
}
}
pub fn as_mqtt_info(&self, config: &TankConfig, water_temp: Result<f32, anyhow::Error>) -> TankInfo {
let mut tank_err: Option<TankError> = None;
let left_ml = match self.left_ml(config) {
Err(err) => { tank_err = Some(err); None },
Ok(left_ml) => Some(left_ml),
};
let enough_water = self.enough_water(config).unwrap_or(false); //NOTE: is this correct if there is an error assume not enough water?
let warn_level = self.warn_level(config).unwrap_or(false); //NOTE: should no warn level be triggered if there is an error?
let raw = match self {
TankState::TankSensorDisabled
| TankState::TankSensorError(_) => None,
TankState::TankSensorPresent(raw_value_mv) => Some(*raw_value_mv),
};
TankInfo {
enough_water,
warn_level,
left_ml,
sensor_error: tank_err,
raw,
water_frozen: water_temp.as_ref().is_ok_and(|temp| *temp < WATER_FROZEN_THRESH),
water_temp: water_temp.as_ref().copied().ok(),
temp_sensor_error: water_temp.err().map(|err| err.to_string())
}
}
#[derive(Serialize)]
pub struct TankStateMQTT {
enough_water: bool,
warn_level: bool,
left_ml: u32,
sensor_error: bool,
raw: u16,
water_frozen: String,
}
pub fn determine_tank_state(
@ -145,33 +138,9 @@ pub fn determine_tank_state(
config: &PlantControllerConfig,
) -> TankState {
if config.tank.tank_sensor_enabled {
match board.tank_sensor_voltage() {
Ok(raw_sensor_value_mv) => TankState::TankSensorPresent(raw_sensor_value_mv),
Err(err) => TankState::TankSensorError(TankError::BoardError(err.to_string()))
}
let raw_sensor_value_mv = board.tank_sensor_voltage();
TankState::TankSensorPresent(raw_sensor_value_mv)
} else {
TankState::TankSensorDisabled
}
}
#[derive(Debug, Serialize)]
/// Information structure send to mqtt for monitoring purposes
pub struct TankInfo {
/// is there enough water in the tank
enough_water: bool,
/// warning that water needs to be refilled soon
warn_level: bool,
/// estimation how many ml are still in tank
left_ml: Option<f32>,
/// if there is was an issue with the water level sensor
/// TODO merge with left_ml as Result<u32, error_type>
sensor_error: Option<TankError>,
/// raw water sensor value
raw: Option<f32>,
/// water in tank might be frozen
water_frozen: bool,
/// water temperature
water_temp: Option<f32>,
temp_sensor_error: Option<String>,
}