wpan_ get net example actually working

4 files changed, 40 insertions, 34 deletions

diff --git a/embassy-stm32-wpan/src/mac/control.rs b/embassy-stm32-wpan/src/mac/control.rs
index 8fb971da3..d2a7b65ee 100644
--- a/embassy-stm32-wpan/src/mac/control.rs
+++ b/embassy-stm32-wpan/src/mac/control.rs
@@ -38,7 +38,7 @@ impl<'a> Control<'a> {
         }
     }
 
-    pub async fn init_link(&mut self, short_address: [u8; 2], extended_address: [u8; 8], pan_id: [u8; 2]) {
+    pub async fn init_link(&mut self, pan_id: [u8; 2]) {
         debug!("resetting");
 
         debug!(
@@ -52,12 +52,19 @@ impl<'a> Control<'a> {
             .await
         );
 
+        let (short_address, mac_address) = critical_section::with(|cs| {
+            let mut network_state = self.network_state.borrow(cs).borrow_mut();
+
+            network_state.pan_id = pan_id;
+
+            (network_state.short_addr, network_state.mac_addr)
+        });
+
         debug!("setting extended address");
-        let extended_address: u64 = u64::from_be_bytes(extended_address);
         debug!(
             "{:#x}",
             self.send_command_and_get_response(&SetRequest {
-                pib_attribute_ptr: &extended_address as *const _ as *const u8,
+                pib_attribute_ptr: &u64::from_be_bytes(mac_address) as *const _ as *const u8,
                 pib_attribute: PibId::ExtendedAddress,
             })
             .await
@@ -66,11 +73,10 @@ impl<'a> Control<'a> {
         );
 
         debug!("setting short address");
-        let short_address: u16 = u16::from_be_bytes(short_address);
         debug!(
             "{:#x}",
             self.send_command_and_get_response(&SetRequest {
-                pib_attribute_ptr: &short_address as *const _ as *const u8,
+                pib_attribute_ptr: &u16::from_be_bytes(short_address) as *const _ as *const u8,
                 pib_attribute: PibId::ShortAddress,
             })
             .await
@@ -78,10 +84,6 @@ impl<'a> Control<'a> {
             .await
         );
 
-        critical_section::with(|cs| {
-            self.network_state.borrow(cs).borrow_mut().mac_addr = extended_address.to_be_bytes();
-        });
-
         debug!("setting association permit");
         let association_permit: bool = true;
         debug!(
@@ -186,20 +188,8 @@ impl<'a> Future for EventToken<'a> {
     type Output = MacEvent<'a>;
 
     fn poll(self: core::pin::Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
-        self.rx_event_channel.lock(|s| {
-            let signal = s.borrow_mut();
-            let signal = match &*signal {
-                Some(s) => s,
-                _ => unreachable!(),
-            };
-
-            let result = match signal.wait().poll_unpin(cx) {
-                Poll::Ready(mac_event) => Poll::Ready(mac_event),
-                Poll::Pending => Poll::Pending,
-            };
-
-            result
-        })
+        self.rx_event_channel
+            .lock(|s| s.borrow_mut().as_mut().unwrap().wait().poll_unpin(cx))
     }
 }
 
diff --git a/embassy-stm32-wpan/src/mac/driver.rs b/embassy-stm32-wpan/src/mac/driver.rs
index 819299b48..5592723a2 100644
--- a/embassy-stm32-wpan/src/mac/driver.rs
+++ b/embassy-stm32-wpan/src/mac/driver.rs
@@ -17,6 +17,8 @@ use crate::sub::mac::{Mac, MacRx, MacTx};
 
 pub struct NetworkState {
     pub mac_addr: [u8; 8],
+    pub short_addr: [u8; 2],
+    pub pan_id: [u8; 2],
     pub link_state: LinkState,
     pub link_waker: AtomicWaker,
 }
@@ -25,6 +27,8 @@ impl NetworkState {
     pub const fn new() -> Self {
         Self {
             mac_addr: [0u8; 8],
+            short_addr: [0u8; 2],
+            pan_id: [0u8; 2],
             link_state: LinkState::Down,
             link_waker: AtomicWaker::new(),
         }
@@ -68,7 +72,11 @@ pub struct Driver<'d> {
 }
 
 impl<'d> Driver<'d> {
-    pub fn new(driver_state: &'d mut DriverState<'d>) -> (Self, Runner<'d>, Control<'d>) {
+    pub fn new(
+        driver_state: &'d mut DriverState<'d>,
+        short_address: [u8; 2],
+        mac_address: [u8; 8],
+    ) -> (Self, Runner<'d>, Control<'d>) {
         (
             Self {
                 tx_data_channel: &driver_state.tx_data_channel,
@@ -85,6 +93,8 @@ impl<'d> Driver<'d> {
                 &driver_state.mac_tx,
                 &mut driver_state.tx_buf_queue,
                 &driver_state.network_state,
+                short_address,
+                mac_address,
             ),
             Control::new(
                 &driver_state.rx_event_channel,
diff --git a/embassy-stm32-wpan/src/mac/runner.rs b/embassy-stm32-wpan/src/mac/runner.rs
index 26fdf23e0..92c74c2ee 100644
--- a/embassy-stm32-wpan/src/mac/runner.rs
+++ b/embassy-stm32-wpan/src/mac/runner.rs
@@ -34,7 +34,7 @@ pub struct Runner<'a> {
 }
 
 impl<'a> Runner<'a> {
-    pub fn new(
+    pub(crate) fn new(
         rx_event_channel: &'a ZeroCopyPubSub<CriticalSectionRawMutex, MacEvent<'a>>,
         rx_data_channel: &'a Channel<CriticalSectionRawMutex, MacEvent<'a>, 1>,
         mac_rx: &'a mut MacRx,
@@ -43,11 +43,20 @@ impl<'a> Runner<'a> {
         mac_tx: &'a Mutex<CriticalSectionRawMutex, MacTx>,
         tx_buf_queue: &'a mut [[u8; MTU]; BUF_SIZE],
         network_state: &'a blocking_mutex::Mutex<CriticalSectionRawMutex, RefCell<NetworkState>>,
+        short_address: [u8; 2],
+        mac_address: [u8; 8],
     ) -> Self {
         for buf in tx_buf_queue {
             tx_buf_channel.try_send(buf).unwrap();
         }
 
+        critical_section::with(|cs| {
+            let mut network_state = network_state.borrow(cs).borrow_mut();
+
+            network_state.mac_addr = mac_address;
+            network_state.short_addr = short_address;
+        });
+
         Self {
             rx_event_channel,
             rx_data_channel,
@@ -70,12 +79,7 @@ impl<'a> Runner<'a> {
                             }
                             _ => {
                                 self.rx_event_channel.lock(|s| {
-                                    match &*s.borrow() {
-                                        Some(signal) => {
-                                            signal.signal(mac_event);
-                                        }
-                                        None => {}
-                                    };
+                                    s.borrow().as_ref().map(|signal| signal.signal(mac_event));
                                 });
                             }
                         }
@@ -89,7 +93,9 @@ impl<'a> Runner<'a> {
                     let (buf, len) = self.tx_data_channel.receive().await;
                     let mac_tx = self.mac_tx.lock().await;
 
-                    // TODO: skip this if the link state is down
+                    let pan_id = critical_section::with(|cs| self.network_state.borrow(cs).borrow().pan_id);
+
+                    // TODO: get the destination address from the packet instead of using the broadcast address
 
                     // The mutex should be dropped on the next loop iteration
                     mac_tx
@@ -97,7 +103,7 @@ impl<'a> Runner<'a> {
                             DataRequest {
                                 src_addr_mode: AddressMode::Short,
                                 dst_addr_mode: AddressMode::Short,
-                                dst_pan_id: PanId([0x1A, 0xAA]),
+                                dst_pan_id: PanId(pan_id),
                                 dst_address: MacAddress::BROADCAST,
                                 msdu_handle: msdu_handle,
                                 ack_tx: 0x00,
diff --git a/embassy-stm32-wpan/src/sub/mm.rs b/embassy-stm32-wpan/src/sub/mm.rs
index 62d0de8bd..a90c6ee55 100644
--- a/embassy-stm32-wpan/src/sub/mm.rs
+++ b/embassy-stm32-wpan/src/sub/mm.rs
@@ -46,7 +46,7 @@ impl MemoryManager {
         Self { _private: () }
     }
 
-    pub async fn run_queue(&self) {
+    pub async fn run_queue(&self) -> ! {
         loop {
             poll_fn(|cx| unsafe {
                 MM_WAKER.register(cx.waker());