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

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

use micropelt_derive::PartialClose;

use crate::utils::{
    bin_to_float_point_five, bin_to_float_point_two_five, float_point_five_to_bin, percent_to_bin,
};

pub const DEFAULT_AMBIENT_TEMPERATURE: f32 = 19.0;
pub const DEFAULT_FLOW_TEMPERATURE: f32 = 55.0;

#[derive(Clone, Debug, PartialClose)]
pub enum DeviceValue {
    User(SetValue),
    FreezeProtect(u8),
    ForcedHeating(u8),
    #[partial_close(resolution = 0.25)]
    DetectingOpeningPoint(f32),
    #[partial_close(resolution = 0.25)]
    SlowHarvesting(f32),
    TemperatureDropDetected,
    ValvePositionInverse(u8),
}

#[derive(Clone, Debug, PartialClose)]
pub enum SetValue {
    ValvePosition(u8),
    #[partial_close(resolution = 0.5)]
    FlowTemperature(f32),
    #[partial_close(resolution = 0.5)]
    AmbientTemperature(f32),
    InverseValvePositionMode(u8),
}

impl fmt::Display for DeviceValue {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::User(x) => x.fmt(f),
            Self::FreezeProtect(value) => {
                write!(f, "Freeze Protecting (Device opened to {value}%)")
            }
            Self::ForcedHeating(value) => write!(f, "Forced Heating (Device opened to {value}%)"),
            Self::DetectingOpeningPoint(value) => write!(
                f,
                "Detecting Opening Point (maximum flow temperature {value}°C)",
            ),
            Self::SlowHarvesting(value) => {
                write!(f, "Slow Harvesting (maximum flow temperature {value}°C)")
            }
            Self::TemperatureDropDetected => write!(f, "Temperature Drop Detected"),
            Self::ValvePositionInverse(value) => write!(f, "Inverse Valve Position {value}%")
        }
    }
}

impl fmt::Display for SetValue {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::ValvePosition(value) => write!(f, "Valve Position {value}%"),
            Self::InverseValvePositionMode(value) => write!(f, "Inverse Valve Position {value}%"),
            Self::FlowTemperature(value) => {
                write!(f, "Flow Temperature {value}°C")
            }
            Self::AmbientTemperature(value) => {
                write!(f, "Ambient Temperature {value}°C")
            }
        }
    }
}

impl PartialEq for DeviceValue {
    fn eq(&self, other: &Self) -> bool {
        self.partial_close(other)
    }
}

impl PartialEq for SetValue {
    fn eq(&self, other: &Self) -> bool {
        self.partial_close(other)
    }
}

impl DeviceValue {
    pub(super) fn from_bin(mode: u8, value: u8) -> Result<Self> {
        match mode {
            0 => Ok(Self::User(SetValue::ValvePosition(value))),
            1 => Ok(Self::User(SetValue::FlowTemperature(
                bin_to_float_point_five(value),
            ))),
            2 => Ok(Self::User(SetValue::AmbientTemperature(
                bin_to_float_point_five(value),
            ))),
            3 => Ok(Self::DetectingOpeningPoint(bin_to_float_point_two_five(
                value,
            ))),
            4 => Ok(Self::SlowHarvesting(bin_to_float_point_two_five(value))),
            5 => Ok(Self::TemperatureDropDetected),
            6 => Ok(Self::FreezeProtect(value)),
            7 => Ok(Self::ForcedHeating(value)),
            8 => Ok(Self::ValvePositionInverse(value)),
            _ => Err(Error::new(
                ErrorKind::InvalidInput,
                format!("Unexpected set mode: {mode} (set value {value})"),
            )),
        }
    }
}

impl SetValue {
    pub fn default_radiator() -> Self {
        Self::AmbientTemperature(DEFAULT_AMBIENT_TEMPERATURE)
    }

    pub fn default_domestic_hot_water() -> Self {
        Self::FlowTemperature(DEFAULT_FLOW_TEMPERATURE)
    }

    pub(super) fn value_to_bin(&self) -> Result<u8> {
        match self {
            SetValue::ValvePosition(value) => Ok(percent_to_bin(*value)?),
            SetValue::InverseValvePositionMode(value) => Ok(percent_to_bin(*value)?),
            SetValue::FlowTemperature(value) => Ok(float_point_five_to_bin(*value, 80.0)?),
            SetValue::AmbientTemperature(value) => Ok(float_point_five_to_bin(*value, 40.0)?),
        }
    }

    pub(super) fn user_mode_to_bin(&self) -> u8 {
        match self {
            SetValue::ValvePosition(_) => 0,
            SetValue::FlowTemperature(_) => 1,
            SetValue::AmbientTemperature(_) => 2,
            SetValue::InverseValvePositionMode(_) => 3,
        }
    }

    pub(super) fn safety_mode_to_bin(&self) -> u8 {
        match self {
            SetValue::AmbientTemperature(_) => 0,
            SetValue::FlowTemperature(_) => 1,
            SetValue::ValvePosition(_) => 2,
            SetValue::InverseValvePositionMode(_) => 3,
        }
    }
}

#[cfg(test)]
#[path = "./test_device_value.rs"]
mod test_device_value;