feat(example): add example for connecting to multiple peripherals

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

Author: HaoboGu

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/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/src/bin/ble_bas_central_multiple.rs

@@ -0,0 +1,50 @@
+#![no_std]
+#![no_main]
+
+use embassy_executor::Spawner;
+use esp_hal::clock::CpuClock;
+use esp_hal::timer::timg::TimerGroup;
+use esp_radio::Controller;
+use esp_radio::ble::controller::BleConnector;
+use static_cell::StaticCell;
+use trouble_example_apps::ble_bas_central_multiple;
+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,
+    );
+
+    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);
+
+    ble_bas_central_multiple::run(controller).await;
+}