serial 0.0.4

Rust library for accessing serial ports.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

# Serial
This crate provides Rust programs with access to serial ports. Serials ports are defined as traits
to support extension through custom serial port implementations. The goals of the `serial` crate are
to support all platforms supported by Rust. Currently, only Unix TTY devices are supported.

## Usage
Add `serial` as a dependency in `Cargo.toml`:

```toml
[dependencies]
serial = "0.0.4"
```

Import the `serial` crate and everything from the `serial::prelude` module. The `serial::prelude`
module contains traits that are useful to have in scope. All the traits in `prelude` begin with
`Serial` to avoid name conflicts with other crates. Having the traits in scope avoids compiler
errors when using serial ports.

For now, you must open a serial port using a system-specific method. Once you've opened a serial
port, you can interact with it using the `SerialPort` and `SerialPortExt` traits. By depending on
the traits, your code will support future implementations of serial ports, including custom
implementations such as those for embedded systems.

```rust
extern crate serial;

use std::io;
use std::path::Path;

// import useful traits
use serial::prelude::*;

fn main() {
  // opening port is system-specific
  let mut port = serial::posix::TTYPort::open(&Path::new("/dev/ttyUSB0")).unwrap();
  do_something(&mut port).unwrap();
}

// use SerialPort trait to program generically
fn do_something<T: SerialPort>(port: &mut T) -> io::Result<()> {
  try!(port.configure(|settings| {
    settings.set_baud_rate(serial::Baud115200);
    settings.set_char_size(serial::Bits8);
    settings.set_parity(serial::ParityNone);
    settings.set_stop_bits(serial::Stop1);
    settings.set_flow_control(serial::FlowNone);
  }));

  // read and write to port using Read and Write traits
  try!(port.read(...));
  try!(port.write(...));

  Ok(())
}
```

## Contributors
* [dcuddeback](https://github.com/dcuddeback)
* [willem66745](https://github.com/willem66745)

## License
Copyright © 2015 David Cuddeback

Distributed under the [MIT License](LICENSE).