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

chore: cargo fmt

Browse Source
This commit is contained in:
ju6ge 2025-03-13 20:32:28 +01:00
parent 3cdaacabac
commit f340278236
Signed by: judge
GPG Key ID: 6512C30DD8E017B5
5 changed files with 318 additions and 288 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
rust/src/config.rs
View File

@ -33,7 +33,7 @@ pub struct NightLampConfig {
pub night_lamp_hour_end: u8,
pub night_lamp_only_when_dark: bool,
pub low_soc_cutoff: u8,
pub low_soc_restore: u8
pub low_soc_restore: u8,
}
impl Default for NightLampConfig {
fn default() -> Self {
@ -43,7 +43,7 @@ impl Default for NightLampConfig {
night_lamp_hour_end: 2,
night_lamp_only_when_dark: true,
low_soc_cutoff: 30,
low_soc_restore: 50
low_soc_restore: 50,
}
}
}

47
rust/src/log/mod.rs
View File

@ -1,5 +1,5 @@
use std::{collections::HashMap, sync::Mutex};
use serde::Serialize;
use std::{collections::HashMap, sync::Mutex};
use strum::{EnumIter, IntoEnumIterator};
use strum_macros::IntoStaticStr;
@ -15,10 +15,11 @@ const TXT_LONG_LENGTH:usize = 32;
const BUFFER_SIZE: usize = 220;
#[link_section = ".rtc.data"]
static mut BUFFER:ConstGenericRingBuffer::<LogEntry, BUFFER_SIZE> = ConstGenericRingBuffer::<LogEntry, BUFFER_SIZE>::new();
static mut BUFFER: ConstGenericRingBuffer<LogEntry, BUFFER_SIZE> =
ConstGenericRingBuffer::<LogEntry, BUFFER_SIZE>::new();
#[allow(static_mut_refs)]
static BUFFER_ACCESS: Lazy<Mutex<&mut ConstGenericRingBuffer::<LogEntry, BUFFER_SIZE>>> = Lazy::new(|| unsafe { Mutex::new(&mut BUFFER) });
static BUFFER_ACCESS: Lazy<Mutex<&mut ConstGenericRingBuffer<LogEntry, BUFFER_SIZE>>> =
Lazy::new(|| unsafe { Mutex::new(&mut BUFFER) });
#[derive(Serialize, Debug, Clone)]
pub struct LogEntry {
@ -27,7 +28,7 @@ pub struct LogEntry {
pub a: u32,
pub b: u32,
pub txt_short: heapless::String<TXT_SHORT_LENGTH>,
pub txt_long: heapless::String<TXT_LONG_LENGTH>
pub txt_long: heapless::String<TXT_LONG_LENGTH>,
}
pub fn init() {
@ -41,7 +42,7 @@ pub fn init(){
fn limit_length<const LIMIT: usize>(input: &str, target: &mut heapless::String<LIMIT>) {
for char in input.chars() {
match target.push(char) {
Ok(_) => {}, //continue adding chars
Ok(_) => {} //continue adding chars
Err(_) => {
//clear space for two asci chars
while target.len() + 2 >= LIMIT {
@ -51,7 +52,7 @@ fn limit_length <const LIMIT:usize> (input: &str, target: &mut heapless::String<
target.push('.').unwrap();
target.push('.').unwrap();
return;
},
}
}
}
}
@ -76,11 +77,9 @@ pub fn log(message_key: LogMessage, number_a: u32, number_b: u32, txt_short:&str
let time = EspSystemTime {}.now().as_millis() as u64;
let ordinal = message_key.ordinal() as u16;
let template_string: &str = message_key.into();
let mut values: HashMap<&str, &str> = HashMap::new();
let number_a_str = number_a.to_string();
let number_b_str = number_b.to_string();
@ -95,8 +94,6 @@ pub fn log(message_key: LogMessage, number_a: u32, number_b: u32, txt_short:&str
println!("{serial_entry}");
let entry = LogEntry {
timestamp: time,
message_id: ordinal,
@ -106,14 +103,10 @@ pub fn log(message_key: LogMessage, number_a: u32, number_b: u32, txt_short:&str
txt_long: txt_long_stack,
};
let mut buffer = BUFFER_ACCESS.lock().unwrap();
buffer.push(entry);
}
#[cfg(test)]
mod tests {
use super::*;
@ -132,11 +125,11 @@ mod tests {
}
}
#[derive(IntoStaticStr, EnumIter, Serialize, PartialEq, Eq, PartialOrd, Ord, Clone, UnitEnum)]
pub enum LogMessage {
#[strum(serialize = "Reset due to ${txt_long} requires rtc clear ${number_a} and force config mode ${number_b}")]
#[strum(
serialize = "Reset due to ${txt_long} requires rtc clear ${number_a} and force config mode ${number_b}"
)]
ResetReason,
#[strum(serialize = "Current restart to conf mode ${number_a}")]
RestartToConfig,
@ -146,7 +139,9 @@ pub enum LogMessage {
BatteryCommunicationError,
#[strum(serialize = "Tank sensor raw ${number_a} percent ${number_b}")]
SensorTankRaw,
#[strum(serialize = "raw measure unscaled ${number_a} hz ${number_b}, plant ${txt_short} sensor ${txt_long}")]
#[strum(
serialize = "raw measure unscaled ${number_a} hz ${number_b}, plant ${txt_short} sensor ${txt_long}"
)]
RawMeasure,
#[strum(serialize = "IP info: ${txt_long}")]
WifiInfo,
@ -164,7 +159,9 @@ pub enum LogMessage {
PartitionState,
#[strum(serialize = "Mounted Filesystem free ${number_a} total ${number_b} use ${txt_short}")]
FilesystemMount,
#[strum(serialize = "Mounting Filesystem, this will format the first time and needs quite some time!")]
#[strum(
serialize = "Mounting Filesystem, this will format the first time and needs quite some time!"
)]
MountingFilesystem,
#[strum(serialize = "Year inplausible, force config mode")]
YearInplausibleForceConfig,
@ -178,12 +175,16 @@ pub enum LogMessage {
ConfigModeMissingConfig,
#[strum(serialize = "startup state wifi ${number_a} sntp ${number_b} mqtt ${txt_short}")]
StartupInfo,
#[strum(serialize = "Trying to pump for ${number_b}s with pump ${number_a} now dryrun: ${txt_short}")]
#[strum(
serialize = "Trying to pump for ${number_b}s with pump ${number_a} now dryrun: ${txt_short}"
)]
PumpPlant,
#[strum(serialize = "Enable main power dryrun: ${number_a}")]
EnableMain,
#[strum(serialize = "Pumped multiple times, but plant is still to try attempt: ${number_a} limit :: ${number_b} plant: ${txt_short}")]
ConsecutivePumpCountLimit
#[strum(
serialize = "Pumped multiple times, but plant is still to try attempt: ${number_a} limit :: ${number_b} plant: ${txt_short}"
)]
ConsecutivePumpCountLimit,
}
#[derive(Serialize)]

89
rust/src/main.rs
View File

@ -10,17 +10,11 @@ use chrono_tz::{Europe::Berlin, Tz};
use config::Mode;
use esp_idf_hal::delay::Delay;
use esp_idf_sys::{
esp_ota_get_app_partition_count,
esp_ota_get_running_partition,
esp_ota_get_state_partition,
esp_ota_img_states_t,
esp_ota_img_states_t_ESP_OTA_IMG_ABORTED,
esp_ota_img_states_t_ESP_OTA_IMG_INVALID,
esp_ota_img_states_t_ESP_OTA_IMG_NEW,
esp_ota_img_states_t_ESP_OTA_IMG_PENDING_VERIFY,
esp_ota_img_states_t_ESP_OTA_IMG_UNDEFINED,
esp_ota_img_states_t_ESP_OTA_IMG_VALID,
vTaskDelay
esp_ota_get_app_partition_count, esp_ota_get_running_partition, esp_ota_get_state_partition,
esp_ota_img_states_t, esp_ota_img_states_t_ESP_OTA_IMG_ABORTED,
esp_ota_img_states_t_ESP_OTA_IMG_INVALID, esp_ota_img_states_t_ESP_OTA_IMG_NEW,
esp_ota_img_states_t_ESP_OTA_IMG_PENDING_VERIFY, esp_ota_img_states_t_ESP_OTA_IMG_UNDEFINED,
esp_ota_img_states_t_ESP_OTA_IMG_VALID, vTaskDelay,
};
use esp_ota::{mark_app_valid, rollback_and_reboot};
use log::log;
@ -28,15 +22,11 @@ use once_cell::sync::Lazy;
use plant_hal::{PlantCtrlBoard, PlantHal, PLANT_COUNT};
use serde::{Deserialize, Serialize};
use crate::{
config::PlantControllerConfig,
webserver::webserver::httpd,
};
mod log;
use crate::{config::PlantControllerConfig, webserver::webserver::httpd};
mod config;
mod log;
pub mod plant_hal;
const TIME_ZONE: Tz = Berlin;
const MOIST_SENSOR_MAX_FREQUENCY: u32 = 5000; // 60kHz (500Hz margin)
@ -72,7 +62,6 @@ impl WaitType {
}
}
#[derive(Serialize, Deserialize, Debug, PartialEq, Default)]
/// Light State tracking data for mqtt
struct LightState {
@ -182,8 +171,6 @@ struct PlantStateMQTT<'a> {
next_pump: &'a str,
}
fn safe_main() -> anyhow::Result<()> {
// It is necessary to call this function once. Otherwise some patches to the runtime
// implemented by esp-idf-sys might not link properly. See https://github.com/esp-rs/esp-idf-template/issues/71
@ -236,23 +223,31 @@ fn safe_main() -> anyhow::Result<()> {
};
log(log::LogMessage::PartitionState, 0, 0, "", ota_state_string);
let mut board: std::sync::MutexGuard<'_, PlantCtrlBoard<'_>> = BOARD_ACCESS.lock().unwrap();
board.general_fault(false);
log(log::LogMessage::MountingFilesystem, 0, 0, "", "");
board.mount_file_system()?;
let free_space = board.file_system_size()?;
log(log::LogMessage::FilesystemMount, free_space.free_size as u32,
free_space.total_size as u32, &free_space.used_size.to_string(), "");
log(
log::LogMessage::FilesystemMount,
free_space.free_size as u32,
free_space.total_size as u32,
&free_space.used_size.to_string(),
"",
);
let mut cur = board.get_rtc_time().or_else(|err| {
let mut cur = board
.get_rtc_time()
.or_else(|err| {
println!("rtc module error: {:?}", err);
board.general_fault(true);
board.time()
}).map_err(|err| -> Result<(), _>{
})
.map_err(|err| -> Result<(), _> {
bail!("time error {}", err);
}).unwrap();
})
.unwrap();
//check if we know the time current > 2020 (plausibility check, this code is newer than 2020)
if cur.year() < 2020 {
@ -260,7 +255,6 @@ fn safe_main() -> anyhow::Result<()> {
log(log::LogMessage::YearInplausibleForceConfig, 0, 0, "", "");
}
println!("cur is {}", cur);
board.update_charge_indicator();
@ -299,7 +293,13 @@ fn safe_main() -> anyhow::Result<()> {
config = valid;
}
Err(err) => {
log(log::LogMessage::ConfigModeMissingConfig, 0,0,"",&err.to_string());
log(
log::LogMessage::ConfigModeMissingConfig,
0,
0,
"",
&err.to_string(),
);
//config upload will trigger reboot!
let _ = board.wifi_ap(Option::None);
drop(board);
@ -403,7 +403,13 @@ fn safe_main() -> anyhow::Result<()> {
publish_battery_state(&mut board, &config);
}
log(log::LogMessage::StartupInfo, wifi as u32, sntp as u32,&mqtt.to_string(),"");
log(
log::LogMessage::StartupInfo,
wifi as u32,
sntp as u32,
&mqtt.to_string(),
"",
);
if to_config {
//check if client or ap mode and init wifi
@ -417,7 +423,6 @@ fn safe_main() -> anyhow::Result<()> {
log(log::LogMessage::NormalRun, 0, 0, "", "");
}
let dry_run = false;
let tank_state = determine_tank_state(&mut board, &config);
@ -464,8 +469,6 @@ fn safe_main() -> anyhow::Result<()> {
}
};
let mut plantstate: [PlantState; PLANT_COUNT] = core::array::from_fn(|_| PlantState {
..Default::default()
});
@ -477,7 +480,6 @@ fn safe_main() -> anyhow::Result<()> {
&mut board,
);
let pump_required = plantstate.iter().any(|it| it.do_water) && !water_frozen;
if pump_required {
log(log::LogMessage::EnableMain, dry_run as u32, 0, "", "");
@ -487,16 +489,27 @@ fn safe_main() -> anyhow::Result<()> {
for plant in 0..PLANT_COUNT {
let state = &mut plantstate[plant];
if state.do_water {
let plant_config = &config.plants[plant];
state.consecutive_pump_count = board.consecutive_pump_count(plant) + 1;
board.store_consecutive_pump_count(plant, state.consecutive_pump_count);
if state.consecutive_pump_count > plant_config.max_consecutive_pump_count as u32 {
log(log::LogMessage::ConsecutivePumpCountLimit, state.consecutive_pump_count as u32,plant_config.max_consecutive_pump_count as u32,&plant.to_string(),"");
log(
log::LogMessage::ConsecutivePumpCountLimit,
state.consecutive_pump_count as u32,
plant_config.max_consecutive_pump_count as u32,
&plant.to_string(),
"",
);
state.not_effective = true;
board.fault(plant, true);
}
log(log::LogMessage::PumpPlant, (plant + 1) as u32,plant_config.pump_time_s as u32,&dry_run.to_string(),"");
log(
log::LogMessage::PumpPlant,
(plant + 1) as u32,
plant_config.pump_time_s as u32,
&dry_run.to_string(),
"",
);
board.store_last_pump_time(plant, cur);
board.last_pump_time(plant);
state.active = true;
@ -587,13 +600,11 @@ fn safe_main() -> anyhow::Result<()> {
//is deep sleep
mark_app_valid();
let stay_alive_mqtt = STAY_ALIVE.load(std::sync::atomic::Ordering::Relaxed);
let stay_alive = stay_alive_mqtt;
println!("Check stay alive, current state is {}", stay_alive);
if stay_alive {
println!("Go to stay alive move");
drop(board);
@ -1095,7 +1106,7 @@ fn get_version() -> VersionInfo {
return VersionInfo {
git_hash: (branch + "@" + hash),
build_time: env!("VERGEN_BUILD_TIMESTAMP").to_owned(),
partition: partition.to_owned() + &address.to_string()
partition: partition.to_owned() + &address.to_string(),
};
}

153
rust/src/plant_hal.rs
View File

@ -1,8 +1,8 @@
use bq34z100::{Bq34Z100Error, Bq34z100g1, Bq34z100g1Driver};
use crate::log::LogMessage;
use ds323x::{DateTimeAccess, Ds323x};
use esp_ota::mark_app_valid;
use crate::log::LogMessage;
use eeprom24x::{Eeprom24x, Eeprom24xTrait, SlaveAddr};
use embedded_hal_bus::i2c::MutexDevice;
@ -23,11 +23,14 @@ use esp_idf_svc::mqtt::client::{EspMqttClient, LwtConfiguration, MqttClientConfi
use esp_idf_svc::nvs::EspDefaultNvsPartition;
use esp_idf_svc::wifi::config::{ScanConfig, ScanType};
use esp_idf_svc::wifi::EspWifi;
use esp_idf_sys::esp_restart;
use esp_idf_sys::{
esp_deep_sleep, esp_sleep_enable_ext1_wakeup,
esp_sleep_ext1_wakeup_mode_t_ESP_EXT1_WAKEUP_ANY_LOW, esp_spiffs_info,
};
use measurements::Temperature;
use once_cell::sync::Lazy;
use plant_ctrl2::sipo::ShiftRegister40;
use esp_idf_sys::{esp_deep_sleep, esp_sleep_enable_ext1_wakeup, esp_sleep_ext1_wakeup_mode_t_ESP_EXT1_WAKEUP_ANY_LOW, esp_spiffs_info};
use esp_idf_sys::esp_restart;
use anyhow::{anyhow, Context};
use anyhow::{bail, Ok, Result};
@ -80,7 +83,6 @@ 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;
@ -129,8 +131,6 @@ static mut LOW_VOLTAGE_DETECTED: bool = false;
#[link_section = ".rtc.data"]
static mut RESTART_TO_CONF: bool = false;
pub struct FileSystemSizeInfo {
pub total_size: usize,
pub used_size: usize,
@ -212,7 +212,7 @@ pub struct BatteryState {
pub struct BackupHeader {
pub timestamp: i64,
crc16: u16,
pub size: usize
pub size: usize,
}
impl PlantCtrlBoard<'_> {
@ -221,10 +221,11 @@ impl PlantCtrlBoard<'_> {
OkStd(current) => current < 20,
Err(_) => false,
};
self.shift_register.decompose()[CHARGING].set_state(is_charging.into()).unwrap();
self.shift_register.decompose()[CHARGING]
.set_state(is_charging.into())
.unwrap();
}
pub fn deep_sleep(&mut self, duration_in_ms: u64) -> ! {
self.shift_register.decompose()[AWAKE].set_low().unwrap();
unsafe {
@ -235,7 +236,10 @@ impl PlantCtrlBoard<'_> {
esp_restart();
} else {
//configure gpio 1 to wakeup on low, reused boot button for this
esp_sleep_enable_ext1_wakeup(0b10u64, esp_sleep_ext1_wakeup_mode_t_ESP_EXT1_WAKEUP_ANY_LOW);
esp_sleep_enable_ext1_wakeup(
0b10u64,
esp_sleep_ext1_wakeup_mode_t_ESP_EXT1_WAKEUP_ANY_LOW,
);
esp_deep_sleep(duration_in_ms);
}
};
@ -251,7 +255,7 @@ impl PlantCtrlBoard<'_> {
let mut header_page_buffer = vec![0_u8; store];
match self.eeprom.read_data(0, &mut header_page_buffer) {
OkStd(_) => {},
OkStd(_) => {}
Err(err) => bail!("Error reading eeprom header {:?}", err),
};
println!("Raw header is {:?} with size {}", header_page_buffer, store);
@ -259,7 +263,6 @@ impl PlantCtrlBoard<'_> {
Ok(header)
}
pub fn get_backup_config(&mut self) -> Result<Vec<u8>> {
let dummy = BackupHeader {
timestamp: 0,
@ -270,7 +273,7 @@ impl PlantCtrlBoard<'_> {
let mut header_page_buffer = vec![0_u8; store];
match self.eeprom.read_data(0, &mut header_page_buffer) {
OkStd(_) => {},
OkStd(_) => {}
Err(err) => bail!("Error reading eeprom header {:?}", err),
};
let header: BackupHeader = bincode::deserialize(&header_page_buffer)?;
@ -278,13 +281,17 @@ impl PlantCtrlBoard<'_> {
let data_start_address = 1 * self.eeprom.page_size() as u32;
let mut data_buffer = vec![0_u8; header.size];
match self.eeprom.read_data(data_start_address, &mut data_buffer) {
OkStd(_) => {},
OkStd(_) => {}
Err(err) => bail!("Error reading eeprom data {:?}", err),
};
let checksum = X25.checksum(&data_buffer);
if checksum != header.crc16 {
bail!("Invalid checksum, got {} but expected {}", checksum, header.crc16 );
bail!(
"Invalid checksum, got {} but expected {}",
checksum,
header.crc16
);
}
Ok(data_buffer)
@ -306,12 +313,16 @@ impl PlantCtrlBoard<'_> {
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)
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(_) => {},
OkStd(_) => {}
Err(err) => bail!("Error writing eeprom {:?}", err),
};
delay.delay_ms(5);
@ -323,7 +334,7 @@ impl PlantCtrlBoard<'_> {
for chunk in to_write {
let address = current_page * page_size as u32;
match self.eeprom.write_page(address, chunk) {
OkStd(_) => {},
OkStd(_) => {}
Err(err) => bail!("Error writing eeprom {:?}", err),
};
current_page = current_page + 1;
@ -339,8 +350,7 @@ impl PlantCtrlBoard<'_> {
//update led here?
delay.delay_ms(5);
}
return Ok(())
return Ok(());
}
pub fn get_battery_state(&mut self) -> BatteryState {
@ -490,7 +500,13 @@ impl PlantCtrlBoard<'_> {
let r2 = median * 50.0 / (3.3 - median);
let mut percent = r2 / 190_f32 * 100_f32;
percent = percent.clamp(0.0, 100.0);
log(LogMessage::SensorTankRaw, median as u32, percent as u32, "","");
log(
LogMessage::SensorTankRaw,
median as u32,
percent as u32,
"",
"",
);
return Ok(percent as u16);
}
@ -663,7 +679,13 @@ impl PlantCtrlBoard<'_> {
delay.delay_ms(10);
let unscaled = self.signal_counter.get_counter_value()? as i32;
let hz = (unscaled as f32 * factor) as u32;
log(LogMessage::RawMeasure, unscaled as u32, hz as u32, &plant.to_string(), &format!("{sensor:?}"));
log(
LogMessage::RawMeasure,
unscaled as u32,
hz as u32,
&plant.to_string(),
&format!("{sensor:?}"),
);
results[repeat] = hz;
}
results.sort();
@ -891,11 +913,11 @@ impl PlantCtrlBoard<'_> {
let b = self.measure_moisture_hz(plant, plant_hal::Sensor::B);
let aa = match a {
OkStd(a) => a as u32,
Err(_) => u32::MAX
Err(_) => u32::MAX,
};
let bb = match b {
OkStd(b) => b as u32,
Err(_) => u32::MAX
Err(_) => u32::MAX,
};
log(LogMessage::TestSensor, aa, bb, &plant.to_string(), "");
}
@ -1327,7 +1349,6 @@ impl PlantHal {
let awake = &mut shift_register.decompose()[AWAKE];
awake.set_high()?;
let charging = &mut shift_register.decompose()[CHARGING];
charging.set_high()?;
@ -1343,7 +1364,6 @@ impl PlantHal {
let ms4 = &mut shift_register.decompose()[MS_4];
ms4.set_high()?;
println!("Init battery driver");
let mut battery_driver = Bq34z100g1Driver {
i2c: MutexDevice::new(&I2C_DRIVER),
@ -1365,7 +1385,6 @@ impl PlantHal {
let mut one_wire_pin = PinDriver::input_output_od(peripherals.pins.gpio18)?;
one_wire_pin.set_pull(Pull::Floating).unwrap();
let rtc_time = rtc.datetime();
match rtc_time {
OkStd(tt) => {
@ -1389,42 +1408,32 @@ impl PlantHal {
let mut to_config_mode: bool = false;
let reasons = ResetReason::get();
match reasons {
ResetReason::Software => {},
ResetReason::ExternalPin => {},
ResetReason::Software => {}
ResetReason::ExternalPin => {}
ResetReason::Watchdog => {
init_rtc_store = true;
},
ResetReason::Sdio => {
init_rtc_store = true
},
ResetReason::Panic => {
init_rtc_store = true
},
ResetReason::InterruptWatchdog => {
init_rtc_store = true
},
ResetReason::PowerOn => {
init_rtc_store = true
},
ResetReason::Unknown => {
init_rtc_store = true
},
ResetReason::Brownout => {
init_rtc_store = true
},
ResetReason::TaskWatchdog => {
init_rtc_store = true
},
ResetReason::DeepSleep => {},
}
ResetReason::Sdio => init_rtc_store = true,
ResetReason::Panic => init_rtc_store = true,
ResetReason::InterruptWatchdog => init_rtc_store = true,
ResetReason::PowerOn => init_rtc_store = true,
ResetReason::Unknown => init_rtc_store = true,
ResetReason::Brownout => init_rtc_store = true,
ResetReason::TaskWatchdog => init_rtc_store = true,
ResetReason::DeepSleep => {}
ResetReason::USBPeripheral => {
init_rtc_store = true;
to_config_mode = true;
},
ResetReason::JTAG => {
init_rtc_store = true
},
}
ResetReason::JTAG => init_rtc_store = true,
};
log(LogMessage::ResetReason, init_rtc_store as u32, to_config_mode as u32, "",&format!("{reasons:?}"));
log(
LogMessage::ResetReason,
init_rtc_store as u32,
to_config_mode as u32,
"",
&format!("{reasons:?}"),
);
if init_rtc_store {
unsafe {
LAST_WATERING_TIMESTAMP = [0; PLANT_COUNT];
@ -1438,8 +1447,20 @@ impl PlantHal {
if to_config_mode {
RESTART_TO_CONF = true;
}
log(LogMessage::RestartToConfig, RESTART_TO_CONF as u32, 0, "","");
log(LogMessage::LowVoltage, LOW_VOLTAGE_DETECTED as u32, 0, "","");
log(
LogMessage::RestartToConfig,
RESTART_TO_CONF as u32,
0,
"",
"",
);
log(
LogMessage::LowVoltage,
LOW_VOLTAGE_DETECTED as u32,
0,
"",
"",
);
for i in 0..PLANT_COUNT {
println!(
"LAST_WATERING_TIMESTAMP[{}] = UTC {}",
@ -1513,12 +1534,16 @@ impl PlantHal {
let status = print_battery(&mut battery_driver);
match status {
OkStd(_) => {
},
OkStd(_) => {}
Err(err) => {
log(LogMessage::BatteryCommunicationError, 0 as u32, 0, "",&format!("{err:?})"));
},
log(
LogMessage::BatteryCommunicationError,
0 as u32,
0,
"",
&format!("{err:?})"),
);
}
}
let shift_register_enable_invert = PinDriver::output(peripherals.pins.gpio21.downgrade())?;

55
rust/src/webserver/webserver.rs
View File

@ -1,22 +1,22 @@
//offer ota and config mode
use std::{
str::from_utf8,
sync::{atomic::AtomicBool, Arc},
};
use crate::{
get_version, log::LogMessage, map_range_moisture, plant_hal::PLANT_COUNT, BOARD_ACCESS
get_version, log::LogMessage, map_range_moisture, plant_hal::PLANT_COUNT, BOARD_ACCESS,
};
use anyhow::bail;
use chrono::DateTime;
use esp_idf_sys::{settimeofday, timeval, vTaskDelay};
use esp_ota::OtaUpdate;
use core::result::Result::Ok;
use embedded_svc::http::Method;
use esp_idf_hal::delay::Delay;
use esp_idf_svc::http::server::{Configuration, EspHttpConnection, EspHttpServer, Request};
use esp_idf_sys::{settimeofday, timeval, vTaskDelay};
use esp_ota::OtaUpdate;
use heapless::String;
use serde::{Deserialize, Serialize};
use std::{
str::from_utf8,
sync::{atomic::AtomicBool, Arc},
};
use url::Url;
use crate::config::PlantControllerConfig;
@ -51,12 +51,12 @@ pub struct TestPump {
#[derive(Serialize, Deserialize, PartialEq, Debug)]
pub struct WebBackupHeader {
timestamp: std::string::String,
size: usize
size: usize,
}
#[derive(Deserialize)]
pub struct NightLampCommand {
active: bool
active: bool,
}
fn write_time(
@ -69,7 +69,7 @@ fn write_time(
let now = timeval {
tv_sec: parsed.to_utc().timestamp(),
tv_usec: 0
tv_usec: 0,
};
unsafe { settimeofday(&now, core::ptr::null_mut()) };
board.set_rtc_time(&parsed.to_utc())?;
@ -173,7 +173,6 @@ fn get_backup_config(
anyhow::Ok(Some(json))
}
fn backup_info(
_request: &mut Request<&mut EspHttpConnection>,
) -> Result<Option<std::string::String>, anyhow::Error> {
@ -187,8 +186,8 @@ fn backup_info(
size: h.size,
};
serde_json::to_string(&wbh)?
},
Err(_) => "{\"error\":\"Header could not be parsed\"".to_owned()
}
Err(_) => "{\"error\":\"Header could not be parsed\"".to_owned(),
};
anyhow::Ok(Some(json))
}
@ -203,7 +202,6 @@ fn set_config(
anyhow::Ok(Some("saved".to_owned()))
}
fn get_battery_state(
_request: &mut Request<&mut EspHttpConnection>,
) -> Result<Option<std::string::String>, anyhow::Error> {
@ -221,13 +219,14 @@ fn get_log(
}
fn get_log_localization_config() -> Result<std::string::String, anyhow::Error> {
anyhow::Ok(serde_json::to_string(&LogMessage::to_log_localisation_config())?)
anyhow::Ok(serde_json::to_string(
&LogMessage::to_log_localisation_config(),
)?)
}
fn get_version_web(
_request: &mut Request<&mut EspHttpConnection>,
) -> Result<Option<std::string::String>, anyhow::Error> {
anyhow::Ok(Some(serde_json::to_string(&get_version())?))
}
@ -293,7 +292,6 @@ fn ota(
if iter != lastiter {
for i in 0..PLANT_COUNT {
board.fault(i, iter == i);
}
lastiter = iter;
}
@ -384,9 +382,9 @@ pub fn httpd(reboot_now: Arc<AtomicBool>) -> Box<EspHttpServer<'static>> {
handle_error_to500(request, get_log)
})
.unwrap();
server.fn_handler("/log_localization", Method::Get, |request| {
server
.fn_handler("/log_localization", Method::Get, |request| {
cors_response(request, 200, &get_log_localization_config().unwrap())
})
.unwrap();
server
@ -473,10 +471,7 @@ pub fn httpd(reboot_now: Arc<AtomicBool>) -> Box<EspHttpServer<'static>> {
let reboot_now_for_reboot = reboot_now.clone();
server
.fn_handler("/reboot", Method::Post, move |_| {
BOARD_ACCESS
.lock()
.unwrap()
.set_restart_to_conf(true);
BOARD_ACCESS.lock().unwrap().set_restart_to_conf(true);
reboot_now_for_reboot.store(true, std::sync::atomic::Ordering::Relaxed);
anyhow::Ok(())
})
@ -532,21 +527,16 @@ pub fn httpd(reboot_now: Arc<AtomicBool>) -> Box<EspHttpServer<'static>> {
server
.fn_handler("/file", Method::Post, move |mut request| {
let filename = query_param(request.uri(), "filename").unwrap();
let lock = BOARD_ACCESS
.lock()
.unwrap();
let file_handle =
lock.get_file_handle(&filename, true);
let lock = BOARD_ACCESS.lock().unwrap();
let file_handle = lock.get_file_handle(&filename, true);
match file_handle {
//TODO get free filesystem size, check against during write if not to large
Ok(mut file_handle) => {
const BUFFER_SIZE: usize = 512;
let mut buffer: [u8; BUFFER_SIZE] = [0; BUFFER_SIZE];
let mut total_read: usize = 0;
let mut lastiter = 0;
loop {
let iter = (total_read / 1024) % 8;
if iter != lastiter {
for i in 0..PLANT_COUNT {
@ -697,7 +687,10 @@ fn handle_error_to500(
return anyhow::Ok(());
}
fn read_up_to_bytes_from_request(request: &mut Request<&mut EspHttpConnection<'_>>, limit: Option<usize>) -> Result<Vec<u8>, anyhow::Error> {
fn read_up_to_bytes_from_request(
request: &mut Request<&mut EspHttpConnection<'_>>,
limit: Option<usize>,
) -> Result<Vec<u8>, anyhow::Error> {
let max_read = limit.unwrap_or(1024);
let mut data_store = Vec::new();
let mut total_read = 0;