Struct MidiClass

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

Packet level implementation of a USB MIDI device.

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 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> MidiClass<'d, D>

where D: Driver<'d>,

pub fn new( builder: &mut Builder<'d, D>, n_in_jacks: u8, n_out_jacks: u8, max_packet_size: u16, ) -> MidiClass<'d, D>

Creates a new MidiClass with the provided UsbBus, number of input and output jacks 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 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.