Improve error handling, ensure robust defaults, and eliminate unsafe unwraps/expectations across modules.

Software/MainBoard/rust/src/hal/esp.rs

@@ -314,17 +314,19 @@ impl Esp<'_> {
             &mut tx_meta,
             &mut tx_buffer,
         );
-        socket.bind(123).unwrap();
+        socket.bind(123).context("Could not bind UDP socket")?;
 
         let context = NtpContext::new(Timestamp::default());
 
         let ntp_addrs = stack
             .dns_query(NTP_SERVER, DnsQueryType::A)
-            .await;
-        if ntp_addrs.is_err() {
-            bail!("Failed to resolve DNS");
+            .await
+            .context("Failed to resolve DNS")?;
+
+        if ntp_addrs.is_empty() {
+            bail!("No IP addresses found for NTP server");
         }
-        let ntp = ntp_addrs.unwrap()[0];
+        let ntp = ntp_addrs[0];
         info!("NTP server: {ntp:?}");
 
         let mut counter = 0;
@@ -416,9 +418,14 @@ impl Esp<'_> {
             Err(_) => "PlantCtrl Emergency Mode".to_string(),
         };
 
-        let device = self.interface_ap.take().unwrap();
+        let device = self
+            .interface_ap
+            .take()
+            .context("AP interface already taken")?;
         let gw_ip_addr_str = "192.168.71.1";
-        let gw_ip_addr = Ipv4Addr::from_str(gw_ip_addr_str).expect("failed to parse gateway ip");
+        let gw_ip_addr = Ipv4Addr::from_str(gw_ip_addr_str).map_err(|_| FatError::String {
+            error: "failed to parse gateway ip".to_string(),
+        })?;
 
         let config = embassy_net::Config::ipv4_static(StaticConfigV4 {
             address: Ipv4Cidr::new(gw_ip_addr, 24),
@@ -472,18 +479,17 @@ impl Esp<'_> {
         spawner: Spawner,
     ) -> FatResult<Stack<'static>> {
         esp_radio::wifi_set_log_verbose();
-        let ssid = network_config.ssid.clone();
-        match &ssid {
+        let ssid = match &network_config.ssid {
             Some(ssid) => {
                 if ssid.is_empty() {
                     bail!("Wifi ssid was empty")
                 }
+                ssid.to_string()
             }
             None => {
                 bail!("Wifi ssid was empty")
             }
-        }
-        let ssid = ssid.unwrap().to_string();
+        };
         info!("attempting to connect wifi {ssid}");
         let password = match network_config.password {
             Some(ref password) => password.to_string(),
@@ -491,7 +497,10 @@ impl Esp<'_> {
         };
         let max_wait = network_config.max_wait;
 
-        let device = self.interface_sta.take().unwrap();
+        let device = self
+            .interface_sta
+            .take()
+            .context("STA interface already taken")?;
         let config = embassy_net::Config::dhcpv4(DhcpConfig::default());
 
         let seed = (self.rng.random() as u64) << 32 | self.rng.random() as u64;
@@ -596,9 +605,9 @@ impl Esp<'_> {
         if let Ok(cur) = self.ota.current_ota_state() {
             if cur == OtaImageState::PendingVerify {
                 info!("Marking OTA image as valid");
-                self.ota
-                    .set_current_ota_state(Valid)
-                    .expect("Could not set image to valid");
+                if let Err(err) = self.ota.set_current_ota_state(Valid) {
+                    error!("Could not set image to valid: {:?}", err);
+                }
             }
         } else {
             info!("No OTA image to mark as valid");
@@ -753,10 +762,7 @@ impl Esp<'_> {
             network_config.mqtt_user.as_ref(),
             network_config.mqtt_password.as_ref(),
         ) {
-            builder = builder.with_authentication(
-                mqtt_user,
-                mqtt_password,
-            );
+            builder = builder.with_authentication(mqtt_user, mqtt_password);
             info!("With authentification");
         }
 
@@ -808,11 +814,10 @@ impl Esp<'_> {
             Timer::after(Duration::from_millis(100)).await;
         }
 
-        Topic::General(round_trip_topic.clone())
+        let _ = Topic::General(round_trip_topic.clone())
             .with_display("online_text")
             .publish()
-            .await
-            .unwrap();
+            .await;
 
         let timeout = {
             let guard = TIME_ACCESS.get().await.lock().await;
@@ -974,7 +979,13 @@ async fn run_dhcp(stack: Stack<'static>, gw_ip_addr: &'static str) {
     use edge_nal::UdpBind;
     use edge_nal_embassy::{Udp, UdpBuffers};
 
-    let ip = Ipv4Addr::from_str(gw_ip_addr).expect("dhcp task failed to parse gw ip");
+    let ip = match Ipv4Addr::from_str(gw_ip_addr) {
+        Ok(ip) => ip,
+        Err(_) => {
+            error!("dhcp task failed to parse gw ip");
+            return;
+        }
+    };
 
     let mut buf = [0u8; 1500];
 
@@ -982,13 +993,19 @@ async fn run_dhcp(stack: Stack<'static>, gw_ip_addr: &'static str) {
 
     let buffers = UdpBuffers::<3, 1024, 1024, 10>::new();
     let unbound_socket = Udp::new(stack, &buffers);
-    let mut bound_socket = unbound_socket
+    let mut bound_socket = match unbound_socket
         .bind(SocketAddr::V4(SocketAddrV4::new(
             Ipv4Addr::UNSPECIFIED,
             DEFAULT_SERVER_PORT,
         )))
         .await
-        .unwrap();
+    {
+        Ok(s) => s,
+        Err(e) => {
+            error!("dhcp task failed to bind socket: {:?}", e);
+            return;
+        }
+    };
 
     loop {
         _ = io::server::run(