set read config initial somewhat ready

rust/src/hal/mod.rs

@@ -49,6 +49,7 @@ use esp_storage::FlashStorage;
 use esp_wifi::{init, EspWifiController};
 use littlefs2::fs::{Allocation, Filesystem as lfs2Filesystem};
 use littlefs2::object_safe::DynStorage;
+use log::{info, warn};
 
 //Only support for 8 right now!
 pub const PLANT_COUNT: usize = 8;
@@ -88,7 +89,7 @@ pub trait BoardInteraction<'a> {
     async fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> Result<f32>;
     async fn general_fault(&mut self, enable: bool);
     async fn test(&mut self) -> Result<()>;
-    async fn set_config(&mut self, config: PlantControllerConfig) -> Result<()>;
+    fn set_config(&mut self, config: PlantControllerConfig);
     async fn get_mptt_voltage(&mut self) -> anyhow::Result<Voltage>;
     async fn get_mptt_current(&mut self) -> anyhow::Result<Current>;
 }
@@ -99,7 +100,12 @@ impl dyn BoardInteraction<'_> {
         let even = counter % 2 == 0;
         let current = counter / (PLANT_COUNT as u32);
         for led in 0..PLANT_COUNT {
-            self.fault(led, current == led as u32).await.unwrap();
+            match self.fault(led, current == led as u32).await {
+                Result::Ok(_) => {}
+                Err(err) => {
+                    warn!("Fault on plant {}: {:?}", led, err);
+                }
+            }
         }
         let _ = self.general_fault(even.into());
     }
@@ -187,11 +193,11 @@ impl PlantHal {
         let timg0 = TimerGroup::new(peripherals.TIMG0);
         let esp_wifi_ctrl = &*mk_static!(
             EspWifiController<'static>,
-            init(timg0.timer0, rng.clone()).unwrap()
+            init(timg0.timer0, rng.clone()).expect("Could not init wifi controller")
         );
 
         let (controller, interfaces) =
-            esp_wifi::wifi::new(&esp_wifi_ctrl, peripherals.WIFI).unwrap();
+            esp_wifi::wifi::new(&esp_wifi_ctrl, peripherals.WIFI).expect("Could not init wifi");
 
         use esp_hal::timer::systimer::SystemTimer;
         esp_hal_embassy::init(systimer.alarm0);
@@ -234,11 +240,9 @@ impl PlantHal {
         };
         //
 
-        let tablebuffer: [u8; esp_bootloader_esp_idf::partitions::PARTITION_TABLE_MAX_LEN] =
-            [0u8; esp_bootloader_esp_idf::partitions::PARTITION_TABLE_MAX_LEN];
         let tablebuffer = mk_static!(
             [u8; esp_bootloader_esp_idf::partitions::PARTITION_TABLE_MAX_LEN],
-            tablebuffer
+            [0u8; esp_bootloader_esp_idf::partitions::PARTITION_TABLE_MAX_LEN]
         );
         let storage_ota = mk_static!(FlashStorage, FlashStorage::new());
         let pt =
@@ -246,36 +250,37 @@ impl PlantHal {
 
         // List all partitions - this is just FYI
         for i in 0..pt.len() {
-            println!("{:?}", pt.get_partition(i));
+            info!("{:?}", pt.get_partition(i));
         }
-
-        let ota_data = pt
-            .find_partition(esp_bootloader_esp_idf::partitions::PartitionType::Data(
+        let ota_data = mk_static!(
+            PartitionEntry,
+            pt.find_partition(esp_bootloader_esp_idf::partitions::PartitionType::Data(
                 DataPartitionSubType::Ota,
             ))?
-            .unwrap();
+            .expect("No OTA data partition found")
+        );
 
-        let ota_data = mk_static!(PartitionEntry, ota_data);
-
-        let ota_data = ota_data.as_embedded_storage(storage_ota);
-        let ota_data = mk_static!(FlashRegion<FlashStorage>, ota_data);
+        let ota_data = mk_static!(
+            FlashRegion<FlashStorage>,
+            ota_data.as_embedded_storage(storage_ota)
+        );
 
         let mut ota = esp_bootloader_esp_idf::ota::Ota::new(ota_data)?;
 
         let ota_partition = match ota.current_slot()? {
             Slot::None => {
-                panic!("No OTA slot found");
+                panic!("No OTA slot active?");
             }
             Slot::Slot0 => pt
                 .find_partition(esp_bootloader_esp_idf::partitions::PartitionType::App(
                     AppPartitionSubType::Ota0,
                 ))?
-                .unwrap(),
+                .expect("No OTA slot0 found"),
             Slot::Slot1 => pt
                 .find_partition(esp_bootloader_esp_idf::partitions::PartitionType::App(
                     AppPartitionSubType::Ota1,
                 ))?
-                .unwrap(),
+                .expect("No OTA slot1 found"),
         };
 
         let ota_next = mk_static!(PartitionEntry, ota_partition);
@@ -289,11 +294,11 @@ impl PlantHal {
             .find_partition(esp_bootloader_esp_idf::partitions::PartitionType::Data(
                 DataPartitionSubType::LittleFs,
             ))?
-            .unwrap();
+            .expect("Data partition with littlefs not found");
         let data_partition = mk_static!(PartitionEntry, data_partition);
 
         let storage_data = mk_static!(FlashStorage, FlashStorage::new());
-        let mut data = mk_static!(
+        let data = mk_static!(
             FlashRegion<FlashStorage>,
             data_partition.as_embedded_storage(storage_data)
         );
@@ -313,7 +318,7 @@ impl PlantHal {
         }
 
         let fs = Arc::new(Mutex::new(
-            lfs2Filesystem::mount(alloc, lfs2filesystem).unwrap(),
+            lfs2Filesystem::mount(alloc, lfs2filesystem).expect("Could not mount lfs2 filesystem"),
         ));
 
         let mut esp = Esp {
@@ -362,9 +367,8 @@ impl PlantHal {
         );
 
         esp.init_rtc_deepsleep_memory(init_rtc_store, to_config_mode);
-        let fs_mount_error = esp.mount_file_system().is_err();
 
-        let config = esp.load_config();
+        let config = esp.load_config().await;
 
         log::info!("Init rtc driver");
         // let mut rtc = Ds323x::new_ds3231(MutexDevice::new(&I2C_DRIVER));