Struct mio_serial::SerialPort

pub struct SerialPort { /* fields omitted */ }

A mio compatable serial port for *nix

Methods

impl SerialPort

fn open<T: AsRef<Path>>(path: T) -> Result<Self>

Construct a new SerialPort

Opens the a serial port at the location provided by path with the following default settings:

• 9600,8N1 (9600 Baud, 8-bit data, no parity, 1 stop bit)
• Receiver enabled in "Cannonical mode"
• Non-blocking
• No flow control (software OR hardware)
• Ignores hardware control lines

Errors

SerialPort construction can fail for a few reasons:

• An invalid path is provided
• The path does not represent a serial port device
• We are unable to configure the serial port ANY of the default settings. (Unlikely... but IS possible)

fn termios(&self) -> Result<Termios>

Retrieve the termios structure for the serial port.

fn set_termios(&mut self, action: i32, t: &Termios) -> Result<()>

Set low-level serial port settings

The action parameter must be one of the following:

• termios::TCSANOW Update immediately
• termios::TCSADRAIN Finish reading buffered data before updating.
• termios::TCSAFLUSH Finish writing buffered data before updating.

Errors

Will return ErrorKind::InvalidInput if action is not one of the three constants defined above.

fn set_nonblocking(&mut self, blocking: bool) -> Result<()>

Enable or disable blocking reads and writes.

Panics

Will panic if the underlying fcntl system call returns a value other than 0 or -1

fn is_blocking(&self) -> Result<bool>

Get the current blocking mode for the serial port

Panics

Will panic if the underlying fcntl system call returns a value other than 0 or -1

fn maybe_write(&mut self, buf: &[u8]) -> Result<Option<usize>>

Try writing some data.

Similar to the standard io::Write implementation, but errors due to blocking IO are translated into Ok(None) results.

Returns

• Ok(Some(size)) on successful writes
• Ok(None) if calling write would block.
• Err(e) for all other IO errors

fn maybe_read(&mut self, buf: &mut [u8]) -> Result<Option<usize>>

Try reading some data.

Similar to the standard io::Read implementation, but errors due to blocking IO are translated into Ok(None) results.

Returns

• Ok(Some(size)) on successful reads
• Ok(None) if calling read would block.
• Err(e) for all other IO errors

fn set_baudrate(&mut self, baud: i32) -> Result<()>

Set the serial baudrate

Valid baudrates are:

• 0
• 50
• 75
• 110
• 134
• 150
• 200
• 300
• 600
• 1200
• 1800
• 2400
• 4800
• 9600
• 19200
• 38400

Errors

Returns an io::ErrorKind::InvalidInput for baud rates no in the list above.

fn baudrate(&self) -> Result<i32>

Get the serial baudrate

Valid baudrates are:

• 0
• 50
• 75
• 110
• 134
• 150
• 200
• 300
• 600
• 1200
• 1800
• 2400
• 4800
• 9600
• 19200
• 38400

Errors

Returns an io::ErrorKind::InvalidInput for baud rates no in the list above.

fn set_raw(&mut self, raw: bool) -> Result<()>

Enable or disable raw mode

In raw mode, input is available character by character, echoing is disabled, and all special processing of terminal input and output characters is disabled.

fn is_raw(&self) -> bool

Return if raw mode is enabled or not.

Trait Implementations

impl Drop for SerialPort

fn drop(&mut self)

A method called when the value goes out of scope.

impl AsRawFd for SerialPort

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl Read for SerialPort

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

fn chars(self) -> Chars<Self>

Unstable (io)

: the semantics of a partial read/write of where errors happen is currently unclear and may change

Transforms this Read instance to an Iterator over chars.

fn chain<R>(self, next: R) -> Chain<Self, R> where R: Read

Creates an adaptor which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adaptor which will read at most limit bytes from it.

impl Write for SerialPort

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this object, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this write.

fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Write.

impl Evented for SerialPort

fn register(&self,
            poll: &Poll,
            token: Token,
            interest: Ready,
            opts: PollOpt)
            -> Result<()>

fn reregister(&self,
              poll: &Poll,
              token: Token,
              interest: Ready,
              opts: PollOpt)
              -> Result<()>

fn deregister(&self, poll: &Poll) -> Result<()>