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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use crate::{BLEAddress, BLEError, ble};
use esp_idf_svc::sys as esp_idf_sys;
use esp_idf_sys::ble_gap_conn_desc;

#[repr(transparent)]
pub struct BLEConnDesc(pub(crate) ble_gap_conn_desc);

impl BLEConnDesc {
    /// Gets the over-the-air address of the connected peer
    #[inline]
    pub fn address(&self) -> BLEAddress {
        BLEAddress::from(self.0.peer_ota_addr)
    }

    /// Gets the ID address of the connected peer
    #[inline]
    pub fn id_address(&self) -> BLEAddress {
        BLEAddress::from(self.0.peer_id_addr)
    }

    /// Gets the connection handle of the connected peer
    #[inline]
    pub fn conn_handle(&self) -> u16 {
        self.0.conn_handle
    }

    /// Gets the connection interval for this connection (in 1.25ms units)
    #[inline]
    pub fn interval(&self) -> u16 {
        self.0.conn_itvl
    }

    /// Gets the supervision timeout for this connection (in 10ms units)
    #[inline]
    pub fn timeout(&self) -> u16 {
        self.0.supervision_timeout
    }

    /// Gets the allowable latency for this connection (unit = number of intervals)
    #[inline]
    pub fn latency(&self) -> u16 {
        self.0.conn_latency
    }

    /// Gets the maximum transmission unit size for this connection (in bytes)
    #[inline]
    pub fn mtu(&self) -> u16 {
        unsafe { esp_idf_sys::ble_att_mtu(self.0.conn_handle) }
    }

    /// Check if we are connected to a bonded peer
    #[inline]
    pub fn bonded(&self) -> bool {
        self.0.sec_state.bonded() != 0
    }

    /// Check if the connection in encrypted
    #[inline]
    pub fn encrypted(&self) -> bool {
        self.0.sec_state.encrypted() != 0
    }

    /// Check if the the connection has been authenticated
    #[inline]
    pub fn authenticated(&self) -> bool {
        self.0.sec_state.authenticated() != 0
    }

    /// Gets the key size used to encrypt the connection
    #[inline]
    pub fn sec_key_size(&self) -> u32 {
        self.0.sec_state.key_size()
    }

    /// Retrieves the most-recently measured RSSI.
    /// A connection’s RSSI is updated whenever a data channel PDU is received.
    pub fn get_rssi(&self) -> Result<i8, BLEError> {
        let mut rssi: i8 = 0;
        unsafe {
            ble!(esp_idf_sys::ble_gap_conn_rssi(
                self.0.conn_handle,
                &mut rssi
            ))?;
        }
        Ok(rssi)
    }
}

impl core::fmt::Debug for BLEConnDesc {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("BLEConnDesc")
            .field("address", &self.address())
            .field("bonded", &self.bonded())
            .field("encrypted", &self.encrypted())
            .field("authenticated", &self.authenticated())
            .field("mtu", &self.mtu())
            .finish()
    }
}