Чтение последовательного потока данных с Bluetooth 5 LE DevBoard через Rumble

Question

Я пытаюсь прочитать поток последовательных данных, поступающих с устройства Bluetooth с низким энергопотреблением.Микропрограмма регистрируется как служба эмуляции UART (пользовательский UUID) и отправляет данные через Receive_Characteristic (пользовательский UUID).Отправляемые последовательные данные - это просто увеличивающиеся числа.

Используя rumble , я могу установить соединение с устройством и что-то прочитать, но не поток.Ниже приведен пример минимального рабочего кода:

    let manager = Manager::new().unwrap();

    let mut adapter = manager
        .adapters()
        .expect("could not list adapters")
        .into_iter()
        .find(|a| a.name == self.adapter_name)
        .expect("could not find adapter by name");

    println!("power cycle adapter");
    adapter = manager.down(&adapter).unwrap();
    adapter = manager.up(&adapter).unwrap();
    println!("connect adapter");

    let central = adapter.connect().unwrap();
    central.start_scan().unwrap();
    println!(
        "find desired {:?} peripheral...",
        &self.device_name
    );

    // keep scanning for 10 s
    std::thread::sleep(std::time::Duration::from_secs(1));
    central.stop_scan().unwrap();

    let peripherals = central.peripherals();



    let mdevice = central
        .peripherals()
        .into_iter()
        .find(|perf| {
            perf.properties()
                .local_name
                .iter()
                .any(|name| name.contains(&self.device_name))
        })
        .expect("could not find peripheral by name");

    std::thread::sleep(std::time::Duration::from_secs(1));

    match mdevice.connect() {
        Ok(d) => {
            println!("mdevice connected");
            d
        }
        Err(err) => {
            eprintln!("error connecting to mdevice: {:?}", err);
            panic!()
        }
    };
    std::thread::sleep(std::time::Duration::from_secs(1));
    println!("discovering characteristics");

    for ch in mdevice.discover_characteristics().unwrap().into_iter() {
        println!("found characteristic: {:?}", ch);
    }
    std::thread::sleep(std::time::Duration::from_secs(1));
    println!("get desired characteristic");
    let receive_characteristic = mdevice
        .discover_characteristics()
        .unwrap()
        .into_iter()
        .find(|c| {
            RECEIVE_CHARACTERISTIC == c.uuid
        })
        .expect("could not find given characteristic");


    // this is some testing code to print out received data
    let (tx, rx) = std::sync::mpsc::channel();

    std::thread::spawn(move || loop {
        let data = match mdevice.read(&receive_characteristic) {
            Ok(d) => d,
            Err(err) => { println!("received an error {:?}", err); 
                          Vec::new()}
        };
        println!("send : {:02?}", data);
        match tx.send(data) {
            Ok(d) => d,
            Err(e) => println!("error {:?}", e)
        };
    });    

    loop {
        let dd = rx.recv();
        println!("received : {:02?}", dd.unwrap());
    }

    Ok(())

Используя гул, я могу подключиться к устройству, но получить поток странно.Я продолжаю получать одно и то же число в vec, но иногда получаю число, находящееся в диапазоне приращения.Правильно ли выполняется чтение последовательного потока?

EDIT : В настоящее время я использую плату разработки nRF52840-DK.Микропрограмма отправляет увеличивающиеся числа от 0 до 255, а затем повторяет последовательность.

Answer 1

Решил это.

Основная проблема заключалась в том, что я не до конца понимал профиль GATT и, следовательно, протокол Bluetooth LE.Этот ресурс дает хорошее введение в эту тему.

Решение состоит в том, чтобы подписаться на обновления данных (событий) после подключения устройства и зарегистрировать обработчик событий, который реагирует на входящие данные.Это было так просто.

// ... same code as before, but only the relevant pieces are shown.
mdevice.connect().expect("Could not connect to device");
std::thread::sleep(std::time::Duration::from_secs(1));

let chars = mdevice.discover_characteristics()
.expect("Discovering characteristics failed");

std::thread::sleep(std::time::Duration::from_secs(1));

let receive_characteristic = chars.clone().into_iter()
.find(|c| 
{
                // The constant is just a fixed array
                RECEIVE_CHARACTERISTIC == c.uuid
}).expect("Could not find given characteristic");

// subscribe to the event
mdevice.subscribe(&receive_characteristic)

mdevice.on_notification(Box::from(move |v : rumble::api::ValueNotification| 
{
// do something with the received data
}));