Struct rpos_drv::Channel

pub struct Channel<P, T: ?Sized> { /* private fields */ }

Channel encode and decode message with protocol, and send and receive bytes via stream

Examples

let mut channel = Channel::new(
    RplidarProtocol::new(),
    serial_port
);
 
channel.write(&Message::new(1)).unwrap();

Implementations

impl<P, T> Channel<P, T>where
    P: ProtocolDecoder + ProtocolEncoder,
    T: Read + Write + ?Sized,

pub fn new(protocol: P, stream: Box<T>) -> Channel<P, T>

Create a new Channel to read and write messages

Example

let channel = Channel::new(
    RplidarProtocol::new(),
    serial_port
);

pub fn with_read_buffer_size(
    protocol: P,
    stream: Box<T>,
    read_buffer_size: usize
) -> Channel<P, T>

Create a new Channel with non-default ring buffer capacity

Example

let channel = Channel::with_read_buffer_size(
    RplidarProtocol::new(),
    serial_port,
    100000 as usize
);

pub fn reset(&mut self)

Reset the channel status This function is usually used to reset protocol encoder and decoder when meet communication error

Example

match channel.invoke(&Message::new(1), Duration::from_secs(1)) {
    Ok(_) => {},
    Err(_) => { channel.reset(); }
}

pub fn read(&mut self) -> Result<Option<Message>>

Read message from channel

Example

if let Some(msg) = channel.read().unwrap() {
    println!("{:?}", msg);
}

pub fn read_until(&mut self, timeout: Duration) -> Result<Option<Message>>

Read message until timeout

Example

channel.read_until(Duration::from_secs(1));

pub fn write(&mut self, msg: &Message) -> Result<usize>

Write message to channel

Example

channel.write(&Message::new(1)).unwrap();

pub fn invoke(
    &mut self,
    request: &Message,
    timeout: Duration
) -> Result<Option<Message>>

Send a request to channel and wait for response

Example

let resp = channel.invoke(&Message::new(1), Duration::from_secs(1));

Trait Implementations

impl<P: Debug, T: Debug + ?Sized> Debug for Channel<P, T>

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

Formats the value using the given formatter.