Trouble Documentation

let mut resources: HostResources<DefaultPacketPool, 4, 2, 1> = HostResources::new();

let stack = trouble_host::new(controller, &mut resources)
    .set_random_address(address)
    .build();

let runner = stack.runner();
let central = stack.central();
let peripheral = stack.peripheral();

// As a generic async function using join:
use embassy_futures::join::join;

let _ = join(
    async {
        loop {
            if let Err(e) = runner.run().await {
                panic!("BLE runner error: {:?}", e);
            }
        }
    },
    async {
        // Your application logic here (advertise, connect, etc.)
    },
).await;

#[embassy_executor::task]
async fn ble_task(mut runner: Runner<'static, SoftdeviceController<'static>>) {
    loop {
        runner.run().await.ok();
    }
}

spawner.must_spawn(ble_task(runner));

use trouble_host::prelude::*;

#[gatt_service(uuid = "180f")]
struct BatteryService {
    #[characteristic(uuid = "2a19", read, notify, value = 10)]
    level: u8,
}

#[gatt_server]
struct Server {
    battery_service: BatteryService,
}

let server = Server::new_with_config(GapConfig::Peripheral(PeripheralConfig {
    name: "TrouBLE",
    appearance: &appearance::power_device::GENERIC_POWER_DEVICE,
}))
.unwrap();

let conn = central.connect(&config).await.unwrap();
let client = GattClient::<C, DefaultPacketPool, 10>::new(&stack, &conn).await.unwrap();

let _ = join(client.task(), async {
    // Your client operations here
}).await;

use embassy_futures::join::join;
use embassy_futures::select::select;
use trouble_host::prelude::*;

const CONNECTIONS_MAX: usize = 1;
const L2CAP_CHANNELS_MAX: usize = 2; // Signal + ATT

#[gatt_server]
struct Server {
    battery_service: BatteryService,
}

#[gatt_service(uuid = service::BATTERY)]
struct BatteryService {
    #[characteristic(uuid = characteristic::BATTERY_LEVEL, read, notify, value = 10)]
    level: u8,
}

pub async fn run<C: Controller>(controller: C) {
    let address = Address::random([0xff, 0x8f, 0x1a, 0x05, 0xe4, 0xff]);
    let mut resources: HostResources<C, DefaultPacketPool, CONNECTIONS_MAX, L2CAP_CHANNELS_MAX> =
        HostResources::new();
    let stack = trouble_host::new(controller, &mut resources)
        .set_random_address(address)
        .build();
    let runner = stack.runner();
    let mut peripheral = stack.peripheral();

    let server = Server::new_with_config(GapConfig::Peripheral(PeripheralConfig {
        name: "TrouBLE",
        appearance: &appearance::power_device::GENERIC_POWER_DEVICE,
    })).unwrap();

    let _ = join(
        async { loop { runner.run().await.ok(); } },
        async {
            loop {
                // Advertise and wait for connection
                let mut adv_data = [0; 31];
                let len = AdStructure::encode_slice(
                    &[
                        AdStructure::Flags(LE_GENERAL_DISCOVERABLE | BR_EDR_NOT_SUPPORTED),
                        AdStructure::CompleteLocalName(b"TrouBLE"),
                    ],
                    &mut adv_data[..],
                ).unwrap();
                let advertiser = peripheral.advertise(
                    &Default::default(),
                    Advertisement::ConnectableScannableUndirected {
                        adv_data: &adv_data[..len],
                        scan_data: &[],
                    },
                ).await.unwrap();
                let conn = advertiser.accept().await.unwrap().with_attribute_server(&server).unwrap();

                // Run GATT event handler and notification task concurrently
                let level = server.battery_service.level;
                select(
                    async {
                        loop {
                            match conn.next().await {
                                GattConnectionEvent::Disconnected { .. } => break,
                                GattConnectionEvent::Gatt { event } => {
                                    event.accept().ok();
                                }
                                _ => {}
                            }
                        }
                    },
                    async {
                        let mut tick: u8 = 0;
                        loop {
                            tick = tick.wrapping_add(1);
                            let _ = level.notify(&conn, &tick).await;
                            Timer::after_secs(2).await;
                        }
                    },
                ).await;
            }
        },
    ).await;
}

const CONNECTIONS_MAX: usize = 1;
const L2CAP_CHANNELS_MAX: usize = 3; // Signal + ATT + 1 CoC channel

let mut resources: HostResources<MyController, DefaultPacketPool, CONNECTIONS_MAX, L2CAP_CHANNELS_MAX> =
    HostResources::new();

let config = L2capChannelConfig {
    mtu: Some(PAYLOAD_LEN as u16),   // Service Data Unit size
    mps: Some(251),                   // Max PDU payload size (frame size)
    flow_policy: CreditFlowPolicy::Every(1), // When to grant credits
    initial_credits: Some(10),        // Credits granted at connection start
};

// Send data (waits for available credits)
let tx = [0x42; PAYLOAD_LEN];
ch.send(&stack, &tx).await.unwrap();

// Non-blocking send (returns Error::Busy if no credits)
ch.try_send(&stack, &tx).unwrap();

// Receive data (blocks until data available)
let mut rx = [0; PAYLOAD_LEN];
let len = ch.receive(&stack, &mut rx).await.unwrap();

// Receive as an owned SDU packet
let sdu = ch.receive_sdu(&stack).await.unwrap();
let data: &[u8] = sdu.as_ref();

let config = L2capChannelConfig {
    mtu: Some(2504),
    mps: Some(247),
    flow_policy: CreditFlowPolicy::Every(50),
    initial_credits: Some(200),
};

let (mut writer, mut reader) = ch.split();

// Use in separate concurrent tasks
join(
    async {
        writer.send(&stack, &data).await.unwrap();
    },
    async {
        let len = reader.receive(&stack, &mut buf).await.unwrap();
    },
).await;

// Merge back if needed
let ch = L2capChannel::merge(writer, reader);

ch.mtu()        // Local negotiated MTU
ch.mps()        // Local negotiated MPS
ch.peer_mtu()   // Remote device's MTU
ch.peer_mps()   // Remote device's MPS
ch.spsm()       // Simplified Protocol/Service Multiplexer
ch.disconnect() // Disconnect the channel

use embassy_futures::join::join;
use trouble_host::prelude::*;

const CONNECTIONS_MAX: usize = 1;
const L2CAP_CHANNELS_MAX: usize = 3;
const PAYLOAD_LEN: usize = 27;

pub async fn run<C: Controller>(controller: C) {
    let address = Address::random([0xff, 0x8f, 0x1a, 0x05, 0xe4, 0xff]);
    let mut resources: HostResources<C, DefaultPacketPool, CONNECTIONS_MAX, L2CAP_CHANNELS_MAX> =
        HostResources::new();
    let stack = trouble_host::new(controller, &mut resources)
        .set_random_address(address)
        .register_l2cap_spsm(0x0081)
        .build();
    let mut runner = stack.runner();
    let mut peripheral = stack.peripheral();

    let _ = join(runner.run(), async {
        loop {
            // Advertise and accept connection
            let mut adv_data = [0; 31];
            let len = AdStructure::encode_slice(
                &[AdStructure::Flags(LE_GENERAL_DISCOVERABLE | BR_EDR_NOT_SUPPORTED)],
                &mut adv_data[..],
            ).unwrap();
            let advertiser = peripheral.advertise(
                &Default::default(),
                Advertisement::ConnectableScannableUndirected {
                    adv_data: &adv_data[..len],
                    scan_data: &[],
                },
            ).await.unwrap();
            let conn = advertiser.accept().await.unwrap();

            // Accept L2CAP channel
            let config = L2capChannelConfig {
                mtu: Some(PAYLOAD_LEN as u16),
                ..Default::default()
            };
            let mut ch = L2capChannel::listen(&stack, &conn).accept(&config).await.unwrap();

            // Echo received data
            let mut buf = [0; PAYLOAD_LEN];
            loop {
                match ch.receive(&stack, &mut buf).await {
                    Ok(len) => {
                        ch.send(&stack, &buf[..len]).await.unwrap();
                    }
                    Err(_) => break,
                }
            }
        }
    }).await;
}

let stack = trouble_host::new(controller, &mut resources)
    .set_random_address(address)
    .set_random_generator_seed(&mut rng)  // Must implement RngCore + CryptoRng
    .build();

// Central or peripheral can request security
conn.request_security().unwrap();

loop {
    match conn.next().await {
        GattConnectionEvent::Disconnected { reason } => break,

        // Display a passkey for the user to enter on the other device
        GattConnectionEvent::PassKeyDisplay(key) => {
            info!("Display this passkey: {}", key);
        }

        // User must confirm the displayed number matches
        GattConnectionEvent::PassKeyConfirm(key) => {
            info!("Confirm passkey: {}", key);
            // After user confirms or rejects:
            conn.raw().pass_key_confirm().unwrap();
            // OR: conn.raw().pass_key_cancel().unwrap();
        }

        // User must input the passkey shown on the other device
        GattConnectionEvent::PassKeyInput => {
            let user_input: u32 = 123456; // Get from user
            conn.raw().pass_key_input(user_input).unwrap();
        }

        // Pairing succeeded
        GattConnectionEvent::PairingComplete { security_level, bond } => {
            info!("Paired with security level: {:?}", security_level);
            if let Some(bond) = bond {
                // Persist the bond information (see Bonding section)
            }
        }

        // Pairing failed
        GattConnectionEvent::PairingFailed(err) => {
            error!("Pairing failed: {:?}", err);
        }

        GattConnectionEvent::Gatt { event } => {
            event.accept().ok();
        }
        _ => {}
    }
}

#[characteristic(uuid = "2a19", read, notify, permissions(encrypted))]
level: u8,

#[characteristic(uuid = "2a4a", read, permissions(authenticated))]
hid_info: [u8; 4],

use bt_hci::controller::ExternalController;
use bt_hci_linux::Transport;

#[tokio::main(flavor = "current_thread")]
async fn main() {
    let dev = 0; // HCI device number (hci0)
    let transport = Transport::new(dev).unwrap();
    let controller = ExternalController::<_, 8>::new(transport);

    // Pass controller to your application
    my_app::run(controller).await;
}

[dependencies]
bt-hci = "0.8"
bt-hci-linux = { path = "../../bt-hci-linux" }
tokio = { version = "1", features = ["macros", "rt"] }
trouble-host = { version = "0.6", features = ["log"] }

#![no_std]
#![no_main]

use embassy_executor::Spawner;
use embassy_nrf::rng;
use nrf_sdc::{self as sdc, mpsl};
use static_cell::StaticCell;

#[embassy_executor::task]
async fn mpsl_task(mpsl: &'static mpsl::MultiprotocolServiceLayer<'static>) -> ! {
    mpsl.run().await
}

#[embassy_executor::main]
async fn main(spawner: Spawner) {
    let p = embassy_nrf::init(Default::default());

    // 1. Initialize MPSL
    let mpsl_p = mpsl::Peripherals::new(
        p.RTC0, p.TIMER0, p.TEMP,
        p.PPI_CH19, p.PPI_CH30, p.PPI_CH31,
    );
    let lfclk_cfg = mpsl::raw::mpsl_clock_lfclk_cfg_t {
        source: mpsl::raw::MPSL_CLOCK_LF_SRC_RC as u8,
        rc_ctiv: mpsl::raw::MPSL_RECOMMENDED_RC_CTIV as u8,
        rc_temp_ctiv: mpsl::raw::MPSL_RECOMMENDED_RC_TEMP_CTIV as u8,
        accuracy_ppm: mpsl::raw::MPSL_DEFAULT_CLOCK_ACCURACY_PPM as u16,
        skip_wait_lfclk_started: mpsl::raw::MPSL_DEFAULT_SKIP_WAIT_LFCLK_STARTED != 0,
    };
    static MPSL: StaticCell<mpsl::MultiprotocolServiceLayer> = StaticCell::new();
    let mpsl = MPSL.init(mpsl::MultiprotocolServiceLayer::new(mpsl_p, Irqs, lfclk_cfg));
    spawner.must_spawn(mpsl_task(mpsl));

    // 2. Configure SoftDevice Controller
    let sdc_p = sdc::Peripherals::new(/* PPI channels */);
    let mut rng = rng::Rng::new(p.RNG, Irqs);
    let mut sdc_mem = sdc::Mem::<4864>::new();
    let sdc = sdc::Builder::new().unwrap()
        .support_peripheral().unwrap()
        .peripheral_count(1).unwrap()
        .build(sdc_p, &mut rng, mpsl, &mut sdc_mem)
        .unwrap();

    // 3. Run application
    my_app::run(sdc).await;
}

#![no_std]
#![no_main]

use embassy_executor::Spawner;
use esp_hal::clock::CpuClock;
use esp_hal::timer::timg::TimerGroup;
use esp_radio::ble::controller::BleConnector;
use trouble_host::prelude::ExternalController;

#[esp_rtos::main]
async fn main(_s: Spawner) {
    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);
    esp_rtos::start(timg0.timer0, /* ... */);

    let connector = BleConnector::new(peripherals.BT, Default::default()).unwrap();
    let controller: ExternalController<_, 20> = ExternalController::new(connector);

    my_app::run(controller).await;
}

#![no_std]
#![no_main]

use cyw43_pio::PioSpi;
use embassy_executor::Spawner;
use embassy_rp::gpio::{Level, Output};
use embassy_rp::pio::Pio;
use static_cell::StaticCell;
use trouble_host::prelude::ExternalController;

#[embassy_executor::task]
async fn cyw43_task(runner: cyw43::Runner<'static, /* ... */>) -> ! {
    runner.run().await
}

#[embassy_executor::main]
async fn main(spawner: Spawner) {
    let p = embassy_rp::init(Default::default());

    // Load firmware blobs
    let fw = include_bytes!("../../cyw43-firmware/43439A0.bin");
    let clm = include_bytes!("../../cyw43-firmware/43439A0_clm.bin");
    let btfw = include_bytes!("../../cyw43-firmware/43439A0_btfw.bin");

    // Set up PIO SPI
    let pwr = Output::new(p.PIN_23, Level::Low);
    let cs = Output::new(p.PIN_25, Level::High);
    let mut pio = Pio::new(p.PIO0, Irqs);
    let spi = PioSpi::new(/* ... */);

    // Initialize cyw43
    static STATE: StaticCell<cyw43::State> = StaticCell::new();
    let state = STATE.init(cyw43::State::new());
    let (_net, bt_device, mut control, runner) =
        cyw43::new_with_bluetooth(state, pwr, spi, fw, btfw, nvram).await;
    spawner.must_spawn(cyw43_task(runner));
    control.init(clm).await;

    let controller: ExternalController<_, 10> = ExternalController::new(bt_device);
    my_app::run(controller).await;
}

use embassy_sync::blocking_mutex::raw::NoopRawMutex;
use tokio_serial::SerialStream;
use trouble_host::prelude::{ExternalController, SerialTransport};

#[tokio::main]
async fn main() {
    let port = SerialStream::open(
        &tokio_serial::new("/dev/ttyUSB0", 1000000)
    ).unwrap();

    let (reader, writer) = tokio::io::split(port);
    let reader = embedded_io_adapters::tokio_1::FromTokio::new(reader);
    let writer = embedded_io_adapters::tokio_1::FromTokio::new(writer);

    let driver: SerialTransport<NoopRawMutex, _, _> = SerialTransport::new(reader, writer);
    let controller: ExternalController<_, 10> = ExternalController::new(driver);

    my_app::run(controller).await;
}