mdf4-rs 0.6.0

mdf4-rs is a Rust library for working with Measurement Data Format (ASAM MDF4) files.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

//! [`LinFlags`].

#[allow(unused_imports)]
use super::*;

/// LIN frame flags for ASAM MDF4 Bus Logging.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct LinFlags(u8);
impl LinFlags {
    /// Bit 0: Frame direction (0 = Rx, 1 = Tx).
    pub const TX: u8 = 0x01;
    /// Bit 1: Wake-up signal.
    pub const WAKEUP: u8 = 0x02;
    /// Bit 2: Checksum error.
    pub const CHECKSUM_ERROR: u8 = 0x04;
    /// Bit 3: No response (slave didn't respond).
    pub const NO_RESPONSE: u8 = 0x08;
    /// Bit 4: Sync error.
    pub const SYNC_ERROR: u8 = 0x10;
    /// Bit 5: Framing error.
    pub const FRAMING_ERROR: u8 = 0x20;
    /// Bit 6: Short response (incomplete data).
    pub const SHORT_RESPONSE: u8 = 0x40;
    /// Bit 7: Enhanced checksum used (LIN 2.x).
    pub const ENHANCED_CHECKSUM: u8 = 0x80;

    /// Create flags from raw byte.
    pub fn from_byte(value: u8) -> Self {
        Self(value)
    }

    /// Get raw byte value.
    pub fn to_byte(self) -> u8 {
        self.0
    }

    /// Create flags for received frame.
    pub fn rx() -> Self {
        Self(0)
    }

    /// Create flags for transmitted frame.
    pub fn tx() -> Self {
        Self(Self::TX)
    }

    /// Check if this is a transmitted frame.
    pub fn is_tx(self) -> bool {
        self.0 & Self::TX != 0
    }

    /// Check if this is a received frame.
    pub fn is_rx(self) -> bool {
        !self.is_tx()
    }

    /// Check if this is a wake-up frame.
    pub fn is_wakeup(self) -> bool {
        self.0 & Self::WAKEUP != 0
    }

    /// Check if checksum error occurred.
    pub fn has_checksum_error(self) -> bool {
        self.0 & Self::CHECKSUM_ERROR != 0
    }

    /// Check if slave didn't respond.
    pub fn has_no_response(self) -> bool {
        self.0 & Self::NO_RESPONSE != 0
    }

    /// Check if sync error occurred.
    pub fn has_sync_error(self) -> bool {
        self.0 & Self::SYNC_ERROR != 0
    }

    /// Check if framing error occurred.
    pub fn has_framing_error(self) -> bool {
        self.0 & Self::FRAMING_ERROR != 0
    }

    /// Check if response was incomplete.
    pub fn has_short_response(self) -> bool {
        self.0 & Self::SHORT_RESPONSE != 0
    }

    /// Check if enhanced (LIN 2.x) checksum is used.
    pub fn uses_enhanced_checksum(self) -> bool {
        self.0 & Self::ENHANCED_CHECKSUM != 0
    }

    /// Check if any error occurred.
    pub fn has_error(self) -> bool {
        self.0
            & (Self::CHECKSUM_ERROR
                | Self::NO_RESPONSE
                | Self::SYNC_ERROR
                | Self::FRAMING_ERROR
                | Self::SHORT_RESPONSE)
            != 0
    }

    /// Set the transmit flag.
    pub fn with_tx(self, tx: bool) -> Self {
        if tx {
            Self(self.0 | Self::TX)
        } else {
            Self(self.0 & !Self::TX)
        }
    }

    /// Set the enhanced checksum flag.
    pub fn with_enhanced_checksum(self, enhanced: bool) -> Self {
        if enhanced {
            Self(self.0 | Self::ENHANCED_CHECKSUM)
        } else {
            Self(self.0 & !Self::ENHANCED_CHECKSUM)
        }
    }
}