serial-rs多个蓝牙连接

Question

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

我不完全确定Qt如何处理这个问题，但是可以使用QSerialPort同时读/写多个设备。

这是一个串口未实现的功能，还是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."),
        }
    }
}