stcc4 0.1.0

A Rust no-std driver for the Sensirion STCC4 CO2 sensor.
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

/// Pre-computed CRC-8 lookup table for polynomial 0x31.
const CRC8_TABLE: [u8; 256] = [
    0x00, 0x31, 0x62, 0x53, 0xC4, 0xF5, 0xA6, 0x97, 0xB9, 0x88, 0xDB, 0xEA, 0x7D, 0x4C, 0x1F, 0x2E,
    0x43, 0x72, 0x21, 0x10, 0x87, 0xB6, 0xE5, 0xD4, 0xFA, 0xCB, 0x98, 0xA9, 0x3E, 0x0F, 0x5C, 0x6D,
    0x86, 0xB7, 0xE4, 0xD5, 0x42, 0x73, 0x20, 0x11, 0x3F, 0x0E, 0x5D, 0x6C, 0xFB, 0xCA, 0x99, 0xA8,
    0xC5, 0xF4, 0xA7, 0x96, 0x01, 0x30, 0x63, 0x52, 0x7C, 0x4D, 0x1E, 0x2F, 0xB8, 0x89, 0xDA, 0xEB,
    0x3D, 0x0C, 0x5F, 0x6E, 0xF9, 0xC8, 0x9B, 0xAA, 0x84, 0xB5, 0xE6, 0xD7, 0x40, 0x71, 0x22, 0x13,
    0x7E, 0x4F, 0x1C, 0x2D, 0xBA, 0x8B, 0xD8, 0xE9, 0xC7, 0xF6, 0xA5, 0x94, 0x03, 0x32, 0x61, 0x50,
    0xBB, 0x8A, 0xD9, 0xE8, 0x7F, 0x4E, 0x1D, 0x2C, 0x02, 0x33, 0x60, 0x51, 0xC6, 0xF7, 0xA4, 0x95,
    0xF8, 0xC9, 0x9A, 0xAB, 0x3C, 0x0D, 0x5E, 0x6F, 0x41, 0x70, 0x23, 0x12, 0x85, 0xB4, 0xE7, 0xD6,
    0x7A, 0x4B, 0x18, 0x29, 0xBE, 0x8F, 0xDC, 0xED, 0xC3, 0xF2, 0xA1, 0x90, 0x07, 0x36, 0x65, 0x54,
    0x39, 0x08, 0x5B, 0x6A, 0xFD, 0xCC, 0x9F, 0xAE, 0x80, 0xB1, 0xE2, 0xD3, 0x44, 0x75, 0x26, 0x17,
    0xFC, 0xCD, 0x9E, 0xAF, 0x38, 0x09, 0x5A, 0x6B, 0x45, 0x74, 0x27, 0x16, 0x81, 0xB0, 0xE3, 0xD2,
    0xBF, 0x8E, 0xDD, 0xEC, 0x7B, 0x4A, 0x19, 0x28, 0x06, 0x37, 0x64, 0x55, 0xC2, 0xF3, 0xA0, 0x91,
    0x47, 0x76, 0x25, 0x14, 0x83, 0xB2, 0xE1, 0xD0, 0xFE, 0xCF, 0x9C, 0xAD, 0x3A, 0x0B, 0x58, 0x69,
    0x04, 0x35, 0x66, 0x57, 0xC0, 0xF1, 0xA2, 0x93, 0xBD, 0x8C, 0xDF, 0xEE, 0x79, 0x48, 0x1B, 0x2A,
    0xC1, 0xF0, 0xA3, 0x92, 0x05, 0x34, 0x67, 0x56, 0x78, 0x49, 0x1A, 0x2B, 0xBC, 0x8D, 0xDE, 0xEF,
    0x82, 0xB3, 0xE0, 0xD1, 0x46, 0x77, 0x24, 0x15, 0x3B, 0x0A, 0x59, 0x68, 0xFF, 0xCE, 0x9D, 0xAC,
];

const CRC8_INIT: u8 = 0xFF;

/// Error type for CRC validation.
#[derive(Debug, Eq, PartialEq, Copy, Clone, PartialOrd, Ord)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum CrcError {
    /// CRC validation failed.
    InvalidCrc,
    /// Output buffer is too small for the data.
    BufferTooSmall,
    /// Input data length is not a multiple of 3 (data1, data2, CRC).
    InvalidInputLength,
}

/// Generate a CRC-8 checksum for the given data using polynomial 0x31 using table lookup.
#[inline]
pub fn generate_crc(data: &[u8]) -> u8 {
    let mut crc = CRC8_INIT;

    for &byte in data {
        crc = CRC8_TABLE[(crc ^ byte) as usize];
    }

    crc
}

/// Validate the CRC of an input slice (units of 2 data bytes, 1 crc byte).
#[inline]
pub fn validate_and_extract_data(raw_bytes: &[u8], data: &mut [u16]) -> Result<usize, CrcError> {
    const GROUP_SIZE: usize = 3;
    const DATA_PER_GROUP: usize = 2;

    if raw_bytes.len() % GROUP_SIZE != 0 {
        return Err(CrcError::InvalidInputLength);
    }

    let num_groups = raw_bytes.len() / GROUP_SIZE;
    let required_output_size = num_groups * DATA_PER_GROUP;

    if data.len() * 2 < required_output_size {
        return Err(CrcError::BufferTooSmall);
    }

    let mut output_idx = 0;

    for chunk in raw_bytes.chunks_exact(GROUP_SIZE) {
        let data_slice = &chunk[..2];
        let expected_crc = chunk[2];

        if generate_crc(data_slice) != expected_crc {
            return Err(CrcError::InvalidCrc);
        }

        data[output_idx] = ((data_slice[0] as u16) << 8) | (data_slice[1] as u16);
        output_idx += 1;
    }

    Ok(output_idx)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    /// Verifies CRC validation and extraction succeeds on valid data.
    fn test_validate_and_extract_ok() {
        let data = [0x12_u8, 0x34_u8];
        let crc = generate_crc(&data);
        let input = [data[0], data[1], crc];

        let mut output = [0u16; 1];
        let len = validate_and_extract_data(&input, &mut output).unwrap();

        assert_eq!(len, 1);
        assert_eq!(output[0], 0x1234);
    }

    #[test]
    /// Verifies CRC validation fails on invalid CRC.
    fn test_invalid_crc() {
        let input = [0x12_u8, 0x34_u8, 0x00_u8];
        let mut output = [0u16; 1];

        let err = validate_and_extract_data(&input, &mut output).unwrap_err();
        assert_eq!(err, CrcError::InvalidCrc);
    }

    #[test]
    /// Verifies CRC validation fails on invalid input length.
    fn test_invalid_input_length() {
        let input = [0x12_u8, 0x34_u8];
        let mut output = [0u16; 1];

        let err = validate_and_extract_data(&input, &mut output).unwrap_err();
        assert_eq!(err, CrcError::InvalidInputLength);
    }

    #[test]
    /// Verifies CRC validation fails when output buffer is too small.
    fn test_buffer_too_small() {
        let data = [0x12_u8, 0x34_u8];
        let crc = generate_crc(&data);
        let input = [data[0], data[1], crc, 0x56_u8, 0x78_u8, crc];
        let mut output = [0u16; 1];

        let err = validate_and_extract_data(&input, &mut output).unwrap_err();
        assert_eq!(err, CrcError::BufferTooSmall);
    }
}