Struct CdcAcmClass

pub struct CdcAcmClass<'d, D: Driver<'d>> { /* private fields */ }

Packet level implementation of a CDC-ACM serial port.

This class can be used directly and it has the least overhead due to directly reading and writing USB packets with no intermediate buffers, but it will not act like a stream-like serial port. The following constraints must be followed if you use this class directly:

• read_packet must be called with a buffer large enough to hold max_packet_size bytes.
• write_packet must not be called with a buffer larger than max_packet_size bytes.
• If you write a packet that is exactly max_packet_size bytes long, it won’t be processed by the host operating system until a subsequent shorter packet is sent. A zero-length packet (ZLP) can be sent if there is no other data to send. This is because USB bulk transactions must be terminated with a short packet, even if the bulk endpoint is used for stream-like data.

Implementations

impl<'d, D: Driver<'d>> CdcAcmClass<'d, D>

pub fn new( builder: &mut Builder<'d, D>, state: &'d mut State<'d>, max_packet_size: u16, ) -> Self

Creates a new CdcAcmClass with the provided UsbBus and max_packet_size in bytes. For full-speed devices, max_packet_size has to be one of 8, 16, 32 or 64.

pub fn max_packet_size(&self) -> u16

Gets the maximum packet size in bytes.

pub fn line_coding(&self) -> LineCoding

Gets the current line coding. The line coding contains information that’s mainly relevant for USB to UART serial port emulators, and can be ignored if not relevant.

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 async fn write_packet(&mut self, data: &[u8]) -> Result<(), EndpointError>

Writes a single packet into the IN endpoint.

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

Reads a single packet from the OUT endpoint.

pub async fn wait_connection(&mut self)

Waits for the USB host to enable this interface

pub fn split(self) -> (Sender<'d, D>, Receiver<'d, D>)

Split the class into a sender and receiver.

This allows concurrently sending and receiving packets from separate tasks.

pub fn split_with_control( self, ) -> (Sender<'d, D>, Receiver<'d, D>, ControlChanged<'d>)

Split the class into sender, receiver and control

Allows concurrently sending and receiving packets whilst monitoring for control changes (dtr, rts)