Struct HardwareCapability 

pub struct HardwareCapability {
    pub channel_count: u8,
    pub supports_canfd: bool,
    pub max_bitrate: u32,
    pub supported_bitrates: Vec<u32>,
    pub filter_count: u8,
    pub timestamp_precision: TimestampPrecision,
}

Hardware capability description.

Describes the capabilities and limitations of a CAN hardware backend. Applications can query these capabilities at runtime to adapt their behavior.

Examples

use canlink_hal::{HardwareCapability, TimestampPrecision};

let capability = HardwareCapability {
    channel_count: 2,
    supports_canfd: true,
    max_bitrate: 8_000_000,
    supported_bitrates: vec![125_000, 250_000, 500_000, 1_000_000],
    filter_count: 16,
    timestamp_precision: TimestampPrecision::Microsecond,
};

assert_eq!(capability.channel_count, 2);
assert!(capability.supports_canfd);

Fields

channel_count: u8

Number of supported channels

supports_canfd: bool

Whether CAN-FD is supported

max_bitrate: u32

Maximum bitrate in bits per second

supported_bitrates: Vec<u32>

List of supported bitrates (bps)

filter_count: u8

Number of hardware filters supported

timestamp_precision: TimestampPrecision

Timestamp precision

Implementations

impl HardwareCapability

pub fn new( channel_count: u8, supports_canfd: bool, max_bitrate: u32, supported_bitrates: Vec<u32>, filter_count: u8, timestamp_precision: TimestampPrecision, ) -> Self

Create a new hardware capability description.

Examples

use canlink_hal::{HardwareCapability, TimestampPrecision};

let capability = HardwareCapability::new(
    2,
    true,
    8_000_000,
    vec![125_000, 250_000, 500_000, 1_000_000],
    16,
    TimestampPrecision::Microsecond,
);

pub fn supports_bitrate(&self, bitrate: u32) -> bool

Check if a specific bitrate is supported.

Examples

use canlink_hal::{HardwareCapability, TimestampPrecision};

let capability = HardwareCapability::new(
    2,
    true,
    8_000_000,
    vec![125_000, 250_000, 500_000, 1_000_000],
    16,
    TimestampPrecision::Microsecond,
);

assert!(capability.supports_bitrate(500_000));
assert!(!capability.supports_bitrate(2_000_000));

pub fn has_channel(&self, channel: u8) -> bool

Check if a specific channel exists.

Examples

use canlink_hal::{HardwareCapability, TimestampPrecision};

let capability = HardwareCapability::new(
    2,
    true,
    8_000_000,
    vec![125_000, 250_000, 500_000, 1_000_000],
    16,
    TimestampPrecision::Microsecond,
);

assert!(capability.has_channel(0));
assert!(capability.has_channel(1));
assert!(!capability.has_channel(2));

Trait Implementations

impl Clone for HardwareCapability

fn clone(&self) -> HardwareCapability

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for HardwareCapability

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

Formats the value using the given formatter.

impl Eq for HardwareCapability

impl PartialEq for HardwareCapability

fn eq(&self, other: &HardwareCapability) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for HardwareCapability