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
|
//! Duplex example
//!
//! This example tests the ability to clone a serial port. It works by creating
//! a new file descriptor, and therefore a new `SerialPort` object that's safe
//! to send to a new thread.
//!
//! This example selects the first port on the system, clones the port into a child
//! thread that writes data to the port every second. While this is running the parent
//! thread continually reads from the port.
//!
//! To test this, have a physical or virtual loopback device connected as the
//! only port in the system.
use std::io::Write;
use std::time::Duration;
use std::{io, thread};
fn main() {
// Open the first serialport available.
let port_name = &serialport::available_ports().expect("No serial port")[0].port_name;
let mut port = serialport::new(port_name, 9600)
.open()
.expect("Failed to open serial port");
// Clone the port
let mut clone = port.try_clone().expect("Failed to clone");
// Send out 4 bytes every second
thread::spawn(move || loop {
clone
.write_all(&[5, 6, 7, 8])
.expect("Failed to write to serial port");
thread::sleep(Duration::from_millis(1000));
});
// Read the four bytes back from the cloned port
let mut buffer: [u8; 1] = [0; 1];
loop {
match port.read(&mut buffer) {
Ok(bytes) => {
if bytes == 1 {
println!("Received: {:?}", buffer);
}
}
Err(ref e) if e.kind() == io::ErrorKind::TimedOut => (),
Err(e) => eprintln!("{:?}", e),
}
}
}
|
