Struct automotive::async_can::AsyncCanAdapter

pub struct AsyncCanAdapter { /* private fields */ }

Async wrapper around a CanAdapter. Starts a background thread to handle sending and receiving frames. Uses tokio channels to communicate with the background thread.

Implementations

impl AsyncCanAdapter

pub fn new<T: CanAdapter + Send + Sync + 'static>(adapter: T) -> Self

pub async fn send(&self, frame: &Frame)

Send a single frame. The Future will resolve once the frame has been put in the queue for the background thread. This does not mean the frame is sent out by the adapter.

pub fn recv(&self) -> impl Stream<Item = Frame>

Receive all frames.

Examples found in repository

examples/can_printer.rs (line 9)

async fn main() {
    tracing_subscriber::fmt::init();

    let adapter = automotive::adapter::get_adapter().unwrap();
    let mut stream = adapter.recv();

    while let Some(frame) = stream.next().await {
        let id: u32 = frame.id.into();
        println!("[{}]\t0x{:x}\t{}", frame.bus, id, hex::encode(frame.data));
    }
}

pub fn recv_filter( &self, filter: impl Fn(&Frame) -> bool ) -> impl Stream<Item = Frame>

Receive frames that match a filter. Useful in combination with stream adapters.

Trait Implementations

impl Drop for AsyncCanAdapter

fn drop(&mut self)

Executes the destructor for this type.