Struct serial_io::TTYPort

pub struct TTYPort { /* fields omitted */ }

A serial port implementation for POSIX TTY ports

The port will be closed when the value is dropped. However, this struct should not be instantiated directly by using TTYPort::open(), instead use the cross-platform serialport::open() or serialport::open_with_settings().

Implementations

impl TTYPort

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

Opens a TTY device as a serial port.

path should be the path to a TTY device, e.g., /dev/ttyS0.

Ports are opened in exclusive mode by default. If this is undesireable behavior, use TTYPort::set_exclusive(false).

Errors

• NoDevice if the device could not be opened. This could indicate that the device is already in use.
• InvalidInput if path is not a valid device name.
• Io for any other error while opening or initializing the device.

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 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 pair() -> Result<(TTYPort, TTYPort), Error>

Create a pair of pseudo serial terminals

Returns

Two connected TTYPort objects: (master, slave)

Errors

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

On some platforms manipulating the master port will fail and only modifying the slave port is possible.

Examples

use serialport::TTYPort;

let (master, slave) = TTYPort::pair().unwrap();

pub fn send_break(&self, duration: BreakDuration) -> Result<(), Error>

Sends 0-valued bits over the port for a set duration

pub fn try_clone_native(&self) -> Result<TTYPort, Error>

Attempts to clone the SerialPort. This allow you to write and read simultaneously from the same serial connection. Please note that if you want a real asynchronous serial port you should look at mio-serial or tokio-serial.

Also, you must be very careful when changing the settings of a cloned SerialPort : since the settings are cached on a per object basis, trying to modify them from two different objects can cause some nasty behavior.

This is the same as SerialPort::try_clone() but returns the concrete type instead.

Errors

This function returns an error if the serial port couldn’t be cloned.

Trait Implementations

impl AsRawFd for TTYPort

pub fn as_raw_fd(&self) -> i32

Extracts the raw file descriptor.

impl Debug for TTYPort

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

Formats the value using the given formatter.

impl Drop for TTYPort

pub fn drop(&mut self)

Executes the destructor for this type.

impl FromRawFd for TTYPort

pub unsafe fn from_raw_fd(fd: i32) -> TTYPort

Constructs a new instance of Self from the given raw file descriptor.

impl IntoRawFd for TTYPort

pub fn into_raw_fd(self) -> i32

Consumes this object, returning the raw underlying file descriptor.

impl Read for TTYPort

pub 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.

unsafe fn initializer(&self) -> Initializer

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

Determines if this Reader can work with buffers of uninitialized memory.

fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> 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, appending them to 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 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 SerialPort for TTYPort

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

Returns the port’s baud rate

On some platforms this will be the actual device baud rate, which may differ from the desired baud rate.

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

Returns the name of this port if it exists.

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

Returns the character size.

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

Returns the flow control mode.

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

Returns the parity-checking mode.

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

Returns the number of stop bits.

pub fn timeout(&self) -> Duration

Returns the current timeout.

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

Sets the baud rate.

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

Sets the flow control mode.

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

Sets the parity-checking mode.

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

Sets the character size.

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

Sets the number of stop bits.

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

Sets the timeout for future I/O operations.

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

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

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

Writes to the Data Terminal Ready pin

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

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

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

Reads the state of the Data Set Ready control signal.

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

Reads the state of the Ring Indicator control signal.

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

Reads the state of the Carrier Detect control signal.

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

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

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

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

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

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

pub fn try_clone(&self) -> Result<Box<dyn SerialPort + 'static, Global>, Error>

Attempts to clone the SerialPort. This allow you to write and read simultaneously from the same serial connection. Please note that if you want a real asynchronous serial port you should look at mio-serial or tokio-serial.

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

Start transmitting a break

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

Stop transmitting a break

impl Write for TTYPort

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

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

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

Flush 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, 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.