Rust串行通信库z-serial的使用：高效实现跨平台串口数据读写与设备控制

Zenoh Serial

这个仓库包含了基于串行（类似RS232）传输的Zenoh帧格式。

构建

您需要安装rust和Cargo，请查看Rust官网了解如何安装。

$ cd ~
$ git clone https://github.com/ZettaScaleLabs/z-serial
$ cd z-serial
$ cargo build --release

如何测试

打开两个终端，在第一个终端启动echo服务器：

$ cd ~/z-serial
$ ./target/release/examples/serial-echo <serial device> -s -b <baud rate>
...

在第二个终端启动客户端：

$ cd ~/z-serial
./target/release/examples/serial-echo <serial device>  -i <send interval> -b <baud rate>

完整示例代码

以下是一个使用z-serial库进行串口通信的完整示例：

use std::io::{self, Read, Write};
use std::time::Duration;
use z_serial::{SerialPort, SerialPortBuilder};

fn main() -> io::Result<()> {
    // 配置串口参数
    let port_builder = SerialPortBuilder::new()
        .baud_rate(9600)          // 设置波特率
        .data_bits(8)             // 数据位
        .flow_control_none()      // 无流控制
        .parity_none()            // 无校验位
        .stop_bits(1);            // 停止位

    // 打开串口设备（请根据实际设备路径修改）
    let mut port = port_builder.open("/dev/ttyUSB0")?;
    
    // 设置读写超时时间
    port.set_timeout(Duration::from_millis(1000))?;

    // 要发送的数据
    let data_to_send = b"Hello, Serial World!";
    
    // 写入数据到串口
    port.write_all(data_to_send)?;
    println!("Sent: {:?}", data_to_send);

    // 读取返回数据
    let mut buffer = [0u8; 256];
    let bytes_read = port.read(&mut buffer)?;
    
    // 处理接收到的数据
    if bytes_read > 0 {
        let received_data = &buffer[..bytes_read];
        println!("Received: {:?}", received_data);
        
        // 将接收到的数据转换为字符串（如果是文本数据）
        if let Ok(received_str) = std::str::from_utf8(received_data) {
            println!("Received as string: {}", received_str);
        }
    }

    Ok(())
}

高级使用示例

use z_serial::{SerialPort, SerialPortBuilder, SerialPortInfo};
use std::time::Duration;
use std::io::{self, Read, Write};

// 列出所有可用串口设备
fn list_serial_ports() -> Vec<SerialPortInfo> {
    z_serial::available_ports().unwrap_or_default()
}

// 创建串口通信处理函数
fn create_serial_communication(device: &str, baud_rate: u32) -> io::Result<()> {
    let mut port = SerialPortBuilder::new()
        .baud_rate(baud_rate)
        .data_bits(8)
        .flow_control_none()
        .parity_none()
        .stop_bits(1)
        .open(device)?;

    port.set_timeout(Duration::from_millis(1000))?;

    // 主通信循环
    loop {
        // 读取数据
        let mut buffer = [0u8; 1024];
        match port.read(&mut buffer) {
            Ok(bytes_read) if bytes_read > 0 => {
                let data = &buffer[..bytes_read];
                println!("Received {} bytes: {:?}", bytes_read, data);
                
                // 这里可以添加数据处理逻辑
                process_received_data(data);
                
                // 可选：发送响应
                if should_send_response(data) {
                    let response = prepare_response(data);
                    port.write_all(&response)?;
                }
            }
            Ok(_) => {} // 没有数据收到
            Err(e) if e.kind() == io::ErrorKind::TimedOut => {} // 超时是正常的
            Err(e) => return Err(e), // 其他错误
        }
    }
}

// 数据处理函数
fn process_received_data(data: &[u8]) {
    // 实现您的数据处理逻辑
    println!("Processing data: {:?}", data);
}

// 判断是否需要发送响应
fn should_send_response(data: &[u8]) -> bool {
    // 实现您的响应判断逻辑
    !data.is_empty()
}

// 准备响应数据
fn prepare_response(data: &[u8]) -> Vec<u8> {
    // 实现您的响应准备逻辑
    format!("Echo: {}", String::from_utf8_lossy(data)).into_bytes()
}

安装

在您的项目目录中运行以下Cargo命令：

cargo add z-serial

或者在Cargo.toml中添加以下行：

z-serial = "0.3.1"

完整示例demo

基于上述内容，这里提供一个完整的串口通信示例，包含设备枚举、配置和双向通信：

use std::io::{self, Read, Write};
use std::time::Duration;
use z_serial::{SerialPort, SerialPortBuilder, SerialPortInfo};

fn main() -> io::Result<()> {
    // 列出所有可用串口设备
    println!("Available serial ports:");
    let ports = z_serial::available_ports().unwrap_or_default();
    for port in &ports {
        println!("- {}", port.port_name);
    }

    if ports.is_empty() {
        eprintln!("No serial ports found!");
        return Ok(());
    }

    // 使用第一个找到的串口设备
    let device = &ports[0].port_name;
    println!("Using device: {}", device);

    // 配置串口参数
    let mut port = SerialPortBuilder::new()
        .baud_rate(115200)        // 设置波特率
        .data_bits(8)             // 数据位
        .flow_control_none()      // 无流控制
        .parity_none()            // 无校验位
        .stop_bits(1)             // 停止位
        .open(device)?;           // 打开串口设备

    // 设置读写超时时间
    port.set_timeout(Duration::from_millis(1000))?;

    println!("Serial port opened successfully. Press Ctrl+C to exit.");

    // 主通信循环
    let mut buffer = [0u8; 1024];
    loop {
        // 尝试读取数据
        match port.read(&mut buffer) {
            Ok(bytes_read) if bytes_read > 0 => {
                let received_data = &buffer[..bytes_read];
                println!("Received {} bytes: {:?}", bytes_read, received_data);
                
                // 尝试转换为字符串显示
                if let Ok(text) = std::str::from_utf8(received_data) {
                    println!("As text: {}", text);
                }
                
                // 自动回复接收到的数据
                port.write_all(received_data)?;
                println!("Echoed back {} bytes", bytes_read);
            }
            Ok(_) => {
                // 没有数据收到，发送测试消息
                let test_message = b"PING";
                port.write_all(test_message)?;
                println!("Sent: {:?}", test_message);
                
                // 短暂等待
                std::thread::sleep(Duration::from_millis(500));
            }
            Err(e) if e.kind() == io::ErrorKind::TimedOut => {
                // 超时是正常的，继续循环
                continue;
            }
            Err(e) => {
                eprintln!("Read error: {}", e);
                break;
            }
        }
    }

    Ok(())
}

这个完整示例展示了如何：

1. 枚举系统中可用的串口设备
2. 配置串口通信参数（波特率、数据位、停止位等）
3. 打开串口设备并进行双向数据通信
4. 处理超时和错误情况
5. 实现简单的数据回显功能

使用时请根据实际硬件设备修改串口设备路径和通信参数。