Struct usbd_serial::SerialPort

pub struct SerialPort<'a, B, RS = DefaultBufferStore, WS = DefaultBufferStore>
where
    B: UsbBus,
    RS: BorrowMut<[u8]>,
    WS: BorrowMut<[u8]>,
{ /* private fields */ }

USB (CDC-ACM) serial port with built-in buffering to implement stream-like behavior.

The RS and WS type arguments specify the storage for the read/write buffers, respectively. By default an internal 128 byte buffer is used for both directions.

Implementations

impl<'a, B> SerialPort<'a, B>

where B: UsbBus,

pub fn new<'alloc: 'a>( alloc: &'alloc UsbBusAllocator<B> ) -> SerialPort<'a, B, DefaultBufferStore, DefaultBufferStore>

Creates a new USB serial port with the provided UsbBus and 128 byte read/write buffers.

pub fn new_with_interface_names<'alloc: 'a>( alloc: &'alloc UsbBusAllocator<B>, comm_if_name: Option<&'static str>, data_if_name: Option<&'static str> ) -> SerialPort<'a, B, DefaultBufferStore, DefaultBufferStore>

Same as SerialPort::new, but allows specifying the names of the interfaces

impl<'a, B, RS, WS> SerialPort<'a, B, RS, WS>

where B: UsbBus, RS: BorrowMut<[u8]>, WS: BorrowMut<[u8]>,

pub fn new_with_store<'alloc: 'a>( alloc: &'alloc UsbBusAllocator<B>, read_store: RS, write_store: WS ) -> SerialPort<'a, B, RS, WS>

Creates a new USB serial port with the provided UsbBus and buffer backing stores.

pub fn new_with_store_and_interface_names<'alloc: 'a>( alloc: &'alloc UsbBusAllocator<B>, read_store: RS, write_store: WS, comm_if_name: Option<&'static str>, data_if_name: Option<&'static str> ) -> SerialPort<'a, B, RS, WS>

Creates a new USB serial port with the provided UsbBus and buffer backing stores.

pub fn line_coding(&self) -> &LineCoding

Gets the current line coding.

pub fn dtr(&self) -> bool

Gets the DTR (data terminal ready) state

pub fn rts(&self) -> bool

Gets the RTS (request to send) state

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

Writes bytes from data into the port and returns the number of bytes written.

Errors

• WouldBlock - No bytes could be written because the buffers are full.

Other errors from usb-device may also be propagated.

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

Reads bytes from the port into data and returns the number of bytes read.

Errors

• WouldBlock - No bytes available for reading.

Other errors from usb-device may also be propagated.

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

Sends as much as possible of the current write buffer. Returns Ok if all data that has been written has been completely written to hardware buffers Err(WouldBlock) if there is still data remaining, and other errors if there’s an error sending data to the host. Note that even if this method returns Ok, data may still be in hardware buffers on either side.

Trait Implementations

impl<Bus: UsbBus, RS: BorrowMut<[u8]>, WS: BorrowMut<[u8]>> ErrorType for SerialPort<'_, Bus, RS, WS>

type Error = Error

Error type of all the IO operations on this type.

impl<Bus: UsbBus, RS: BorrowMut<[u8]>, WS: BorrowMut<[u8]>> Read for SerialPort<'_, Bus, RS, WS>

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

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

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

Read the exact number of bytes required to fill buf.

impl<Bus: UsbBus, RS: BorrowMut<[u8]>, WS: BorrowMut<[u8]>> ReadReady for SerialPort<'_, Bus, RS, WS>

fn read_ready(&mut self) -> Result<bool, Self::Error>

Get whether the reader is ready for immediately reading.

impl<B, RS, WS> UsbClass<B> for SerialPort<'_, B, RS, WS>

where B: UsbBus, RS: BorrowMut<[u8]>, WS: BorrowMut<[u8]>,

fn get_configuration_descriptors( &self, writer: &mut DescriptorWriter<'_> ) -> Result<()>

Called when a GET_DESCRIPTOR request is received for a configuration descriptor. When called, the implementation should write its interface, endpoint and any extra class descriptors into writer. The configuration descriptor itself will be written by UsbDevice and shouldn’t be written by classes.

fn get_string(&self, index: StringIndex, lang_id: LangID) -> Option<&str>

Gets a class-specific string descriptor.

fn reset(&mut self)

Called after a USB reset after the bus reset sequence is complete.

fn endpoint_in_complete(&mut self, addr: EndpointAddress)

Called when endpoint with address addr has completed transmitting data (IN packet).

fn control_in(&mut self, xfer: ControlIn<'_, '_, '_, B>)

Called when a control request is received with direction DeviceToHost.

fn control_out(&mut self, xfer: ControlOut<'_, '_, '_, B>)

Called when a control request is received with direction HostToDevice.

fn get_bos_descriptors( &self, writer: &mut BosWriter<'_, '_> ) -> Result<(), UsbError>

Called when a GET_DESCRIPTOR request is received for a BOS descriptor. When called, the implementation should write its blobs such as capability descriptors into writer. The BOS descriptor itself will be written by UsbDevice and shouldn’t be written by classes.

fn poll(&mut self)

Called whenever the UsbDevice is polled.

fn endpoint_setup(&mut self, addr: EndpointAddress)

Called when endpoint with address addr has received a SETUP packet. Implementing this shouldn’t be necessary in most cases, but is provided for completeness’ sake.

fn endpoint_out(&mut self, addr: EndpointAddress)

Called when endpoint with address addr has received data (OUT packet).

fn get_alt_setting(&mut self, interface: InterfaceNumber) -> Option<u8>

Called when the interfaces alternate setting state is requested.

fn set_alt_setting( &mut self, interface: InterfaceNumber, alternative: u8 ) -> bool

Called when the interfaces alternate setting state is altered.

impl<Bus: UsbBus, RS: BorrowMut<[u8]>, WS: BorrowMut<[u8]>> Write for SerialPort<'_, Bus, RS, WS>

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

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

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

Flush this output stream, blocking until all intermediately buffered contents reach their destination.

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

Write an entire buffer into this writer.

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

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

impl<Bus: UsbBus, RS: BorrowMut<[u8]>, WS: BorrowMut<[u8]>> WriteReady for SerialPort<'_, Bus, RS, WS>

fn write_ready(&mut self) -> Result<bool, Self::Error>

Get whether the writer is ready for immediately writing.

impl<B, RS, WS> Read<u8> for SerialPort<'_, B, RS, WS>

where B: UsbBus, RS: BorrowMut<[u8]>, WS: BorrowMut<[u8]>,

type Error = UsbError

Read error

fn read(&mut self) -> Result<u8, Self::Error>

Reads a single word from the serial interface

impl<B, RS, WS> Write<u8> for SerialPort<'_, B, RS, WS>

where B: UsbBus, RS: BorrowMut<[u8]>, WS: BorrowMut<[u8]>,

type Error = UsbError

Write error

fn write(&mut self, word: u8) -> Result<(), Self::Error>

Writes a single word to the serial interface

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

Ensures that none of the previously written words are still buffered