new backup adjustments

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 start = chunk * EEPROM_PAGE;
-            let end = start + crate::hal::rtc::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<BackupHeader> {
         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(),

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");

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,