iso14229-1 0.1.0

A ISO 14229-1 protocol.
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
121
122
123

//! Commons of Service 34|35

use crate::error::Error;

/// This parameter is a one-byte value with each nibble encoded separately:
/// ⎯ bit 7 - 4: length (number of bytes) of the maxNumberOfBlockLength parameter;
/// ⎯ bit 3 - 0: reserved by document, to be set to 0 hex.
/// The format of this parameter is compatible to the format of the addressAndLengthFormatIdentifier parameter contained
/// in the request message, except that the lower nibble has to be set to 0 hex.
#[derive(Debug, Copy, Clone, Default, Eq, PartialEq)]
pub struct LengthFormatIdentifier(pub(crate) u8);

impl LengthFormatIdentifier {
    #[inline]
    pub fn new(value: u8) -> Result<Self, Error> {
        if value > 0x0F {
            return Err(Error::InvalidParam(
                "`LengthFormatIdentifier` must be between 0x00 and 0xF0".to_string(),
            ));
        }

        Ok(Self(value << 4))
    }

    #[inline]
    pub const fn max_number_of_block_length(&self) -> usize {
        (self.0 >> 4) as usize
    }
}

impl From<LengthFormatIdentifier> for u8 {
    fn from(val: LengthFormatIdentifier) -> Self {
        val.0
    }
}

impl TryFrom<u8> for LengthFormatIdentifier {
    type Error = Error;
    fn try_from(value: u8) -> Result<Self, Self::Error> {
        if value > 0xF0 {
            return Err(Error::InvalidParam(
                "`LengthFormatIdentifier` must be between 0x00 and 0xF0".to_string(),
            ));
        }

        Ok(Self(value))
    }
}

/// Defined by the vehicle manufacturer
#[derive(Debug, Copy, Clone, Default, Eq, PartialEq)]
pub struct DataFormatIdentifier(pub(crate) u8);

impl DataFormatIdentifier {
    #[inline]
    pub fn new(compression: u8, encryption: u8) -> Self {
        Self((compression << 4) | encryption)
    }
    #[inline]
    pub fn compression(&self) -> u8 {
        self.0 >> 4
    }
    #[inline]
    pub fn encryption(&self) -> u8 {
        self.0 & 0x0F
    }
}

impl From<u8> for DataFormatIdentifier {
    #[inline]
    fn from(v: u8) -> Self {
        Self(v)
    }
}

impl From<DataFormatIdentifier> for u8 {
    #[inline]
    fn from(val: DataFormatIdentifier) -> Self {
        val.0
    }
}

/// This parameter is a one Byte value with each nibble encoded separately (see Table H.1 for example values):
/// — bit 7 - 4: Length (number of bytes) of the memorySize parameter
/// — bit 3 - 0: Length (number of bytes) of the memoryAddress parameter
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub struct AddressAndLengthFormatIdentifier(u8);

impl AddressAndLengthFormatIdentifier {
    pub fn new(addr_len: u8, size_len: u8) -> Result<Self, Error> {
        let value = (size_len << 4) | addr_len;
        Self::try_from(value)
    }

    #[inline]
    pub const fn length_of_memory_address(&self) -> usize {
        (self.0 & 0x0F) as usize
    }

    #[inline]
    pub const fn length_of_memory_size(&self) -> usize {
        ((self.0 & 0xF0) >> 4) as usize
    }
}

impl From<AddressAndLengthFormatIdentifier> for u8 {
    fn from(val: AddressAndLengthFormatIdentifier) -> Self {
        val.0
    }
}

impl TryFrom<u8> for AddressAndLengthFormatIdentifier {
    type Error = Error;
    fn try_from(value: u8) -> Result<Self, Self::Error> {
        if value & 0x0F == 0 || value & 0xF0 == 0 {
            return Err(Error::InvalidParam(
                "all field of `AddressAndLengthFormatIdentifier` must be rather than 0".into(),
            ));
        }

        Ok(Self(value))
    }
}