Struct tokio_socketcan_bcm::BCMSocket

pub struct BCMSocket {
    pub fd: c_int,
}

A socket for a CAN device, specifically for broadcast manager operations.

Fields

fd: c_int

Implementations

impl BCMSocket

pub fn open_nb(ifname: &str) -> Result<BCMSocket>

Open a named CAN device non blocking.

Usually the more common case, opens a socket can device by name, such as "vcan0" or "socan0".

pub fn open_if_nb(if_index: c_uint) -> Result<BCMSocket>

Open CAN device by interface number non blocking.

Opens a CAN device by kernel interface number.

pub fn filter_id(
    &self,
    can_id: CANMessageId,
    ival1: Duration,
    ival2: Duration
) -> Result<()>

Create a content filter subscription, filtering can frames by can_id.

pub fn filter_id_incoming_frames(
    self,
    can_id: CANMessageId,
    ival1: Duration,
    ival2: Duration
) -> Result<BcmFrameStream>

Combination of BCMSocket::filter_id and BCMSocket::incoming_frames.

use std::time;
use tokio_socketcan_bcm::*;
use futures_util::stream::StreamExt;

#[tokio::main]
async fn main() {
    let socket = BCMSocket::open_nb("vcan0").unwrap();
    let ival = time::Duration::from_millis(0);

    // create a stream of messages that filters by the can frame id 0x123
    let mut can_frame_stream = socket
        .filter_id_incoming_frames(0x123.into(), ival, ival)
        .unwrap();

    while let Some(frame) = can_frame_stream.next().await {
        println!("Frame {:?}", frame);
        ()
    }
}

pub fn incoming_msg(self) -> Result<BcmStream>

Stream of incoming BcmMsgHeads that apply to the filter criteria.

use std::time;
use tokio_socketcan_bcm::*;
use futures_util::stream::StreamExt;

#[tokio::main]
async fn main() {
    let socket = BCMSocket::open_nb("vcan0").unwrap();
    let ival = time::Duration::from_millis(0);

    // create a stream of messages that filters by the can frame id 0x123
    let mut can_frame_stream = socket
        .incoming_msg()
        .unwrap();

    while let Some(frame) = can_frame_stream.next().await {
        println!("Frame {:?}", frame);
        ()
    }
}

pub fn incoming_frames(self) -> Result<BcmFrameStream>

Stream of incoming frames that apply to the filter criteria.

use std::time;
use tokio_socketcan_bcm::*;
use futures_util::stream::StreamExt;

#[tokio::main]
async fn main() {
    let socket = BCMSocket::open_nb("vcan0").unwrap();
    let ival = time::Duration::from_millis(0);

    // create a stream of messages that filters by the can frame id 0x123
    let mut can_frame_stream = socket
        .incoming_frames()
        .unwrap();

    while let Some(frame) = can_frame_stream.next().await {
        println!("Frame {:?}", frame);
        ()
    }
}

pub fn filter_delete(&self, can_id: CANMessageId) -> Result<()>

Remove a content filter subscription.

pub fn read_msg(&self) -> Result<BcmMsgHead>

Read a single bcm message.

Trait Implementations

impl Debug for BCMSocket

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

Formats the value using the given formatter.

impl Drop for BCMSocket

fn drop(&mut self)

Executes the destructor for this type.

impl Evented for BCMSocket

fn register(
    &self,
    poll: &Poll,
    token: Token,
    interest: Ready,
    opts: PollOpt
) -> Result<()>

Register self with the given Poll instance.

fn reregister(
    &self,
    poll: &Poll,
    token: Token,
    interest: Ready,
    opts: PollOpt
) -> Result<()>

Re-register self with the given Poll instance.

fn deregister(&self, poll: &Poll) -> Result<()>

Deregister self from the given Poll instance