Bluetooth 串行rs多蓝牙连接

使用串行rs可以打开Mac和Arduino（HC-05）之间的蓝牙连接。但如果我想同时打开多个蓝牙连接，则只有最近的连接保持打开状态

我不完全确定Qt如何处理这个问题，但可以使用

QSerialPort

同时读取/写入多个设备

这是一个串行rs未实现的特性，还是Qt做了一些类似于切换连接（在时间上只打开一个）的事情，所以看起来好像处理了多个连接

extern crate serial;
#[macro_use]
extern crate text_io;
use std::process::Command;
use std::io;
use std::time::Duration;
use std::sync::mpsc::{Sender, Receiver};
use std::sync::mpsc;
use std::thread;
use std::io::prelude::*;
use serial::prelude::*;
use std::sync::Arc;
use std::sync::Mutex;

fn print_available_ports() {
    let status = Command::new("ls")
        .arg("/dev/")
        .status()
        .unwrap_or_else(|e| panic!("Failed to execute process: {}", e));
}

fn print_available_commands() {
    println!("Available commands:");
    println!("  print_ports - prints available serial ports");
    println!("  connect - make an asynchronous connection to port");
    println!("  start - signal ports to start collecting data");
    println!("  stop - opposite to start");
    println!("  monitor - print info of current state of reading");
    println!("  help - prints this info.");
    println!("  exit");
}

fn connect_to_port(portname: &String,
                   rate: usize,
                   tx: Sender<String>,
                   port_state: Arc<Mutex<bool>>)
                   -> io::Result<()> {
    let mut port = serial::open(portname.trim()).unwrap();
    try!(port.reconfigure(&|settings| {
        try!(settings.set_baud_rate(serial::BaudRate::from_speed(rate)));
        settings.set_char_size(serial::Bits8);
        settings.set_parity(serial::ParityNone);
        settings.set_stop_bits(serial::Stop1);
        settings.set_flow_control(serial::FlowNone);
        Ok(())
    }));

    try!(port.set_timeout(Duration::from_millis(10000)));

    println!("Serial port to {} opened successfully.", portname);
    println!("Waiting for the start..");

    while *(port_state.lock().unwrap()) != true {

    }

    println!("Port named {} started reading.", portname);

    let mut ans_number: usize = 0;
    let mut answer = String::new();
    let mut bytes_received: usize = 0;
    let mut buf = vec![0;128];

    loop {
        match port.read(&mut buf[..]) {
            Ok(n) => {
                bytes_received += n;
            }
            Err(_) => {
                println!("Error in reading from {}", portname);
                bytes_received = bytes_received;
            }
        }

        if bytes_received > 10000 {
            answer = String::new();
            answer = format!("#{} Port {} received 10000 bytes of data",
                             ans_number,
                             portname);
            tx.send(answer);
            bytes_received = 0;
            ans_number += 1;
        }

        if *(port_state.lock().unwrap()) == false {
            println!("Port named {} got signal to stop. Abort.", portname);
            break;
        }
    }

    Ok(())
}

fn main() {
    print_available_commands();

    let mut reading_active = Arc::new(Mutex::new(false));
    let (dtx, drx): (Sender<String>, Receiver<String>) = mpsc::channel();
    let mut ports = vec![];
    let mut input = String::new();

    loop {
        input = String::new();
        match io::stdin().read_line(&mut input) {
            Ok(n) => println!("Command received: {}", input.trim()),
            Err(error) => println!("error: {}", error),
        }

        match input.trim() {
            "connect" => {
                let portname: String;
                let baudrate: usize;

                println!("Enter port name:");
                portname = read!();

                println!("Enter baudrate:");
                baudrate = read!();

                let thread_state = reading_active.clone();
                let thread_tx = dtx.clone();
                ports.push(thread::Builder::new().name(portname.clone()).spawn(move || {
                    connect_to_port(&portname, baudrate, thread_tx, thread_state);
                }));
            }

            "start" => {
                *(reading_active.lock().unwrap()) = true;
            }
            "stop" => {
                *(reading_active.lock().unwrap()) = false;
            }
            "help" => print_available_commands(),
            "print_ports" => print_available_ports(),
            "exit" => {
                println!("Closing used ports..");
            }

            "monitor" => {
                loop {
                    println!("{:?}", drx.recv());
                }
            }
            _ => println!("Unsupported command."),
        }
    }
}

extern板条箱系列；
#[宏_使用]
外部板条箱文本；
使用std：：process：：命令；
使用std：：io；
使用std:：time:：Duration；
使用std:：sync:：mpsc:：{发送方，接收方}；
使用std:：sync:：mpsc；
使用std：：线程；
使用std:：io:：prelude:：*；
使用序列：：前奏：：*；
使用std:：sync:：Arc；
使用std:：sync:：Mutex；
fn打印\u可用\u端口（）{
让状态=命令：：新建（“ls”）
.arg（“/dev/”）
.status（）
.unwrap_或_else（| e | panic！（“未能执行进程：{}，e））；
}
fn打印可用的命令（）{
println！（“可用命令：”）；
println！（“打印端口-打印可用串行端口”）；
println！（“连接-与端口建立异步连接”）；
println！（“开始-开始收集数据的信号端口”）；
println！（“停止-与开始相反”）；
println！（“监视器-当前读取状态的打印信息”）；
println！（“帮助-打印此信息”）；
println！（“退出”）；
}
fn将\u连接到\u端口（端口名：&字符串，
比率：usize，
发送人，
港口国（Arc）
->io：：结果{
让mut port=serial:：open（portname.trim（））.unwrap（）；
试试！（端口重新配置（&|设置|{
试试！（设置。设置波特率（串行：：波特率：：自速度（速率））；
设置。设置字符大小（串行：：位8）；
设置。设置奇偶校验（串行：：ParityNone）；
设置。设置停止位（串行：：停止1）；
设置。设置流量控制（串行：：FlowNone）；
好（（））
}));
试试！（port.set_timeout（持续时间：：从_毫秒（10000））；
println！（“{}的串行端口已成功打开。”，端口名）；
println！（“等待开始…”）；
while*（port_state.lock（）.unwrap（））！=true{
}
println！（“名为{}的端口开始读取。”，端口名）；
让mut ans_数：usize=0；
让mut answer=String:：new（）；
让mut bytes_接收：usize=0；
让mut buf=vec！[0；128]；
环路{
匹配端口。读取（&mut buf[…]）{
Ok（n）=>{
接收的字节数_+=n；
}
错误（41;）=>{
println！（“从{}读取端口名时出错）；
接收字节数=接收字节数；
}
}
如果接收的字节数大于10000{
answer=String:：new（）；
应答=格式！（“{}端口{}接收到10000字节的数据”，
ans_编号，
端口名）；
发送（应答）；
接收的字节数=0；
ans_数+=1；
}
如果*（端口状态.lock（）.unwrap（））==false{
println！（“名为{}的端口收到停止的信号。中止。”，portname）；
打破
}
}
好（（））
}
fn main（）{
打印可用的命令（）；
让mut reading_active=Arc:：new（Mutex:：new（false））；
let（dtx，drx）：（发送方，接收方）=mpsc:：channel（）；
让mut port=vec！[]；
让mut input=String:：new（）；
环路{
input=String:：new（）；
匹配io:：stdin（）。读取行（&mut输入）{
Ok（n）=>println！（“收到的命令：{}”，input.trim（）），
Err（error）=>println！（“error:{}”，error），
}
匹配input.trim（）{
“连接”=>{
让portname:String；
让波特率：usize；
println！（“输入端口名：”）；
portname=read！（）；
println！（“输入波特率：”）；
波特率=读！（）；
让线程_state=reading_active.clone（）；
让线程_tx=dtx.clone（）；
ports.push（thread:：Builder:：new（）.name（portname.clone（））.spawn（move | |{
将线程连接到线程端口（&portname、波特率、线程发送、线程状态）；
}));
}
“开始”=>{
*（正在读取_active.lock（）.unwrap（））=真；
}
“停止”=>{
*（正在读取_active.lock（）.unwrap（））=false；
}
“帮助”=>打印可用的命令（），
“打印端口”=>打印可用的端口（），
“退出”=>{
println！（“关闭已用端口…”）；
}
“监视器”=>{
环路{
println！（“{：？}”，drx.recv（））；
}
}
_=>println！（“不支持的命令”），
}
}
}

如果我连接到1个蓝牙设备和1个通过usb连接的设备（或2个usb连接的设备），那么，我认为代码中没有问题。如果我连接到1个蓝牙设备和1个通过usb连接的设备（或2个usb连接的设备），那么这段代码工作得非常好，因此，我认为代码中没有问题。