Merge pull request #468 from HaoboGu/example/bonding

Improve bonding example, add ESP32 bonding example

Author: HaoboGu

examples/apps/src/ble_bas_peripheral_bonding.rs

@@ -12,12 +12,38 @@ 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]
 struct Server {
     battery_service: BatteryService,
+    hid_service: HidService,
+}
+
+static DESC: [u8; 67] = [
+    5u8, 1u8, 9u8, 6u8, 161u8, 1u8, 5u8, 7u8, 25u8, 224u8, 41u8, 231u8, 21u8, 0u8, 37u8, 1u8, 117u8, 1u8, 149u8, 8u8,
+    129u8, 2u8, 21u8, 0u8, 38u8, 255u8, 0u8, 117u8, 8u8, 149u8, 1u8, 129u8, 3u8, 5u8, 8u8, 25u8, 1u8, 41u8, 5u8, 37u8,
+    1u8, 117u8, 1u8, 149u8, 5u8, 145u8, 2u8, 149u8, 3u8, 145u8, 3u8, 5u8, 7u8, 25u8, 0u8, 41u8, 221u8, 38u8, 255u8,
+    0u8, 117u8, 8u8, 149u8, 6u8, 129u8, 0u8, 192u8,
+];
+
+#[gatt_service(uuid = service::HUMAN_INTERFACE_DEVICE)]
+pub(crate) struct HidService {
+    #[characteristic(uuid = "2a4a", read, value = [0x01, 0x01, 0x00, 0x03])]
+    pub(crate) hid_info: [u8; 4],
+    #[characteristic(uuid = "2a4b", read, value = DESC)]
+    pub(crate) report_map: [u8; 67],
+    #[characteristic(uuid = "2a4c", write_without_response)]
+    pub(crate) hid_control_point: u8,
+    #[characteristic(uuid = "2a4e", read, write_without_response, value = 1)]
+    pub(crate) protocol_mode: u8,
+    #[descriptor(uuid = "2908", read, value = [0u8, 1u8])]
+    #[characteristic(uuid = "2a4d", read, notify)]
+    pub(crate) input_keyboard: [u8; 8],
+    #[descriptor(uuid = "2908", read, value = [0u8, 2u8])]
+    #[characteristic(uuid = "2a4d", read, write, write_without_response)]
+    pub(crate) output_keyboard: [u8; 1],
 }
 
 /// Battery service
@@ -47,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))
         }
     }
@@ -75,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 {
@@ -120,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
@@ -147,8 +185,7 @@ where
         info!("Loaded bond information");
         stack.add_bond_information(bond_info).unwrap();
         true
-    }
-    else {
+    } else {
         info!("No bond information found");
         false
     };
@@ -160,9 +197,9 @@ where
     info!("Starting advertising and GATT service");
     let server = Server::new_with_config(GapConfig::Peripheral(PeripheralConfig {
         name: "TrouBLE",
-        appearance: &appearance::power_device::GENERIC_POWER_DEVICE,
+        appearance: &appearance::human_interface_device::GENERIC_HUMAN_INTERFACE_DEVICE,
     }))
-        .unwrap();
+    .unwrap();
 
     let _ = join(ble_task(runner), async {
         loop {
@@ -176,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")]
@@ -185,7 +223,7 @@ where
             }
         }
     })
-        .await;
+    .await;
 }
 
 /// This is a background task that is required to run forever alongside any other BLE tasks.
@@ -217,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();
@@ -294,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(&[[0x0f, 0x18]]),
+            AdStructure::ServiceUuids16(&[
+                service::BATTERY.to_le_bytes(),
+                service::HUMAN_INTERFACE_DEVICE.to_le_bytes(),
+            ]),
             AdStructure::CompleteLocalName(name.as_bytes()),
         ],
         &mut advertiser_data[..],

examples/esp32/Cargo.lock

@@ -6,11 +6,13 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 embassy-executor = "0.9.0"
+embassy-embedded-hal = "0.5"
 esp-bootloader-esp-idf = "0.2.0"
 esp-backtrace = { version = "0.17.0", features = [ "panic-handler", "println" ] }
 esp-hal = { version = "1.0.0-rc.0", features = [ "unstable" ] }
 esp-hal-embassy = { version = "0.9.0" }
 esp-alloc = { version = "0.8.0" }
+esp-storage = { version = "0.7.0" }
 esp-println = { version = "0.15.0", features = ["log-04"] }
 esp-radio = { version = "0.15.0", features = [ "unstable", "ble" ] }
 esp-preempt = { version = "0.0.1", features = ["log-04"] }
@@ -21,12 +23,12 @@ static_cell = "2"
 [features]
 default = ["esp32c3"]
 
-esp32 = ["esp-hal/esp32", "esp-backtrace/esp32", "esp-hal-embassy/esp32", "esp-println/esp32", "esp-radio/esp32", "esp-preempt/esp32", "esp-bootloader-esp-idf/esp32"]
-esp32c2 = ["esp-hal/esp32c2", "esp-backtrace/esp32c2", "esp-hal-embassy/esp32c2", "esp-println/esp32c2", "esp-preempt/esp32c2", "esp-radio/esp32c2", "esp-bootloader-esp-idf/esp32c2"]
-esp32c3 = ["esp-hal/esp32c3", "esp-backtrace/esp32c3", "esp-hal-embassy/esp32c3", "esp-println/esp32c3", "esp-preempt/esp32c3", "esp-radio/esp32c3", "esp-bootloader-esp-idf/esp32c3"]
-esp32c6 = ["esp-hal/esp32c6", "esp-backtrace/esp32c6", "esp-hal-embassy/esp32c6", "esp-println/esp32c6", "esp-preempt/esp32c6", "esp-radio/esp32c6", "esp-bootloader-esp-idf/esp32c6"]
-esp32h2 = ["esp-hal/esp32h2", "esp-backtrace/esp32h2", "esp-hal-embassy/esp32h2", "esp-println/esp32h2", "esp-preempt/esp32h2", "esp-radio/esp32h2", "esp-bootloader-esp-idf/esp32h2"]
-esp32s3 = ["esp-hal/esp32s3", "esp-backtrace/esp32s3", "esp-hal-embassy/esp32s3", "esp-println/esp32s3", "esp-preempt/esp32s3", "esp-radio/esp32s3", "esp-bootloader-esp-idf/esp32s3"]
+esp32 = ["esp-hal/esp32", "esp-backtrace/esp32", "esp-hal-embassy/esp32", "esp-println/esp32", "esp-storage/esp32", "esp-radio/esp32", "esp-preempt/esp32", "esp-bootloader-esp-idf/esp32"]
+esp32c2 = ["esp-hal/esp32c2", "esp-backtrace/esp32c2", "esp-hal-embassy/esp32c2", "esp-println/esp32c2", "esp-storage/esp32c2", "esp-preempt/esp32c2", "esp-radio/esp32c2", "esp-bootloader-esp-idf/esp32c2"]
+esp32c3 = ["esp-hal/esp32c3", "esp-backtrace/esp32c3", "esp-hal-embassy/esp32c3", "esp-println/esp32c3", "esp-storage/esp32c3", "esp-preempt/esp32c3", "esp-radio/esp32c3", "esp-bootloader-esp-idf/esp32c3"]
+esp32c6 = ["esp-hal/esp32c6", "esp-backtrace/esp32c6", "esp-hal-embassy/esp32c6", "esp-println/esp32c6", "esp-storage/esp32c6", "esp-preempt/esp32c6", "esp-radio/esp32c6", "esp-bootloader-esp-idf/esp32c6"]
+esp32h2 = ["esp-hal/esp32h2", "esp-backtrace/esp32h2", "esp-hal-embassy/esp32h2", "esp-println/esp32h2", "esp-storage/esp32h2", "esp-preempt/esp32h2", "esp-radio/esp32h2", "esp-bootloader-esp-idf/esp32h2"]
+esp32s3 = ["esp-hal/esp32s3", "esp-backtrace/esp32s3", "esp-hal-embassy/esp32s3", "esp-println/esp32s3", "esp-storage/esp32s3", "esp-preempt/esp32s3", "esp-radio/esp32s3", "esp-bootloader-esp-idf/esp32s3"]
 
 security = [
     "trouble-example-apps/security",
@@ -54,9 +56,14 @@ required-features = ["security"]
 name = "ble_bas_peripheral_sec"
 required-features = ["security"]
 
+[[bin]]
+name = "ble_bas_peripheral_bonding"
+required-features = ["security"]
+
 [patch.crates-io]
 esp-radio = {git = "https://github.com/lulf/esp-hal.git", branch = "bt-hci-fix"}
 esp-preempt = {git = "https://github.com/lulf/esp-hal.git", branch = "bt-hci-fix"}
+esp-storage = {git = "https://github.com/lulf/esp-hal.git", branch = "bt-hci-fix"}
 esp-backtrace = {git = "https://github.com/lulf/esp-hal.git", branch = "bt-hci-fix"}
 esp-hal = {git = "https://github.com/lulf/esp-hal.git", branch = "bt-hci-fix"}
 esp-bootloader-esp-idf = {git = "https://github.com/lulf/esp-hal.git", branch = "bt-hci-fix"}

examples/esp32/Cargo.toml

@@ -0,0 +1,58 @@
+#![no_std]
+#![no_main]
+
+use embassy_executor::Spawner;
+use esp_hal::clock::CpuClock;
+use esp_hal::rng::{Trng, TrngSource};
+use esp_hal::timer::timg::TimerGroup;
+use esp_radio::Controller;
+use esp_radio::ble::controller::BleConnector;
+use esp_storage::FlashStorage;
+use static_cell::StaticCell;
+use trouble_example_apps::ble_bas_peripheral_bonding;
+use trouble_host::prelude::ExternalController;
+use {esp_alloc as _, esp_backtrace as _};
+
+esp_bootloader_esp_idf::esp_app_desc!();
+
+#[esp_hal_embassy::main]
+async fn main(_s: Spawner) {
+    esp_println::logger::init_logger_from_env();
+    let peripherals = esp_hal::init(esp_hal::Config::default().with_cpu_clock(CpuClock::max()));
+    esp_alloc::heap_allocator!(size: 72 * 1024);
+    let timg0 = TimerGroup::new(peripherals.TIMG0);
+    #[cfg(target_arch = "riscv32")]
+    let software_interrupt = esp_hal::interrupt::software::SoftwareInterruptControl::new(peripherals.SW_INTERRUPT);
+
+    esp_preempt::start(
+        timg0.timer0,
+        #[cfg(target_arch = "riscv32")]
+        software_interrupt.software_interrupt0,
+    );
+
+    let _trng_source = TrngSource::new(peripherals.RNG, peripherals.ADC1);
+    let mut trng = Trng::try_new().unwrap(); // Ok when there's a TrngSource accessible
+
+    static RADIO: StaticCell<Controller<'static>> = StaticCell::new();
+    let radio = RADIO.init(esp_radio::init().unwrap());
+
+    #[cfg(not(feature = "esp32"))]
+    {
+        let systimer = esp_hal::timer::systimer::SystemTimer::new(peripherals.SYSTIMER);
+        esp_hal_embassy::init(systimer.alarm0);
+    }
+    #[cfg(feature = "esp32")]
+    {
+        esp_hal_embassy::init(timg0.timer1);
+    }
+
+    let bluetooth = peripherals.BT;
+    let connector = BleConnector::new(radio, bluetooth);
+    let controller: ExternalController<_, 20> = ExternalController::new(connector);
+
+    // Initialize the flash
+    let mut flash = embassy_embedded_hal::adapter::BlockingAsync::new(FlashStorage::new(peripherals.FLASH));
+
+    // ble_bas_peripheral_sec::run(controller, &mut trng).await;
+    ble_bas_peripheral_bonding::run(controller, &mut trng, &mut flash).await;
+}