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

use super::*;

use base64::Engine as _;

use crate::lorawan::Downlink as _;

#[test]
fn serialise_r_zero() {
    let downlink = DownlinkR {
        user_value: SetValue::ValvePosition(0),
        safety_value: SetValue::AmbientTemperature(0.0),
        ..super::DownlinkR::default()
    };

    let bytes = downlink.serialise().unwrap().payload;

    assert_eq!(vec![0; 6], bytes);
}

#[test]
fn serialise_r_01() {
    let downlink = DownlinkR {
        user_value: SetValue::AmbientTemperature(18.5),
        room_temperature: 17.0,
        safety_value: SetValue::ValvePosition(65),
        radio_communication_interval: RadioCommunicationIntervalR::Minutes120,
        reference_run: false,
    };

    let expected_output = vec![37, 68, 65, 58, 0, 0];

    assert_eq!(expected_output, downlink.serialise().unwrap().payload);
}

#[test]
fn serialise_r_02() {
    let downlink = DownlinkR {
        user_value: SetValue::FlowTemperature(57.5),
        room_temperature: 0.0,
        safety_value: SetValue::FlowTemperature(58.0),
        radio_communication_interval: RadioCommunicationIntervalR::Minutes480,
        reference_run: false,
    };

    let bytes = downlink.serialise().unwrap().payload;

    let b64 = base64::engine::general_purpose::STANDARD.encode(bytes);

    assert_eq!("cwB0RQAA", b64);
}

#[test]
fn serialise_f_zero() {
    let downlink = DownlinkF {
        user_value: SetValue::ValvePosition(0),
        safety_value: SetValue::AmbientTemperature(0.0),
        radio_communication_interval: RadioCommunicationIntervalF::Minutes15,
        k_p: Kp::Kp12,
        reference_run: false,
    };

    let bytes = downlink.serialise().unwrap().payload;

    assert_eq!(vec![0; 6], bytes);
}

#[test]
fn serialise_f_01() {
    let downlink = DownlinkF {
        user_value: SetValue::FlowTemperature(57.5),
        safety_value: SetValue::FlowTemperature(58.0),
        radio_communication_interval: RadioCommunicationIntervalF::Minutes120,
        k_p: Kp::Kp4,
        reference_run: false,
    };

    let bytes = downlink.serialise().unwrap().payload;

    assert_eq!(vec![115, 0, 116, 0b00110101, 0, 0b01000000], bytes);
}

#[test]
fn serialise_4_zero() {
    let downlink = Downlink4 {
        user_value: SetValue::ValvePosition(0),
        room_temperature: 0.0,
        safety_value: SetValue::AmbientTemperature(0.0),
        radio_communication_interval: RadioCommunicationIntervalR::Minutes10,
    };

    let bytes = downlink.serialise().unwrap().payload;

    assert_eq!(vec![0; 4], bytes);
}

#[test]
fn serialise_4_01() {
    let downlink = Downlink4 {
        user_value: SetValue::AmbientTemperature(2.5),
        room_temperature: 16.75,
        safety_value: SetValue::FlowTemperature(76.5),
        radio_communication_interval: RadioCommunicationIntervalR::Minutes120,
    };

    let bytes = downlink.serialise().unwrap().payload;

    assert_eq!(vec![5, 67, 153, 0b00111001], bytes);
}

#[test]
fn test_float_point_two_five_to_bin() {
    assert_eq!(17, float_point_two_five_to_bin(4.25));
}