micropelt 1.1.8

Micropelt device communication definitions
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use std::io::{Error, ErrorKind, Result};

pub fn check_payload_length(payload: &[u8], expected_length: usize) -> Result<()> {
    if payload.len() == expected_length {
        Ok(())
    } else {
        Err(Error::new(
            ErrorKind::InvalidData,
            format!(
                "Payload length should be {expected_length}, got {payload:?} which is of length {}",
                payload.len()
            ),
        ))
    }
}

pub fn check_range(lower: f32, input: f32, upper: f32, resolution: f32) -> Result<()> {
    if input < lower - 0.5 * resolution {
        return Err(Error::new(
            ErrorKind::InvalidInput,
            format!("Lower limit is {lower}, received {input}"),
        ));
    }
    if input > upper + 0.5 * resolution {
        return Err(Error::new(
            ErrorKind::InvalidInput,
            format!("Upper limit is {upper}, received {input}"),
        ));
    }

    Ok(())
}

pub fn bin_to_fifty(input: u8) -> u16 {
    input as u16 * 50
}

pub fn bin_to_ten(input: u8) -> u16 {
    input as u16 * 10
}

pub fn bin_to_float_point_five(input: u8) -> f32 {
    input as f32 * 0.5
}

pub fn bin_to_float_point_two_five(input: u8) -> f32 {
    input as f32 * 0.25
}

pub fn bin_to_float_point_two(input: u8) -> f32 {
    input as f32 * 0.2
}

pub fn _bin_to_float_point_one(input: u8) -> f32 {
    input as f32 * 0.1
}

pub fn bin_to_float_point_zero(input: u8) -> f32 {
    input as f32
}

pub fn bin_to_float_point_zero_two(input: u8) -> f32 {
    input as f32 * 0.02
}

pub fn bin_to_float_point_zero_one(input: u8) -> f32 {
    input as f32 * 0.01
}

pub fn bin_to_bool(input: u8) -> Result<bool> {
    match input {
        0 => Ok(false),
        1 => Ok(true),
        _ => Err(Error::new(
            ErrorKind::InvalidData,
            format!("A bit should only be 0 or 1, got {input}"),
        )),
    }
}

pub fn bool_to_bin(input: bool) -> u8 {
    match input {
        true => 1,
        false => 0,
    }
}

pub fn bin_to_percent(input: u8) -> Result<u8> {
    check_range(0.0, input as f32, 100.0, 1.0)?;

    Ok(input)
}

pub fn percent_to_bin(input: u8) -> Result<u8> {
    check_range(0.0, input as f32, 100.0, 1.0)?;

    Ok(input)
}

pub fn float_point_five_to_bin(input: f32, upper: f32) -> Result<u8> {
    check_range(0.0, input, upper, 0.5)?;

    Ok((input * 2.0) as u8)
}

pub fn float_point_two_five_to_bin(input: f32) -> u8 {
    (input * 4.0) as u8
}

pub fn float_point_two_to_bin(input: f32) -> Result<u8> {
    check_range(0.0, input, 51.0, 0.2)?;

    Ok((input * 5.0) as u8)
}

pub fn _float_point_one_to_bin(input: f32) -> Result<u8> {
    check_range(0.0, input, 25.5, 0.1)?;

    Ok((input * 10.0) as u8)
}

pub fn p_max_to_bin(input: u8) -> Result<u8> {
    check_range(0.0, input as f32, 255.0, 1.0)?;

    Ok(input)
}

pub fn float_point_zero_two_to_bin(input: f32) -> Result<u8> {
    check_range(0.0, input, 5.1, 0.02)?;

    Ok((input * 50.0) as u8)
}

pub fn float_point_zero_one_to_bin(input: f32) -> Result<u8> {
    check_range(0.0, input, 2.55, 0.01)?;

    Ok((input * 100.0) as u8)
}

#[cfg(test)]
mod tests {
    use super::{bin_to_float_point_zero, p_max_to_bin};

    #[test]
    fn test_f32_ser_de() {
        let number = 25;
        let ser_number = p_max_to_bin(number).unwrap();
        let de_number = bin_to_float_point_zero(ser_number);
        // we no longer care about decimals in the P value
        assert_eq!(25.0, de_number);
    }
}