Addressed AI comments.

Author: umarbinzahid

feather_async/Cargo.toml

@@ -8,7 +8,7 @@ version = "0.1.0"
 harness = false
 
 [dependencies]
-cortex-m = { version = "0.7.7", features = ["critical-section-single-core"] }
+cortex-m = { version = "0.7.3", features = ["critical-section-single-core"] }
 cortex-m-rt = "0.7.5"
 defmt = "0.3"
 defmt-rtt = "0.4"

feather_async/examples/bypass_mode.rs

@@ -60,7 +60,10 @@ async fn wait_for_dhcp(stack: &Stack<'static>) -> Result<(), AppError> {
     loop {
         if let Some(config) = stack.config_v4() {
             let ip: [u8; MAX_IP_BYTES] = config.address.address().octets();
-            let gateway: [u8; MAX_IP_BYTES] = config.gateway.unwrap().octets();
+            let gateway: [u8; MAX_IP_BYTES] = config
+                .gateway
+                .ok_or(AppError::WincError(StackError::InvalidResponse))?
+                .octets();
             let mask: [u8; MAX_IP_BYTES] = config.address.netmask().octets();
             defmt::info!("IP address: {}.{}.{}.{}", ip[0], ip[1], ip[2], ip[3]);
             defmt::info!(
@@ -98,8 +101,11 @@ async fn wait_for_dhcp(stack: &Stack<'static>) -> Result<(), AppError> {
 #[embassy_executor::task]
 async fn ping_task(stack: Stack<'static>, destination_ip: Ipv4Addr, count: u16) -> ! {
     // Wait for DHCP
-    if let Err(_) = wait_for_dhcp(&stack).await {
-        loop {}
+    if let Err(err) = wait_for_dhcp(&stack).await {
+        defmt::error!("DHCP error: {:?}", err);
+        loop {
+            Timer::after(Duration::from_secs(1)).await
+        }
     }
 
     // Then we can use it!
@@ -142,7 +148,9 @@ async fn ping_task(stack: Stack<'static>, destination_ip: Ipv4Addr, count: u16)
         }
     }
 
-    loop {}
+    loop {
+        embassy_time::Timer::after_secs(3600).await
+    }
 }
 
 /// Main Program
@@ -155,7 +163,7 @@ async fn program(spwaner: Spawner) -> Result<(), AppError> {
     let test_ip: Ipv4Addr =
         Ipv4Addr::from_str(test_ip).map_err(|_| StackError::InvalidParameters)?;
     let test_count = option_env!("TEST_COUNT").unwrap_or(DEFAULT_TEST_COUNT);
-    let test_count = u16::from_str(test_count).unwrap();
+    let test_count = u16::from_str(test_count).map_err(|_| StackError::InvalidParameters)?;
 
     let ssid = Ssid::from(option_env!("TEST_SSID").unwrap_or(DEFAULT_TEST_SSID))
         .map_err(|_| StackError::InvalidParameters)?;

winc-rs/src/async_client/ethernet.rs

@@ -14,7 +14,7 @@ impl<X: Xfer> AsyncClient<'_, X> {
     /// # Arguments
     ///
     /// * `buffer` - A mutable slice used to store the received Ethernet packet.
-    /// * `timeout` - An optional duration to wait for a packet.
+    /// * `timeout` - An optional duration to wait for an Ethernet packet.
     ///   If `None`, the default timeout value `ETHERNET_RX_TIMEOUT_MSEC` is used.
     ///
     /// # Returns
@@ -23,11 +23,11 @@ impl<X: Xfer> AsyncClient<'_, X> {
     /// * `Err(StackError)` - If an error occurs while reading the ethernet packet.
     pub async fn read_ethernet_packet(
         &mut self,
-        buffer: Option<&mut [u8]>,
+        buffer: &mut [u8],
         timeout: Option<Duration>,
     ) -> Result<usize, StackError> {
         let timeout_ms: Option<u32> = timeout.map(|d| d.as_millis().min(u32::MAX as u128) as u32);
-        let mut op = RxEthernetPacketInfo::new(buffer, timeout_ms);
+        let mut op = RxEthernetPacketInfo::new(Some(buffer), timeout_ms);
         self.poll_op(&mut op).await
     }
 
@@ -53,7 +53,7 @@ impl<X: Xfer> AsyncClient<'_, X> {
 
 #[cfg(feature = "embassy-net")]
 mod embassy_net {
-    use super::{AsyncClient, Xfer};
+    use super::{AsyncClient, StackError, Xfer};
     use crate::error;
     use crate::manager::{Manager, MAX_OCTETS_IN_MAC_ADDRESS, SOCKET_BUFFER_MAX_LENGTH};
     use crate::ops::net_ops::ethernet_receive::RxEthernetPacketInfo;
@@ -93,7 +93,7 @@ mod embassy_net {
         /// Construct a token pair consisting of one receive token and one transmit token.
         fn receive(
             &mut self,
-            _cx: &mut Context<'_>,
+            cx: &mut Context<'_>,
         ) -> Option<(Self::RxToken<'_>, Self::TxToken<'_>)> {
             // poll for new events
             let _ = self.heartbeat();
@@ -102,10 +102,27 @@ mod embassy_net {
             let mut rx_op = RxEthernetPacketInfo::new(None, Some(ETH_RECV_TIMEOUT_MSEC));
             let result = self.poll_once(&mut rx_op);
 
-            let Ok(read_length) = result else {
-                return None;
+            let read_length = match result {
+                Ok(length) => length,
+                Err(e) => {
+                    if e == StackError::GeneralTimeout {
+                        error!("Ethernet receive timeout");
+                    }
+                    // register the waker if no packet is available
+                    if let Err(e) = self
+                        .manager
+                        .borrow_mut()
+                        .register_waker_if_new(cx.waker().clone())
+                    {
+                        error!("Too many wakers registered: {:?}", e);
+                    }
+                    return None;
+                }
             };
 
+            // Got a packet - remove the waker.
+            self.manager.borrow_mut().unregister_waker(&cx.waker());
+
             let rx_token = WincRxToken {
                 callback: &self.callbacks,
                 read_length,
@@ -234,7 +251,7 @@ mod tests {
             let mut client = make_test_client();
             *client.debug_callback.borrow_mut() = Some(&mut my_debug);
             client
-                .read_ethernet_packet(Some(rx_buffer.as_mut_slice()), None)
+                .read_ethernet_packet(rx_buffer.as_mut_slice(), None)
                 .await
         };
 
@@ -248,7 +265,7 @@ mod tests {
         let timeout = Some(Duration::from_millis(1000));
 
         let result = client
-            .read_ethernet_packet(Some(rx_buffer.as_mut_slice()), timeout)
+            .read_ethernet_packet(rx_buffer.as_mut_slice(), timeout)
             .await;
 
         assert_eq!(result, Err(StackError::GeneralTimeout));

winc-rs/src/manager.rs

@@ -874,6 +874,39 @@ impl<X: Xfer> Manager<X> {
         }
     }
 
+    /// Registers a waker only if it is not already registered.
+    ///
+    /// # Arguments
+    ///
+    /// * `waker` - The task waker to register.
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(())` - If the waker was registered or was already registered.
+    /// * `StackError` - If too many wakers are already registered.
+    #[cfg(all(feature = "async", feature = "embassy-net"))]
+    pub(crate) fn register_waker_if_new(
+        &mut self,
+        waker: core::task::Waker,
+    ) -> Result<(), crate::StackError> {
+        // Already registered?
+        for slot in &self.wakers {
+            if let Some(ref stored) = slot {
+                if stored.will_wake(&waker) {
+                    return Ok(());
+                }
+            }
+        }
+        // Find empty slot
+        for slot in &mut self.wakers {
+            if slot.is_none() {
+                *slot = Some(waker);
+                return Ok(());
+            }
+        }
+        Err(crate::StackError::TooManyWakers)
+    }
+
     /// Sets the timeout (countdown) for the current Async/Sync operation.
     ///
     /// # Arguments