esp32-nimble 0.12.0

A wrapper for the ESP32 NimBLE Bluetooth stack.
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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use std::time::Duration;

use bstr::ByteSlice;
use esp_idf_svc::hal::{
    task::block_on,
    timer::{TimerDriver, config::TimerConfig},
};
use esp32_nimble::{BLEDevice, BLEScan, uuid128};

fn main() -> anyhow::Result<()> {
    esp_idf_svc::sys::link_patches();
    esp_idf_svc::log::EspLogger::initialize_default();

    let timer = TimerDriver::new(&TimerConfig::default())?;

    block_on(async {
        let ble_device = BLEDevice::take();
        let mut ble_scan = BLEScan::new();
        let device = ble_scan
            .active_scan(true)
            .interval(100)
            .window(99)
            .start(ble_device, 10000, |device, data| {
                if let Some(name) = data.name() {
                    if name.contains_str("ESP32") {
                        return Some(*device);
                    }
                }
                None
            })
            .await?;

        if let Some(device) = device {
            let mut client = ble_device.new_client();
            client.on_connect(|client| {
                client.update_conn_params(120, 120, 0, 60).unwrap();
            });
            client.connect(&device.addr()).await?;

            let service = client
                .get_service(uuid128!("fafafafa-fafa-fafa-fafa-fafafafafafa"))
                .await?;

            let uuid = uuid128!("d4e0e0d0-1a2b-11e9-ab14-d663bd873d93");
            let characteristic = service.get_characteristic(uuid).await?;
            let value = characteristic.read_value().await?;
            ::log::info!(
                "{} value: {}",
                characteristic,
                core::str::from_utf8(&value)?
            );

            let uuid = uuid128!("a3c87500-8ed3-4bdf-8a39-a01bebede295");
            let characteristic = service.get_characteristic(uuid).await?;

            if !characteristic.can_notify() {
                ::log::error!("characteristic can't notify: {}", characteristic);
                return anyhow::Ok(());
            }

            ::log::info!("subscribe to {}", characteristic);
            characteristic
                .on_notify(|data| {
                    ::log::info!("{}", core::str::from_utf8(data).unwrap());
                })
                .subscribe_notify(false)
                .await?;

            timer.delay(Duration::from_secs(10)).await?;

            client.disconnect()?;
        }

        anyhow::Ok(())
    })
}