nxt 0.2.1

USB driver for communicating with the NXT brick
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
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

//! Bluetooth protocol support

use std::sync::OnceLock;

use super::Socket;
use crate::{Error, Nxt, Result};
use bluer::{
    rfcomm::{self, SocketAddr},
    Adapter, AdapterEvent, Address,
};
use futures::StreamExt;
use tokio::{
    io::{AsyncReadExt, AsyncWriteExt},
    sync::RwLock,
};

/// Observed device class advertised by NXT brick
const NXT_DEVICE_CLASS: u32 = 0x804;
/// RFCOMM channel used by the NXT brick
const NXT_BT_CHAN: u8 = 1;
/// Stores a shared adapter object for performing device scans
static ADAPTER: OnceLock<Adapter> = OnceLock::new();

/// Get a handle to the default Bluetooth adapter, returning the cached
/// one if present
async fn init_adapter() -> Result<&'static Adapter> {
    if let Some(adapter) = ADAPTER.get() {
        Ok(adapter)
    } else {
        let session = bluer::Session::new().await?;
        let adapter = session.default_adapter().await?;
        adapter.set_powered(true).await?;
        Ok(ADAPTER.get_or_init(|| adapter))
    }
}

/// A handle to an NXT brick over Bluetooth
pub struct Bluetooth {
    /// Connected RFCOMM stream
    stream: RwLock<rfcomm::Stream>,
}

impl From<rfcomm::Stream> for Bluetooth {
    fn from(stream: rfcomm::Stream) -> Self {
        Self {
            stream: RwLock::new(stream),
        }
    }
}

impl Bluetooth {
    /// Connect to an NXT brick at the specified address
    pub async fn connect(addr: Address) -> Result<Nxt> {
        let socket = rfcomm::Socket::new()?;
        let stream = socket
            .connect(SocketAddr::new(addr, NXT_BT_CHAN))
            .await?
            .into();
        let conn = Self { stream };
        println!("Connected!");
        crate::Nxt::init(conn).await
    }

    /// Listen for bluetooth connections and try to connec to the first
    /// NXT device discovered
    pub async fn wait_for_nxt() -> Result<crate::Nxt> {
        let adapter = init_adapter().await?;
        let mut device_events = adapter.discover_devices().await?;

        while let Some(evt) = device_events.next().await {
            if let AdapterEvent::DeviceAdded(addr) = evt {
                println!("Device added: {addr:?}");
                // check whether it looks like an NXT
                let device = adapter.device(addr).unwrap();
                if device.class().await.unwrap_or_default()
                    == Some(NXT_DEVICE_CLASS)
                {
                    // device.connect().await?;
                    println!("Device looks like an NXT; connecting");

                    return Self::connect(addr).await;
                }
            }
        }

        Err(Error::NoBrick)
    }
}

#[async_trait::async_trait]
impl Socket for Bluetooth {
    #[tracing::instrument(skip_all)]
    async fn send(&self, data: &[u8]) -> Result<usize> {
        debug!("Writing {} bytes", data.len());
        let len_prefix: u16 = data.len().try_into()?;
        let mut lock = self.stream.write().await;
        let written = lock.write(&len_prefix.to_le_bytes()).await?;
        debug_assert_eq!(written, 2);
        Ok(lock.write(data).await?)
    }

    #[tracing::instrument(skip_all)]
    async fn recv<'buf>(&self, buf: &'buf mut [u8]) -> Result<&'buf [u8]> {
        let mut len_prefix = [0; 2];
        let mut lock = self.stream.write().await;
        let len = lock.read_exact(&mut len_prefix).await?;
        debug_assert_eq!(len, len_prefix.len());
        debug!("Expecting {len} bytes from prefix");

        let len_prefix = u16::from_le_bytes(len_prefix).into();
        if buf.len() < len_prefix {
            return Err(Error::Parse("Data too long for buffer"));
        }
        let len = lock.read_exact(&mut buf[..len_prefix]).await?;
        drop(lock);
        debug_assert_eq!(len, len_prefix);

        Ok(&buf[..len])
    }
}