blew 0.1.0-alpha.7

Cross-platform async BLE library for Rust (Apple, Linux, Android)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

//! BLE scanner example.
//!
//! Starts a scan for all nearby peripherals, prints each discovery for
//! 10 seconds, then stops.
//!
//! ```sh
//! cargo run --example scan -p blew
//! ```

use blew::Central;
use blew::central::{CentralEvent, ScanFilter};
use tokio_stream::StreamExt as _;

#[tokio::main(flavor = "current_thread")]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    tracing_subscriber::fmt()
        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
        .init();

    // Explicit type annotation required -- Rust can't infer the default type param.
    let central: Central = Central::new().await?;

    let mut events = central.events();

    central.start_scan(ScanFilter::default()).await?;
    println!("Scanning for 10 s ... (Ctrl-C to stop early)");

    let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(10);

    loop {
        match tokio::time::timeout_at(deadline, events.next()).await {
            Ok(Some(CentralEvent::DeviceDiscovered(device))) => {
                let name = device.name.as_deref().unwrap_or("<unnamed>");
                let rssi = device
                    .rssi
                    .map(|r| format!("{r} dBm"))
                    .unwrap_or_else(|| "?".into());
                println!("  {:<40} {:>8}  {}", device.id, rssi, name);
            }
            Ok(Some(_)) => {}  // ignore connect/disconnect etc.
            Ok(None) => break, // event stream closed
            Err(_) => break,   // 10 s elapsed
        }
    }

    central.stop_scan().await?;
    println!("Done.");
    Ok(())
}