Serial Core

《serial-core》crate 提供用于与串口接口和实现的抽象类型。它们可以用于编写适用于所有串口类型的通用代码，并实现与通用代码一起工作的新串口类型。

• 文档

用法

在 Cargo.toml 中将 serial-core 添加为依赖项

[dependencies]
serial-core = "0.4"

与打开的串口接口

导入 serial-core crate 和 serial_core::prelude 模块中的所有内容。在 serial_core::prelude 模块中的特性能在处理串口时解析特型方法，并且不太可能与其他crate冲突。

extern crate serial_core as serial;

use std::io;
use std::time::Duration;

use std::io::prelude::*;
use serial::prelude::*;

配置和I/O

通过 SerialPort、std::io::Read 和 std::io::Write 特型来处理串口接口，这些特型提供了配置、I/O和控制信号的方法。

fn probe<P: SerialPort>(port: &mut P) -> io::Result<()> {
    let mut buf: Vec<u8> = (0..255).collect();

    // configuration
    try!(port.reconfigure(&|settings| {
        try!(settings.set_baud_rate(serial::Baud9600));
        settings.set_char_size(serial::Bits8);
        settings.set_parity(serial::ParityNone);
        settings.set_stop_bits(serial::Stop1);
        settings.set_flow_control(serial::FlowNone);
        Ok(())
    }));

    // I/O
    try!(port.set_timeout(Duration::from_millis(100)));
    try!(port.write(&buf[..]));
    try!(port.read(&mut buf[..]));

    // control signals
    try!(port.set_dtr(true));
    try!(port.read_dsr());

    Ok(())
}

有关使用打开串口的详细信息，请参阅 SerialPort 特型 的文档。

获取串口的所有权

通常情况下，您可能希望在串口上实现高级协议，在这种情况下，您可能需要一个拥有串口并提供针对高级协议的特定接口的手柄对象。

为了实现不要求泛型爆炸的通用串口处理程序，可以在特型中定义高级协议

struct Handle<P: SerialPort> {
    port: P,
}

impl<P: SerialPort> Handle<P> {
    fn new(port: P) -> Self {
        Handle { port: port }
    }
}

impl<P: SerialPort> Greet for Handle<P> {
    fn get_name(&mut self) -> serial::Result<String> {
        let mut name = String::new();

        try!(self.port.write("What is your name? "));
        try!(self.port.read_to_string(&mut name));

        Ok(name)
    }

    fn say_hello(&mut self, name: &String) -> serial::Result<()> {
        try!(writeln!(&mut self.port, "Hello, {}!", name));
        Ok(())
    }
}

fn greet(greeter: &mut Greet) -> serial::Result<()> {
    let name = try!(greeter.get_name());

    greeter.say_hello(name)
}

请注意，在上面的例子中，greet() 函数可以通过 Greet trait 与 Handle 结构体进行交互，而不关心它所交互的 SerialPort 类型。

或者，由于 SerialPort 是对象安全的，它可以在句柄内部被封装。然而，这种方法可能会引入额外的指针间接引用。

struct Handle {
    port: Box<SerialPort>,
}

impl Handle {
    fn new<P: SerialPort>(port: P) -> Self {
        Handle { port: Box::new(port) }
    }

    fn get_name(&mut self) -> serial::Result<String> {
        // ...
    }

    fn say_hello(&mut self, name: &String) -> serial::Result<()> {
        // ...
    }
}

实现自定义串行端口

串行端口 crate 设计为可扩展的，允许第三方定义自定义串行端口类型。实现自定义串行端口类型的原因可能包括将串行端口桥接到 TCP 套接字或其他 I/O 设备，提供用于测试的假实现，或者与自定义硬件集成。

要定义一个自定义串行端口类型，首先导入 serial_core crate

extern crate serial_core as serial;

use std::io;
use std::time::Duration;

接下来，定义一个将实现新的串行端口类型和可选的设置类型

struct CustomSerialPort {
    // ...
}

struct CustomSerialPortSettings {
    // ...
}

为新的串行端口类型实现 SerialDevice，std::io::Read 和 std::io::Write

impl serial::SerialDevice for CustomSerialPort {
    type Settings = CustomSerialPortSettings;

    fn read_settings(&self) -> serial::Result<Self::Settings> { ... }
    fn write_settings(&mut self, settings: &Self::Settings) -> serial::Result<()> { ... }
    fn timeout(&self) -> Duration { ... }
    fn set_timeout(&mut self, timeout: Duration) -> serial::Result<()> { ... }

    fn set_rts(&mut self, level: bool) -> serial::Result<()> { ... }
    fn set_dtr(&mut self, level: bool) -> serial::Result<()> { ... }
    fn read_cts(&mut self) -> serial::Result<bool> { ... }
    fn read_dsr(&mut self) -> serial::Result<bool> { ... }
    fn read_ri(&mut self) -> serial::Result<bool> { ... }
    fn read_cd(&mut self) -> serial::Result<bool> { ... }
}

impl io::Read for CustomSerialPort {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { ... }
}

impl io::Write for CustomSerialPort {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> { ... }
    fn flush(&mut self) -> io::Result<()> { ... }
}

如果不需要自定义设置类型，则可以使用 PortSettings 结构体 作为 SerialDevice::Settings 关联类型的默认值。否则，Settings 类型必须实现 SerialPortSettings

impl serial::SerialPortSettings for CustomSerialPortSettings {
    fn baud_rate(&self) -> Option<BaudRate> { ... }
    fn char_size(&self) -> Option<CharSize> { ... }
    fn parity(&self) -> Option<Parity> { ... }
    fn stop_bits(&self) -> Option<StopBits> { ... }
    fn flow_control(&self) -> Option<FlowControl> { ... }

    fn set_baud_rate(&mut self, baud_rate: BaudRate) -> serial::Result<()> { ... }
    fn set_char_size(&mut self, char_size: CharSize) { ... }
    fn set_parity(&mut self, parity: Parity) { ... }
    fn set_stop_bits(&mut self, stop_bits: StopBits) { ... }
    fn set_flow_control(&mut self, flow_control: FlowControl) { ... }
}

有关实现新的串行端口类型的详细信息，请参阅 SerialDevice trait 的文档。

许可证

版权所有 © 2015 David Cuddeback

在 MIT 许可证 下分发。