Struct VirtualPort 

pub struct VirtualPort { /* private fields */ }

VirtualPort simulates a serial port for testing purposes. It supports setting various serial port parameters like baud rate, data bits, flow control, parity, and stop bits. It also supports reading from and writing to buffers.

Port pair wiring diagram:

Port 1 Port 2 ┌─────┐ ┌─────┐ │ TXD ├──────────▶│ RXD │ │ RXD │◂──────────┤ TXD │ │ RTS ├──────────▶│ CTS │ │ CTS │◂──────────┤ RTS │ │ DTR ├─────────┬▶│ DSR │ │ │ └▶│ CD │ │ DSR │◂┬─────────┤ DTR │ │ CD │◂┘ │ │ │ RI ├───────────┤ RI │ └─────┘ └─────┘

Implementations

impl VirtualPort

pub fn loopback(baud_rate: u32, buffer_capacity: u32) -> Result<Self>

Opens a single loopback virtual port with the specified baud rate.

Examples found in repository

examples/loopback.rs (line 6)

fn main() {
    let mut port = VirtualPort::loopback(9600, 1024).unwrap();
    let write_data = b"hello";
    let mut read_data = [0u8; 5];

    port.write_all(write_data).unwrap();
    port.read_exact(&mut read_data).unwrap();
    assert_eq!(&read_data, write_data);
}

pub fn pair(baud_rate: u32, buffer_capacity: u32) -> Result<(Self, Self)>

Opens a pair of connected virtual ports with the specified baud rate. These ports can simulate a communication between two devices.

Examples found in repository

examples/pair.rs (line 6)

fn main() {
    let (mut port1, mut port2) = VirtualPort::pair(9600, 1024).unwrap();
    let write_data = b"hello";
    let mut read_data = [0u8; 5];

    port1.write_all(write_data).unwrap();
    port2.read_exact(&mut read_data).unwrap();
    assert_eq!(&read_data, write_data);
}

pub fn into_boxed(self) -> Box<dyn SerialPort>

Boxes the instance as a SerialPort.

pub fn simulate_delay(&self) -> bool

Returns whether transmission delay simulation is enabled.

pub fn set_simulate_delay(&mut self, value: bool)

Sets whether to simulate the transmission delay for reading operations.

pub fn noise_on_config_mismatch(&self) -> bool

Returns whether to simulate corrupted symbols if physical settings don’t match.

pub fn set_noise_on_config_mismatch(&mut self, value: bool)

Sets whether to simulate corrupted symbols if physical settings don’t match.

Trait Implementations

impl Clone for VirtualPort

fn clone(&self) -> VirtualPort

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Read for VirtualPort

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_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” adapter 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.

fn read_array<const N: usize>(&mut self) -> Result<[u8; N], Error>

where Self: Sized,

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

Read and return a fixed array of bytes from this source.

impl SerialPort for VirtualPort

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

Returns the name of this port if it exists.

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

Returns the current baud rate.

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

Returns the character size.

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

Returns the flow control mode.

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

Returns the parity-checking mode.

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

Returns the number of stop bits.

fn timeout(&self) -> Duration

Returns the current timeout.

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

Sets the baud rate.

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

Sets the flow control mode.

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

Sets the parity-checking mode.

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

Sets the character size.

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

Sets the number of stop bits.

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

Sets the timeout for future I/O operations.

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

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

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

Writes to the Data Terminal Ready pin

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

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

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

Reads the state of the Data Set Ready control signal.

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

Reads the state of the Ring Indicator control signal.

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

Reads the state of the Carrier Detect control signal.

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

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

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

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

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

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

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

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.

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

Start transmitting a break

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

Stop transmitting a break

impl Write for VirtualPort

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

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

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

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.