Struct SerialStream

pub struct SerialStream { /* private fields */ }

Async serial port I/O

Reading and writing to a SerialStream is usually done using the convenience methods found on the tokio::io::AsyncReadExt and tokio::io::AsyncWriteExt traits.

Implementations

impl SerialStream

pub fn open(builder: &SerialPortBuilder) -> Result<SerialStream, Error>

Open serial port from a provided path, using the default reactor.

pub fn pair() -> Result<(SerialStream, SerialStream), Error>

Create a pair of pseudo serial terminals using the default reactor

Returns

Two connected, unnamed Serial objects.

Errors

Attempting any IO or parameter settings on the slave tty after the master tty is closed will return errors.

Examples

use tokio_serial::SerialStream;

#[tokio::main]
async fn main() {
    let (master, slave) = SerialStream::pair().unwrap();
}

pub fn set_exclusive(&mut self, exclusive: bool) -> Result<(), Error>

Sets the exclusivity of the port

If a port is exclusive, then trying to open the same device path again will fail.

See the man pages for the tiocexcl and tiocnxcl ioctl’s for more details.

Errors

• Io for any error while setting exclusivity for the port.

pub fn exclusive(&self) -> bool

Returns the exclusivity of the port

If a port is exclusive, then trying to open the same device path again will fail.

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

Try to read bytes on the serial port. On success returns the number of bytes read.

The function must be called with valid byte array buf of sufficient size to hold the message bytes. If a message is too long to fit in the supplied buffer, excess bytes may be discarded.

When there is no pending data, Err(io::ErrorKind::WouldBlock) is returned. This function is usually paired with readable().

pub async fn readable(&self) -> Result<(), Error>

Wait for the port to become readable.

This function is usually paired with try_read().

The function may complete without the socket being readable. This is a false-positive and attempting a try_read() will return with io::ErrorKind::WouldBlock.

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

Try to write bytes on the serial port. On success returns the number of bytes written.

When the write would block, Err(io::ErrorKind::WouldBlock) is returned. This function is usually paired with writable().

pub async fn writable(&self) -> Result<(), Error>

Wait for the port to become writable.

This function is usually paired with try_write().

The function may complete without the socket being readable. This is a false-positive and attempting a try_write() will return with io::ErrorKind::WouldBlock.

Trait Implementations

impl AsRawFd for SerialStream

fn as_raw_fd(&self) -> i32

Extracts the raw file descriptor.

impl AsyncRead for SerialStream

fn poll_read( self: Pin<&mut SerialStream>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<(), Error>>

Attempts to ready bytes on the serial port.

Note that on multiple calls to a poll_* method in the read direction, only the Waker from the Context passed to the most recent call will be scheduled to receive a wakeup.

Return value

The function returns:

• Poll::Pending if the socket is not ready to read
• Poll::Ready(Ok(())) reads data ReadBuf if the socket is ready
• Poll::Ready(Err(e)) if an error is encountered.

Errors

This function may encounter any standard I/O error except WouldBlock.

impl AsyncWrite for SerialStream

fn poll_write( self: Pin<&mut SerialStream>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize, Error>>

Attempts to send data on the serial port

Note that on multiple calls to a poll_* method in the send direction, only the Waker from the Context passed to the most recent call will be scheduled to receive a wakeup.

Return value

The function returns:

• Poll::Pending if the socket is not available to write
• Poll::Ready(Ok(n)) n is the number of bytes sent
• Poll::Ready(Err(e)) if an error is encountered.

Errors

This function may encounter any standard I/O error except WouldBlock.

fn poll_flush( self: Pin<&mut SerialStream>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Attempts to flush the object, ensuring that any buffered data reach their destination.

fn poll_shutdown( self: Pin<&mut SerialStream>, cx: &mut Context<'_>, ) -> Poll<Result<(), Error>>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

fn poll_write_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>

Like poll_write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation.

impl Debug for SerialStream

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Read for SerialStream

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

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

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

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

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

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

Reads all bytes until EOF in this source, appending them to buf.

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

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

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

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

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

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

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

where Self: Sized,

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

impl SerialPort for SerialStream

fn try_clone(&self) -> Result<Box<dyn SerialPort>, Error>

Cloning SerialStream is not supported.

Errors

Always returns ErrorKind::Other with a message.

fn name(&self) -> Option<String>

Returns the name of this port if it exists.

fn baud_rate(&self) -> Result<u32, Error>

Returns the current baud rate.

fn data_bits(&self) -> Result<DataBits, Error>

Returns the character size.

fn flow_control(&self) -> Result<FlowControl, Error>

Returns the flow control mode.

fn parity(&self) -> Result<Parity, Error>

Returns the parity-checking mode.

fn stop_bits(&self) -> Result<StopBits, Error>

Returns the number of stop bits.

fn timeout(&self) -> Duration

Returns the current timeout.

fn set_baud_rate(&mut self, baud_rate: u32) -> Result<(), Error>

Sets the baud rate.

fn set_data_bits(&mut self, data_bits: DataBits) -> Result<(), Error>

Sets the character size.

fn set_flow_control(&mut self, flow_control: FlowControl) -> Result<(), Error>

Sets the flow control mode.

fn set_parity(&mut self, parity: Parity) -> Result<(), Error>

Sets the parity-checking mode.

fn set_stop_bits(&mut self, stop_bits: StopBits) -> Result<(), Error>

Sets the number of stop bits.

fn set_timeout(&mut self, _: Duration) -> Result<(), Error>

Sets the timeout for future I/O operations.

fn write_request_to_send(&mut self, level: bool) -> Result<(), Error>

Sets the state of the RTS (Request To Send) control signal.

fn write_data_terminal_ready(&mut self, level: bool) -> Result<(), Error>

Writes to the Data Terminal Ready pin

fn read_clear_to_send(&mut self) -> Result<bool, Error>

Reads the state of the CTS (Clear To Send) control signal.

fn read_data_set_ready(&mut self) -> Result<bool, Error>

Reads the state of the Data Set Ready control signal.

fn read_ring_indicator(&mut self) -> Result<bool, Error>

Reads the state of the Ring Indicator control signal.

fn read_carrier_detect(&mut self) -> Result<bool, Error>

Reads the state of the Carrier Detect control signal.

fn bytes_to_read(&self) -> Result<u32, Error>

Gets the number of bytes available to be read from the input buffer.

fn bytes_to_write(&self) -> Result<u32, Error>

Get the number of bytes written to the output buffer, awaiting transmission.

fn clear(&self, buffer_to_clear: ClearBuffer) -> Result<(), Error>

Discards all bytes from the serial driver’s input buffer and/or output buffer.

fn set_break(&self) -> Result<(), Error>

Start transmitting a break

fn clear_break(&self) -> Result<(), Error>

Stop transmitting a break

impl TryFrom<TTYPort> for SerialStream

type Error = Error

The type returned in the event of a conversion error.

fn try_from( value: TTYPort, ) -> Result<SerialStream, <SerialStream as TryFrom<TTYPort>>::Error>

Performs the conversion.

impl Write for SerialStream

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

Writes a buffer into this writer, returning how many bytes were written.

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

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

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

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

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

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

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

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.