Merge pull request #74 from embassy-rs/improvements

Improvements

.github/workflows/ci.yaml

@@ -26,5 +26,23 @@ jobs:
           cd host
           cargo test --lib -- --nocapture
 
-      - name: Build examples
-        run: for i in nrf-sdc serial-hci apache-nimble; do pushd examples/$i; cargo fmt --check && cargo clippy && cargo build --release; popd; done;
+  examples:
+    runs-on: ubuntu-latest
+    needs: build
+    strategy:
+      matrix:
+        example: [nrf-sdc, serial-hci] #, apache-nimble]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Add dependencies
+        run: |
+          sudo apt-get install libudev-dev
+
+      - name: Build example ${{ matrix.example }}
+        working-directory: examples/${{ matrix.example }}
+        env:
+          CARGO_NET_GIT_FETCH_WITH_CLI: "true"
+        run: |
+          cargo fmt --check
+          cargo clippy --locked
+          cargo build --release --locked

examples/apache-nimble/Cargo.toml

@@ -19,13 +19,13 @@ trouble-host = { version = "0.1.0", path = "../../host", features = ["gatt"] }
 static_cell = "1.0.0"
 
 [patch.crates-io]
-apache-nimble = { git = "https://github.com/benbrittain/apache-nimble-sys", branch = "master" }
+apache-nimble = { git = "https://github.com/benbrittain/apache-nimble-sys.git", branch = "master" }
 bt-hci = { git = "https://github.com/alexmoon/bt-hci.git", branch = "main" }
-embassy-time = { git = "https://github.com/embassy-rs/embassy", branch = "main" }
-embassy-time-driver = { git = "https://github.com/embassy-rs/embassy", branch = "main" }
-embassy-executor = { git = "https://github.com/embassy-rs/embassy", branch = "main" }
-embassy-nrf = { git = "https://github.com/embassy-rs/embassy", branch = "main" }
-embassy-sync = { version = "0.5.0", package = "embassy-sync", git = "https://github.com/embassy-rs/embassy", rev= "53dedd2ff5076a5bb100eea26a1053cb70bf6c9d" }
+embassy-time = { git = "https://github.com/embassy-rs/embassy.git", branch = "main" }
+embassy-time-driver = { git = "https://github.com/embassy-rs/embassy.git", branch = "main" }
+embassy-executor = { git = "https://github.com/embassy-rs/embassy.git", branch = "main" }
+embassy-nrf = { git = "https://github.com/embassy-rs/embassy.git", branch = "main" }
+embassy-sync = { version = "0.5.0", package = "embassy-sync", git = "https://github.com/embassy-rs/embassy.git", rev= "53dedd2ff5076a5bb100eea26a1053cb70bf6c9d" }
 
 [profile.dev]
 debug = 2

examples/apache-nimble/src/main.rs

@@ -73,8 +73,11 @@ async fn main(spawner: embassy_executor::Spawner) {
             loop {
                 match server.next().await {
                     Ok(event) => match event {
-                        GattEvent::Write { value, .. } => {
-                            info!("{}", value);
+                        GattEvent::Write { .. } => {
+                            info!("Gatt write event!");
+                        }
+                        GattEvent::Read { .. } => {
+                            info!("Gatt read event!");
                         }
                     },
                     Err(e) => {

examples/nrf-sdc/src/bin/ble_advertise_multiple.rs

@@ -150,7 +150,6 @@ async fn main(spawner: Spawner) {
                 channel_map: None,
                 fragment: false,
                 filter_policy: AdvFilterPolicy::Unfiltered,
-                ..Default::default()
             },
             data: Advertisement::ExtNonconnectableScannableUndirected {
                 scan_data: &adv_data[..len],

examples/nrf-sdc/src/bin/ble_bas_central.rs

@@ -130,25 +130,23 @@ async fn main(spawner: Spawner) {
 
     info!("Scanning for peripheral...");
     let _ = join(ble.run(), async {
-        loop {
-            let conn = unwrap!(ble.connect(&config).await);
-            info!("Connected, creating gatt client");
+        let conn = unwrap!(ble.connect(&config).await);
+        info!("Connected, creating gatt client");
 
-            let mut client = ble.gatt_client::<10, 128>(&conn).await.unwrap();
+        let mut client = ble.gatt_client::<10, 128>(&conn).await.unwrap();
 
-            info!("Looking for battery service");
-            let services = unwrap!(client.services_by_uuid(&Uuid::new_short(0x180f)).await);
-            let service = unwrap!(services.first()).clone();
+        info!("Looking for battery service");
+        let services = unwrap!(client.services_by_uuid(&Uuid::new_short(0x180f)).await);
+        let service = unwrap!(services.first()).clone();
 
-            info!("Looking for value handle");
-            let c = unwrap!(client.characteristic_by_uuid(&service, &Uuid::new_short(0x2a19)).await);
+        info!("Looking for value handle");
+        let c = unwrap!(client.characteristic_by_uuid(&service, &Uuid::new_short(0x2a19)).await);
 
-            loop {
-                let mut data = [0; 1];
-                unwrap!(client.read_characteristic(&c, &mut data[..]).await);
-                info!("Read value: {}", data[0]);
-                Timer::after(Duration::from_secs(10)).await;
-            }
+        loop {
+            let mut data = [0; 1];
+            unwrap!(client.read_characteristic(&c, &mut data[..]).await);
+            info!("Read value: {}", data[0]);
+            Timer::after(Duration::from_secs(10)).await;
         }
     })
     .await;

examples/serial-hci/src/main.rs

@@ -105,8 +105,8 @@ async fn main() {
         async {
             loop {
                 match server.next().await {
-                    Ok(event) => {
-                        info!("Gatt event: {:?}", event);
+                    Ok(_event) => {
+                        info!("Gatt event!");
                     }
                     Err(e) => {
                         error!("Error processing GATT events: {:?}", e);

host/src/channel_manager.rs

@@ -124,7 +124,7 @@ impl<'d, const RXQ: usize> ChannelManager<'d, RXQ> {
     pub(crate) fn disconnected(&self, conn: ConnHandle) -> Result<(), Error> {
         let mut state = self.state.borrow_mut();
         for (idx, storage) in state.channels.iter_mut().enumerate() {
-            if conn.raw() == storage.conn {
+            if Some(conn) == storage.conn {
                 let _ = self.inbound[idx].close();
                 storage.close();
             }
@@ -141,7 +141,7 @@ impl<'d, const RXQ: usize> ChannelManager<'d, RXQ> {
                 // Ensure inbound is empty.
                 self.inbound[idx].clear();
                 let cid: u16 = BASE_ID + idx as u16;
-                storage.conn = conn.raw();
+                storage.conn = Some(conn);
                 storage.cid = cid;
                 f(storage);
                 return Ok(ChannelIndex(idx as u8));
@@ -164,7 +164,7 @@ impl<'d, const RXQ: usize> ChannelManager<'d, RXQ> {
             let mut state = self.state.borrow_mut();
             for (idx, chan) in state.channels.iter_mut().enumerate() {
                 match chan.state {
-                    ChannelState::PeerConnecting(req_id) if chan.conn == conn.raw() && psm.contains(&chan.psm) => {
+                    ChannelState::PeerConnecting(req_id) if chan.conn == Some(conn) && psm.contains(&chan.psm) => {
                         chan.mps = chan.mps.min(self.pool.mtu() as u16 - 4);
                         chan.mtu = chan.mtu.min(mtu);
                         chan.mtu = mtu;
@@ -346,7 +346,7 @@ impl<'d, const RXQ: usize> ChannelManager<'d, RXQ> {
 
     fn handle_connect_request(&self, conn: ConnHandle, identifier: u8, req: &LeCreditConnReq) -> Result<(), Error> {
         self.alloc(conn, |storage| {
-            storage.conn = conn.raw();
+            storage.conn = Some(conn);
             storage.psm = req.psm;
             storage.peer_cid = req.scid;
             storage.peer_credits = req.credits;
@@ -365,7 +365,7 @@ impl<'d, const RXQ: usize> ChannelManager<'d, RXQ> {
                 let mut state = self.state.borrow_mut();
                 for storage in state.channels.iter_mut() {
                     match storage.state {
-                        ChannelState::Connecting(req_id) if identifier == req_id && conn.raw() == storage.conn => {
+                        ChannelState::Connecting(req_id) if identifier == req_id && Some(conn) == storage.conn => {
                             storage.peer_cid = res.dcid;
                             storage.peer_credits = res.credits;
                             storage.mps = storage.mps.min(res.mps);
@@ -378,7 +378,8 @@ impl<'d, const RXQ: usize> ChannelManager<'d, RXQ> {
                     }
                 }
                 trace!(
-                    "[l2cap][handle_connect_response] request with id {} not found",
+                    "[l2cap][handle_connect_response][link = {}] request with id {} not found",
+                    conn.raw(),
                     identifier
                 );
                 Err(Error::NotFound)
@@ -394,7 +395,7 @@ impl<'d, const RXQ: usize> ChannelManager<'d, RXQ> {
         let mut state = self.state.borrow_mut();
         for storage in state.channels.iter_mut() {
             match storage.state {
-                ChannelState::Connected if storage.peer_cid == req.cid && conn.raw() == storage.conn => {
+                ChannelState::Connected if storage.peer_cid == req.cid && Some(conn) == storage.conn => {
                     //trace!(
                     //    "[l2cap][handle_credit_flow][cid = {}] {} += {} credits",
                     //    req.cid,
@@ -570,7 +571,7 @@ impl<'d, const RXQ: usize> ChannelManager<'d, RXQ> {
         let state = self.state.borrow();
         let chan = &state.channels[index.0 as usize];
         if chan.state == ChannelState::Connected {
-            return Ok((ConnHandle::new(chan.conn), chan.mps, chan.peer_cid));
+            return Ok((chan.conn.unwrap(), chan.mps, chan.peer_cid));
         }
         //trace!("[l2cap][connected_channel_params] channel {} closed", index);
         Err(Error::ChannelClosed)
@@ -587,7 +588,7 @@ impl<'d, const RXQ: usize> ChannelManager<'d, RXQ> {
         let (conn, cid, credits) = self.with_mut(|state| {
             let chan = &mut state.channels[index.0 as usize];
             if chan.state == ChannelState::Connected {
-                return Ok((chan.conn, chan.cid, chan.flow_control.process()));
+                return Ok((chan.conn.unwrap(), chan.cid, chan.flow_control.process()));
             }
             trace!("[l2cap][flow_control] channel {:?} not found", index);
             Err(Error::NotFound)
@@ -598,7 +599,7 @@ impl<'d, const RXQ: usize> ChannelManager<'d, RXQ> {
             let signal = LeCreditFlowInd { cid, credits };
 
             // Reuse packet buffer for signalling data to save the extra TX buffer
-            let mut hci = ble.acl(ConnHandle::new(conn), 1).await?;
+            let mut hci = ble.acl(conn, 1).await?;
             hci.signal(identifier, &signal, packet.as_mut()).await?;
         }
         Ok(())
@@ -646,7 +647,7 @@ impl<'d, const RXQ: usize> ChannelManager<'d, RXQ> {
                 ChannelState::Disconnecting | ChannelState::PeerDisconnecting => {
                     return Poll::Ready(DisconnectRequest {
                         index: ChannelIndex(idx as u8),
-                        handle: ConnHandle::new(storage.conn),
+                        handle: storage.conn.unwrap(),
                         state: &self.state,
                     });
                 }
@@ -705,12 +706,12 @@ impl<'a, 'd> DisconnectRequest<'a, 'd> {
         let mut tx = [0; 18];
         match state {
             ChannelState::PeerDisconnecting => {
-                assert_eq!(self.handle.raw(), conn);
+                assert_eq!(Some(self.handle), conn);
                 hci.signal(identifier, &DisconnectionRes { dcid, scid }, &mut tx[..])
                     .await?;
             }
             ChannelState::Disconnecting => {
-                assert_eq!(self.handle.raw(), conn);
+                assert_eq!(Some(self.handle), conn);
                 hci.signal(identifier, &DisconnectionReq { dcid, scid }, &mut tx[..])
                     .await?;
             }
@@ -762,7 +763,7 @@ impl<'d, const RXQ: usize> DynamicChannelManager for ChannelManager<'d, RXQ> {
 #[derive(Debug)]
 pub struct ChannelStorage {
     state: ChannelState,
-    conn: u16,
+    conn: Option<ConnHandle>,
     cid: u16,
     psm: u16,
     mps: u16,
@@ -797,7 +798,7 @@ impl defmt::Format for ChannelStorage {
 impl ChannelStorage {
     pub(crate) const DISCONNECTED: ChannelStorage = ChannelStorage {
         state: ChannelState::Disconnected,
-        conn: 0,
+        conn: None,
         cid: 0,
         mps: 0,
         mtu: 0,
@@ -813,11 +814,12 @@ impl ChannelStorage {
     fn close(&mut self) {
         self.state = ChannelState::Disconnected;
         self.cid = 0;
-        self.conn = 0;
+        self.conn = None;
         self.mps = 0;
         self.mtu = 0;
         self.psm = 0;
         self.peer_cid = 0;
+        self.flow_control = CreditFlowControl::new(CreditFlowPolicy::Every(1), 0);
         self.peer_credits = 0;
     }
 }