Merge branch 'main' into pr-typos-and-what

Author: finalyards

examples/apps/src/ble_bas_central_multiple.rs

@@ -0,0 +1,82 @@
+use embassy_futures::join::{join, join3};
+use embassy_time::{Duration, Timer};
+use trouble_host::prelude::*;
+
+/// Max number of connections
+const CONNECTIONS_MAX: usize = 2;
+
+/// Max number of L2CAP channels.
+const L2CAP_CHANNELS_MAX: usize = 4; // Signal + att + CoC
+
+pub async fn run<C>(controller: C)
+where
+    C: Controller,
+{
+    // Using a fixed "random" address can be useful for testing. In real scenarios, one would
+    // use e.g. the MAC 6 byte array as the address (how to get that varies by the platform).
+    let address: Address = Address::random([0xff, 0x8f, 0x1b, 0x05, 0xe4, 0xff]);
+    info!("Our address = {:?}", address);
+
+    let mut resources: HostResources<DefaultPacketPool, CONNECTIONS_MAX, L2CAP_CHANNELS_MAX> = HostResources::new();
+    let stack = trouble_host::new(controller, &mut resources).set_random_address(address);
+    let Host { mut runner, .. } = stack.build();
+
+    info!("Scanning for peripheral...");
+    // NOTE: Modify this to match the address of the peripheral you want to connect to.
+    let fut1 = scan(&stack, [0xff, 0x8f, 0x1a, 0x05, 0xe4, 0xff]);
+    let fut2 = scan(&stack, [0xff, 0x8f, 0x1a, 0x05, 0xe5, 0xff]);
+    let _ = join3(runner.run(), fut1, fut2).await;
+}
+
+async fn scan<'a, C: Controller, P: PacketPool>(stack: &'a Stack<'a, C, P>, addr: [u8; 6]) {
+    let Host { mut central, .. } = stack.build();
+    let target: Address = Address::random(addr);
+
+    let config = ConnectConfig {
+        connect_params: Default::default(),
+        scan_config: ScanConfig {
+            filter_accept_list: &[(target.kind, &target.addr)],
+            ..Default::default()
+        },
+    };
+
+    info!("Connecting to {:?}", addr);
+    let conn = central.connect(&config).await.unwrap();
+    info!("Connected, creating gatt client");
+
+    let client = GattClient::<C, _, 10>::new(stack, &conn).await.unwrap();
+
+    let _ = join(client.task(), async {
+        info!("Looking for battery service");
+        let services = client.services_by_uuid(&Uuid::new_short(0x180f)).await.unwrap();
+        let service = services.first().unwrap().clone();
+
+        info!("Looking for value handle");
+        let c: Characteristic<u8> = client
+            .characteristic_by_uuid(&service, &Uuid::new_short(0x2a19))
+            .await
+            .unwrap();
+
+        info!("Subscribing notifications");
+        let mut listener = client.subscribe(&c, false).await.unwrap();
+
+        let _ = join(
+            async {
+                loop {
+                    let mut data = [0; 1];
+                    client.read_characteristic(&c, &mut data[..]).await.unwrap();
+                    info!("Read value: {}", data[0]);
+                    Timer::after(Duration::from_secs(10)).await;
+                }
+            },
+            async {
+                loop {
+                    let data = listener.next().await;
+                    info!("Got notification: {:?} (val: {})", data.as_ref(), data.as_ref()[0]);
+                }
+            },
+        )
+        .await;
+    })
+    .await;
+}

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/apps/src/lib.rs

@@ -7,6 +7,7 @@ pub(crate) mod fmt;
 pub mod ble_advertise;
 pub mod ble_advertise_multiple;
 pub mod ble_bas_central;
+pub mod ble_bas_central_multiple;
 pub mod ble_bas_central_sec;
 pub mod ble_bas_peripheral;
 pub mod ble_bas_peripheral_sec;

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"}