cc_talk_core 0.0.4

A no-std implementation of the CCtalk 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
124
125
126
127
128
129
130
131
132
133
134

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub struct DataStorage {
    pub memory_type: MemoryType,
    pub read_blocks: u16,
    pub read_bytes_per_block: u8,
    pub write_blocks: u16,
    pub write_bytes_per_block: u8,
}

impl DataStorage {
    #[must_use]
    pub const fn new(
        memory_type: MemoryType,
        read_blocks: u16,
        read_bytes_per_block: u8,
        write_blocks: u16,
        write_bytes_per_block: u8,
    ) -> Self {
        Self {
            memory_type,
            read_blocks,
            read_bytes_per_block,
            write_blocks,
            write_bytes_per_block,
        }
    }

    #[must_use]
    #[allow(clippy::cast_possible_truncation)]
    pub const fn as_bytes(&self) -> [u8; 5] {
        [
            self.memory_type as u8,
            self.read_blocks as u8,
            self.read_bytes_per_block,
            self.write_blocks as u8,
            self.write_bytes_per_block,
        ]
    }

    #[must_use]
    pub const fn read_blocks(&self) -> u16 {
        if self.read_blocks == 0 {
            256
        } else {
            self.read_blocks
        }
    }

    #[must_use]
    pub const fn write_blocks(&self) -> u16 {
        if self.write_blocks == 0 {
            256
        } else {
            self.write_blocks
        }
    }

    #[must_use]
    pub const fn is_read_available(&self) -> bool {
        self.read_bytes_per_block > 0
    }

    #[must_use]
    pub const fn is_write_available(&self) -> bool {
        self.write_bytes_per_block > 0
    }
}

impl From<DataStorage> for [u8; 5] {
    fn from(value: DataStorage) -> Self {
        value.as_bytes()
    }
}

impl From<[u8; 5]> for DataStorage {
    fn from(bytes: [u8; 5]) -> Self {
        Self {
            memory_type: MemoryType::try_from(bytes[0]).expect("Invalid memory type"),
            read_blocks: u16::from(bytes[1]),
            read_bytes_per_block: bytes[2],
            write_blocks: u16::from(bytes[3]),
            write_bytes_per_block: bytes[4],
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum MemoryType {
    VolatileOnReset = 0,
    VolatileOnPowerDown = 1,
    PermanentLimitedUse = 2,
    PermanentUnlimitedUse = 3,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, thiserror::Error)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum MemoryTypeError {
    #[error("Invalid memory type")]
    InvalidMemoryType,
}
impl TryFrom<u8> for MemoryType {
    type Error = MemoryTypeError;

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(Self::VolatileOnReset),
            1 => Ok(Self::VolatileOnPowerDown),
            2 => Ok(Self::PermanentLimitedUse),
            3 => Ok(Self::PermanentUnlimitedUse),
            _ => Err(MemoryTypeError::InvalidMemoryType),
        }
    }
}

#[repr(u8)]
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum FirmwareStorageType {
    RomOrEprom = 0,
    FlashOrEeprom = 1,
}

impl TryFrom<u8> for FirmwareStorageType {
    type Error = ();

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(Self::RomOrEprom),
            1 => Ok(Self::FlashOrEeprom),
            _ => Err(()),
        }
    }
}