feat(example): use internal flash in nrf-sdc bonding example, update deps, fix bonding example issue

Signed-off-by: Haobo Gu <[email protected]>

Author: HaoboGu

examples/apps/src/ble_bas_peripheral_bonding.rs

@@ -12,7 +12,7 @@ use trouble_host::prelude::*;
 const CONNECTIONS_MAX: usize = 1;
 
 /// Max number of L2CAP channels.
-const L2CAP_CHANNELS_MAX: usize = 2; // Signal + att
+const L2CAP_CHANNELS_MAX: usize = 4; // Signal + att
 
 // GATT Server definition
 #[gatt_server]
@@ -46,7 +46,6 @@ pub(crate) struct HidService {
     pub(crate) output_keyboard: [u8; 1],
 }
 
-
 /// Battery service
 #[gatt_service(uuid = service::BATTERY)]
 struct BatteryService {
@@ -74,8 +73,7 @@ impl Key for StoredAddr {
     fn deserialize_from(buffer: &[u8]) -> Result<(Self, usize), SerializationError> {
         if buffer.len() < 6 {
             Err(SerializationError::BufferTooSmall)
-        }
-        else {
+        } else {
             Ok((StoredAddr(BdAddr::new(buffer[0..6].try_into().unwrap())), 6))
         }
     }
@@ -102,43 +100,56 @@ impl<'a> Value<'a> for StoredBondInformation {
 
     fn deserialize_from(buffer: &'a [u8]) -> Result<Self, SerializationError>
     where
-        Self: Sized
+        Self: Sized,
     {
         if buffer.len() < 17 {
             Err(SerializationError::BufferTooSmall)
-        }
-        else {
+        } else {
             let ltk = LongTermKey::from_le_bytes(buffer[0..16].try_into().unwrap());
             let security_level = match buffer[16] {
                 0 => SecurityLevel::NoEncryption,
                 1 => SecurityLevel::Encrypted,
                 2 => SecurityLevel::EncryptedAuthenticated,
-                _ => return Err(SerializationError::InvalidData)
+                _ => return Err(SerializationError::InvalidData),
             };
             Ok(StoredBondInformation { ltk, security_level })
         }
     }
 }
 
 fn flash_range<S: NorFlash>() -> Range<u32> {
-    0..2*S::ERASE_SIZE as u32
+    0..2 * S::ERASE_SIZE as u32
 }
 
-async fn store_bonding_info<S: NorFlash>(storage: &mut S, info: &BondInformation) -> Result<(), sequential_storage::Error<S::Error>> {
-    // Assumes that S::ERASE_SIZE is large enough
-    sequential_storage::erase_all(storage, 0..S::ERASE_SIZE as u32).await?;
-    let mut buffer = [0;32];
+async fn store_bonding_info<S: NorFlash>(
+    storage: &mut S,
+    info: &BondInformation,
+) -> Result<(), sequential_storage::Error<S::Error>> {
+    // Use flash range from 640KB, should be good for both ESP32 & nRF52840 examples
+    let start_addr = 0xA0000 as u32;
+    let storage_range = start_addr..(start_addr + 8 * S::ERASE_SIZE as u32);
+    sequential_storage::erase_all(storage, storage_range.clone()).await?;
+    let mut buffer = [0; 32];
     let key = StoredAddr(info.identity.bd_addr);
-    let value = StoredBondInformation { ltk: info.ltk, security_level: info.security_level };
-    sequential_storage::map::store_item(storage, flash_range::<S>(), &mut NoCache::new(), &mut buffer, &key, &value).await?;
+    let value = StoredBondInformation {
+        ltk: info.ltk,
+        security_level: info.security_level,
+    };
+    sequential_storage::map::store_item(storage, storage_range, &mut NoCache::new(), &mut buffer, &key, &value).await?;
     Ok(())
 }
 
-async fn load_bonding_info<S: NorFlash>(storage: &mut S) -> Option<BondInformation>
-{
-    let mut buffer = [0;32];
+async fn load_bonding_info<S: NorFlash>(storage: &mut S) -> Option<BondInformation> {
+    let mut buffer = [0; 32];
     let mut cache = NoCache::new();
-    let mut iter = sequential_storage::map::fetch_all_items::<StoredAddr, _, _>(storage, flash_range::<S>(), &mut cache, &mut buffer).await.ok()?;
+    let mut iter = sequential_storage::map::fetch_all_items::<StoredAddr, _, _>(
+        storage,
+        flash_range::<S>(),
+        &mut cache,
+        &mut buffer,
+    )
+    .await
+    .ok()?;
     while let Some((key, value)) = iter.next::<StoredBondInformation>(&mut buffer).await.ok()? {
         return Some(BondInformation {
             identity: Identity {
@@ -147,7 +158,7 @@ async fn load_bonding_info<S: NorFlash>(storage: &mut S) -> Option<BondInformati
             },
             security_level: value.security_level,
             is_bonded: true,
-            ltk: value.ltk
+            ltk: value.ltk,
         });
     }
     None
@@ -174,8 +185,7 @@ where
         info!("Loaded bond information");
         stack.add_bond_information(bond_info).unwrap();
         true
-    }
-    else {
+    } else {
         info!("No bond information found");
         false
     };
@@ -189,7 +199,7 @@ where
         name: "TrouBLE",
         appearance: &appearance::human_interface_device::GENERIC_HUMAN_INTERFACE_DEVICE,
     }))
-        .unwrap();
+    .unwrap();
 
     let _ = join(ble_task(runner), async {
         loop {
@@ -203,6 +213,7 @@ where
                     // run until any task ends (usually because the connection has been closed),
                     // then return to advertising state.
                     select(a, b).await;
+                    info!("Connection dropped");
                 }
                 Err(e) => {
                     #[cfg(feature = "defmt")]
@@ -212,7 +223,7 @@ where
             }
         }
     })
-        .await;
+    .await;
 }
 
 /// This is a background task that is required to run forever alongside any other BLE tasks.
@@ -244,13 +255,18 @@ async fn ble_task<C: Controller, P: PacketPool>(mut runner: Runner<'_, C, P>) {
 ///
 /// This function will handle the GATT events and process them.
 /// This is how we interact with read and write requests.
-async fn gatt_events_task<S: NorFlash>(storage: &mut S, server: &Server<'_>, conn: &GattConnection<'_, '_, DefaultPacketPool>, bond_stored: &mut bool) -> Result<(), Error> {
+async fn gatt_events_task<S: NorFlash>(
+    storage: &mut S,
+    server: &Server<'_>,
+    conn: &GattConnection<'_, '_, DefaultPacketPool>,
+    bond_stored: &mut bool,
+) -> Result<(), Error> {
     let level = server.battery_service.level;
     let reason = loop {
         match conn.next().await {
             GattConnectionEvent::Disconnected { reason } => break reason,
             #[cfg(feature = "security")]
-            GattConnectionEvent::PairingComplete { security_level, bond} => {
+            GattConnectionEvent::PairingComplete { security_level, bond } => {
                 info!("[gatt] pairing complete: {:?}", security_level);
                 if let Some(bond) = bond {
                     store_bonding_info(storage, &bond).await.unwrap();
@@ -321,7 +337,10 @@ async fn advertise<'values, 'server, C: Controller>(
     let len = AdStructure::encode_slice(
         &[
             AdStructure::Flags(LE_GENERAL_DISCOVERABLE | BR_EDR_NOT_SUPPORTED),
-            AdStructure::ServiceUuids16(&[service::BATTERY.to_le_bytes(), service::HUMAN_INTERFACE_DEVICE.to_le_bytes()]),
+            AdStructure::ServiceUuids16(&[
+                service::BATTERY.to_le_bytes(),
+                service::HUMAN_INTERFACE_DEVICE.to_le_bytes(),
+            ]),
             AdStructure::CompleteLocalName(name.as_bytes()),
         ],
         &mut advertiser_data[..],

examples/nrf-sdc/Cargo.lock

@@ -7,15 +7,15 @@ resolver = "2"
 [dependencies]
 embassy-executor = { version = "0.9", default-features = false, features = ["arch-cortex-m", "executor-thread", "defmt", "executor-interrupt"] }
 embassy-time = { version = "0.5", default-features = false, features = ["defmt", "defmt-timestamp-uptime"] }
-embassy-nrf = { version = "0.7", default-features = false, features = ["defmt", "time-driver-rtc1", "gpiote", "unstable-pac", "rt"] }
+embassy-nrf = { version = "0.8", default-features = false, features = ["defmt", "time-driver-rtc1", "gpiote", "unstable-pac", "rt"] }
 embassy-futures = "0.1.1"
 embassy-sync = { version = "0.7", features = ["defmt"] }
 
 futures = { version = "0.3", default-features = false, features = ["async-await"]}
 nrf-sdc = { version = "0.4", default-features = false, features = ["defmt", "peripheral", "central"] }
 nrf-mpsl = { version = "0.3", default-features = false, features = ["defmt", "critical-section-impl"] }
 bt-hci = { version = "0.6", default-features = false, features = ["defmt"] }
-trouble-host = { path = "../../host", features = ["derive", "scan"] }
+trouble-host = { path = "../../host", features = ["derive", "scan", "gatt"] }
 trouble-example-apps = { version = "0.1.0", path = "../apps", features = ["defmt"] }
 
 defmt = "1.0"
@@ -41,8 +41,8 @@ debug = 2
 #embassy-time-driver = {path = "../../../embassy/embassy-time-driver"}
 #embassy-embedded-hal = {path = "../../../embassy/embassy-embedded-hal"}
 #embassy-hal-internal = {path = "../../../embassy/embassy-hal-internal"}
-nrf-sdc = { git = "https://github.com/alexmoon/nrf-sdc.git", rev = "1bc7380cd5d7a031f37511b69da13fc6caded816"}
-nrf-mpsl = { git = "https://github.com/alexmoon/nrf-sdc.git", rev = "1bc7380cd5d7a031f37511b69da13fc6caded816"}
+nrf-sdc = { git = "https://github.com/alexmoon/nrf-sdc.git", rev = "11d5c3c"}
+nrf-mpsl = { git = "https://github.com/alexmoon/nrf-sdc.git", rev = "11d5c3c"}
 #bt-hci = { git = "https://github.com/embassy-rs/bt-hci.git", rev = "83a9e179ff019ed60abb73705f54383f89fc60fc" }
 
 [features]

examples/nrf-sdc/Cargo.toml

@@ -6,6 +6,7 @@ use embassy_executor::Spawner;
 use embassy_nrf::mode::Async;
 use embassy_nrf::peripherals::RNG;
 use embassy_nrf::{bind_interrupts, qspi, rng};
+use nrf_sdc::mpsl::Flash;
 use nrf_sdc::mpsl::MultiprotocolServiceLayer;
 use nrf_sdc::{self as sdc, mpsl};
 use rand_chacha::ChaCha12Rng;
@@ -40,7 +41,7 @@ const L2CAP_MTU: usize = 72;
 
 fn build_sdc<'d, const N: usize>(
     p: nrf_sdc::Peripherals<'d>,
-    rng: &'d mut rng::Rng<RNG, Async>,
+    rng: &'d mut rng::Rng<Async>,
     mpsl: &'d MultiprotocolServiceLayer,
     mem: &'d mut sdc::Mem<N>,
 ) -> Result<nrf_sdc::SoftdeviceController<'d>, nrf_sdc::Error> {
@@ -64,7 +65,13 @@ async fn main(spawner: Spawner) {
         skip_wait_lfclk_started: mpsl::raw::MPSL_DEFAULT_SKIP_WAIT_LFCLK_STARTED != 0,
     };
     static MPSL: StaticCell<MultiprotocolServiceLayer> = StaticCell::new();
-    let mpsl = MPSL.init(unwrap!(mpsl::MultiprotocolServiceLayer::new(mpsl_p, Irqs, lfclk_cfg)));
+    static SESSION_MEM: StaticCell<mpsl::SessionMem<1>> = StaticCell::new();
+    let mpsl = MPSL.init(unwrap!(mpsl::MultiprotocolServiceLayer::with_timeslots(
+        mpsl_p,
+        Irqs,
+        lfclk_cfg,
+        SESSION_MEM.init(mpsl::SessionMem::new())
+    )));
     spawner.must_spawn(mpsl_task(&*mpsl));
 
     let sdc_p = sdc::Peripherals::new(
@@ -75,27 +82,11 @@ async fn main(spawner: Spawner) {
     let mut rng = rng::Rng::new(p.RNG, Irqs);
     let mut rng_2 = ChaCha12Rng::from_rng(&mut rng).unwrap();
 
-    let mut sdc_mem = sdc::Mem::<3312>::new();
+    let mut sdc_mem = sdc::Mem::<5000>::new();
     let sdc = unwrap!(build_sdc(sdc_p, &mut rng, mpsl, &mut sdc_mem));
 
-    // Config for the MX25R64 present in the nRF52840 DK
-    let mut config = qspi::Config::default();
-    config.read_opcode = qspi::ReadOpcode::READ4IO;
-    config.write_opcode = qspi::WriteOpcode::PP4IO;
-    config.write_page_size = qspi::WritePageSize::_256BYTES;
-    config.frequency = qspi::Frequency::M32;
-    config.capacity = 8*1024*1024;
+    // Use internal Flash as the storage
+    let mut flash = Flash::take(mpsl, p.NVMC);
 
-    let mut qspi: qspi::Qspi<_> = qspi::Qspi::new(
-        p.QSPI, Irqs, p.P0_19, p.P0_17, p.P0_20, p.P0_21, p.P0_22, p.P0_23, config,
-    );
-    let input = embassy_nrf::gpio::Input::new(p.P0_11, embassy_nrf::gpio::Pull::Up);
-    // Allow time for button to settle
-    embassy_time::Timer::after(embassy_time::Duration::from_millis(100)).await;
-    if input.is_low() {
-        defmt::info!("Erasing flash");
-        qspi.erase(0).await.unwrap();
-    }
-
-    ble_bas_peripheral_bonding::run(sdc, &mut rng_2, &mut qspi).await;
+    ble_bas_peripheral_bonding::run(sdc, &mut rng_2, &mut flash).await;
 }