Struct DecodedSignal 

pub struct DecodedSignal<'a> {
    pub name: &'a str,
    pub value: f64,
    pub raw_value: i64,
    pub min: f64,
    pub max: f64,
    pub unit: Option<&'a str>,
    pub description: Option<&'a str>,
}

A decoded signal from a CAN message.

Contains the signal name, its decoded physical value, unit, and optional value description.

Fields

name: &'a str

The name of the signal as defined in the DBC file.

value: f64

The decoded physical value after applying factor and offset.

raw_value: i64

The raw integer value before applying factor and offset. Useful for debugging, re-encoding, or storing raw CAN data.

min: f64

The minimum valid physical value as defined in the DBC file.

max: f64

The maximum valid physical value as defined in the DBC file.

unit: Option<&'a str>

The unit of the signal (e.g., “rpm”, “°C”), if defined.

description: Option<&'a str>

The value description text if defined in the DBC file (e.g., “Park”, “Drive”). This maps the raw signal value to a human-readable description.

Implementations

impl<'a> DecodedSignal<'a>

pub fn new( name: &'a str, value: f64, raw_value: i64, min: f64, max: f64, unit: Option<&'a str>, description: Option<&'a str>, ) -> Self

Creates a new DecodedSignal with the given parameters.

Arguments

• name - The signal name
• value - The decoded physical value (after applying factor and offset)
• raw_value - The raw integer value before scaling
• min - The minimum valid physical value
• max - The maximum valid physical value
• unit - The optional unit of measurement (e.g., “rpm”, “km/h”)
• description - The optional value description text (e.g., “Park”, “Drive”)

Examples

use dbc_rs::DecodedSignal;

let signal = DecodedSignal::new("Gear", 3.0, 3, 0.0, 5.0, Some(""), Some("Drive"));
assert_eq!(signal.name, "Gear");
assert_eq!(signal.value, 3.0);
assert_eq!(signal.raw_value, 3);
assert!(signal.is_in_range());
assert_eq!(signal.description, Some("Drive"));

pub fn is_in_range(&self) -> bool

Returns true if the decoded value is within the valid range [min, max].

Examples

use dbc_rs::DecodedSignal;

let signal = DecodedSignal::new("RPM", 2000.0, 8000, 0.0, 8000.0, Some("rpm"), None);
assert!(signal.is_in_range());

let out_of_range = DecodedSignal::new("RPM", 9000.0, 36000, 0.0, 8000.0, Some("rpm"), None);
assert!(!out_of_range.is_in_range());

Trait Implementations

impl<'a> Clone for DecodedSignal<'a>

fn clone(&self) -> DecodedSignal<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for DecodedSignal<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for DecodedSignal<'a>

fn eq(&self, other: &DecodedSignal<'a>) -> 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<'a> StructuralPartialEq for DecodedSignal<'a>