From 1da6d54d7adf9811093fcd9a9a5c066108ec5358 Mon Sep 17 00:00:00 2001 From: Empire Phoenix Date: Mon, 6 Apr 2026 19:51:46 +0200 Subject: [PATCH] new backup adjustments --- Software/MainBoard/rust/src/hal/v4_hal.rs | 22 +++++++++++++++---- Software/MainBoard/rust/src/main.rs | 4 ++-- .../rust/src/webserver/backup_manager.rs | 15 +++++-------- 3 files changed, 25 insertions(+), 16 deletions(-) diff --git a/Software/MainBoard/rust/src/hal/v4_hal.rs b/Software/MainBoard/rust/src/hal/v4_hal.rs index 9ed69d4..06e1865 100644 --- a/Software/MainBoard/rust/src/hal/v4_hal.rs +++ b/Software/MainBoard/rust/src/hal/v4_hal.rs @@ -16,6 +16,7 @@ use async_trait::async_trait; use bincode::config; use canapi::id::{classify, plant_id, MessageKind, IDENTIFY_CMD_OFFSET}; use canapi::SensorSlot; +use core::cmp::min; use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice; use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex; use embassy_time::{Duration, Timer, WithTimeout}; @@ -546,6 +547,7 @@ impl<'a> BoardInteraction<'a> for V4<'a> { async fn backup_config(&mut self, controller_config: &PlantControllerConfig) -> FatResult<()> { let mut buffer: [u8; 4096 - BACKUP_HEADER_MAX_SIZE] = [0; 4096 - BACKUP_HEADER_MAX_SIZE]; let length = bincode::encode_into_slice(controller_config, &mut buffer, CONFIG)?; + info!("Writing backup config of size {}", length); let mut checksum = X25.digest(); checksum.update(&buffer[..length]); let mut header_page_buffer = [0_u8; BACKUP_HEADER_MAX_SIZE]; @@ -556,20 +558,31 @@ impl<'a> BoardInteraction<'a> for V4<'a> { timestamp: time, size: length as u16, }; + info!("Header is {:?}", header); bincode::encode_into_slice(&header, &mut header_page_buffer, CONFIG)?; + info!("Header is serialized"); self.get_rtc_module().write(0, &header_page_buffer)?; + info!("Header written"); let mut to_write = length; let mut chunk: usize = 0; while to_write > 0 { self.progress(chunk as u32).await; - let start = BACKUP_HEADER_MAX_SIZE + chunk * EEPROM_PAGE; - let end = start + crate::hal::rtc::EEPROM_PAGE; + let start = chunk * EEPROM_PAGE; + let end = start + min(EEPROM_PAGE, to_write); let part = &buffer[start..end]; + info!( + "Writing chunk {} of size {} to offset {}", + chunk, + part.len(), + start + ); to_write -= part.len(); chunk += 1; - self.get_rtc_module().write((1 + chunk) as u32, part)?; + self.get_rtc_module() + .write((BACKUP_HEADER_MAX_SIZE + chunk * EEPROM_PAGE) as u32, part)?; } + info!("Backup complete"); self.clear_progress().await; Ok(()) } @@ -592,9 +605,10 @@ impl<'a> BoardInteraction<'a> for V4<'a> { async fn backup_info(&mut self) -> FatResult { let mut header_page_buffer = [0_u8; BACKUP_HEADER_MAX_SIZE]; self.get_rtc_module().read(0, &mut header_page_buffer)?; - + info!("Read header page"); let info: Result<(BackupHeader, usize), bincode::error::DecodeError> = bincode::decode_from_slice(&header_page_buffer[..], CONFIG); + info!("decoding header: {:?}", info); info.map(|(header, _)| header) .map_err(|e| FatError::String { error: "Could not read backup header: ".to_string() + &e.to_string(), diff --git a/Software/MainBoard/rust/src/main.rs b/Software/MainBoard/rust/src/main.rs index 274b2ac..05366ab 100644 --- a/Software/MainBoard/rust/src/main.rs +++ b/Software/MainBoard/rust/src/main.rs @@ -248,7 +248,7 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> { let reboot_now = Arc::new(AtomicBool::new(false)); println!("starting webserver"); - spawner.spawn(http_server(reboot_now.clone(), stack))?; + let _ = http_server(reboot_now.clone(), stack); wait_infinity(board, WaitType::MissingConfig, reboot_now.clone()).await; } @@ -642,7 +642,7 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> { if stay_alive { let reboot_now = Arc::new(AtomicBool::new(false)); if let Some(s) = stack.take() { - let _webserver = http_server(reboot_now.clone(), s); + spawner.spawn(http_server(reboot_now.clone(), s))?; wait_infinity(board, WaitType::MqttConfig, reboot_now.clone()).await; } else { bail!("Network Stack missing, hard abort"); diff --git a/Software/MainBoard/rust/src/webserver/backup_manager.rs b/Software/MainBoard/rust/src/webserver/backup_manager.rs index 50ffb0c..0dde713 100644 --- a/Software/MainBoard/rust/src/webserver/backup_manager.rs +++ b/Software/MainBoard/rust/src/webserver/backup_manager.rs @@ -6,6 +6,7 @@ use alloc::string::{String, ToString}; use chrono::DateTime; use edge_http::io::server::Connection; use edge_nal::io::{Read, Write}; +use log::info; use serde::{Deserialize, Serialize}; #[derive(Serialize, Deserialize, PartialEq, Debug)] @@ -46,19 +47,11 @@ where T: Read + Write, { let input = read_up_to_bytes_from_request(conn, Some(4096)).await?; + info!("Read input with length {}", input.len()); let mut board = BOARD_ACCESS.get().await.lock().await; let config_to_backup = serde_json::from_slice(&input)?; + info!("Parsed send config to object"); board.board_hal.backup_config(&config_to_backup).await?; - conn.initiate_response( - 200, - Some("OK"), - &[ - ("Access-Control-Allow-Origin", "*"), - ("Access-Control-Allow-Headers", "*"), - ("Access-Control-Allow-Methods", "*"), - ], - ) - .await?; Ok(Some("saved".to_owned())) } @@ -73,6 +66,7 @@ where let json = match info { Ok(h) => { + info!("Got backup info: {:?}", h); let timestamp = DateTime::from_timestamp_millis(h.timestamp).unwrap_or_default(); let wbh = WebBackupHeader { timestamp: timestamp.to_rfc3339(), @@ -81,6 +75,7 @@ where serde_json::to_string(&wbh)? } Err(err) => { + info!("Error getting backup info: {:?}", err); let wbh = WebBackupHeader { timestamp: err.to_string(), size: 0,