rointe-core 0.1.1

Rust SDK for controlling Rointe WiFi radiators via Firebase Realtime Database
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

use std::fmt;

use serde::{Deserialize, Serialize};

/// Physical device type as reported by the API.
///
/// This enum is `#[non_exhaustive]` — Rointe may introduce new hardware
/// categories in future firmware updates.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum RointeProduct {
    /// Standard panel radiator.
    Radiator,
    /// Panel radiator (variant B).
    Radiatorb,
    /// Towel-rail radiator.
    Towel,
    /// ACS (hot-water storage / immersion) heater.
    Acs,
    /// Thermostat controller.
    Therm,
    /// Oval towel-rail radiator.
    OvalTowel,
}

/// Operating mode of the device.
///
/// - `Manual` — target temperature is set explicitly by the user.
/// - `Auto` — the device follows its programmed weekly schedule.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum DeviceMode {
    /// Temperature is controlled manually.
    Manual,
    /// Temperature follows the weekly schedule.
    Auto,
}

impl fmt::Display for DeviceMode {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            DeviceMode::Manual => write!(f, "manual"),
            DeviceMode::Auto => write!(f, "auto"),
        }
    }
}

/// Current status / active preset of the device.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum DeviceStatus {
    /// Heating to the comfort preset temperature.
    Comfort,
    /// Heating to the eco (energy-saving) preset temperature.
    Eco,
    /// Frost-protection (ice) mode active.
    Ice,
    /// Device is off.
    Off,
    /// No preset active; device is in manual temperature control.
    #[serde(rename = "none")]
    NoStatus,
}

impl fmt::Display for DeviceStatus {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            DeviceStatus::Comfort => write!(f, "comfort"),
            DeviceStatus::Eco => write!(f, "eco"),
            DeviceStatus::Ice => write!(f, "ice"),
            DeviceStatus::Off => write!(f, "off"),
            DeviceStatus::NoStatus => write!(f, "none"),
        }
    }
}

/// High-level HVAC command used with [`crate::RointeClient::set_mode`].
#[derive(Debug, Clone, PartialEq)]
pub enum HvacMode {
    /// Turn the device off (two-step sequence).
    Off,
    /// Turn on and heat to the comfort temperature (two-step sequence).
    Heat,
    /// Follow the programmed weekly schedule (two-step sequence).
    Auto,
}

impl fmt::Display for HvacMode {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            HvacMode::Off => write!(f, "off"),
            HvacMode::Heat => write!(f, "heat"),
            HvacMode::Auto => write!(f, "auto"),
        }
    }
}

/// Comfort preset used with [`crate::RointeClient::set_preset`].
#[derive(Debug, Clone, PartialEq)]
pub enum Preset {
    /// Heat to the device's configured comfort temperature.
    Comfort,
    /// Heat to the device's configured eco (energy-saving) temperature.
    Eco,
    /// Activate frost-protection (ice) mode.
    Ice,
}

impl fmt::Display for Preset {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Preset::Comfort => write!(f, "comfort"),
            Preset::Eco => write!(f, "eco"),
            Preset::Ice => write!(f, "ice"),
        }
    }
}

/// Interpretation of a single character slot in a device's weekly schedule string.
///
/// Each day's schedule is a 24-character string; each character represents one
/// hour and maps to one of these modes.
#[derive(Debug, Clone, PartialEq)]
pub enum ScheduleMode {
    /// `'C'` — heat to the comfort preset temperature.
    Comfort,
    /// `'E'` — heat to the eco preset temperature.
    Eco,
    /// Any other character — device is off during this hour.
    Off,
}

impl ScheduleMode {
    /// Parse a schedule character into the corresponding [`ScheduleMode`].
    ///
    /// - `'C'` → [`ScheduleMode::Comfort`]
    /// - `'E'` → [`ScheduleMode::Eco`]
    /// - anything else → [`ScheduleMode::Off`]
    pub fn from_char(c: char) -> Self {
        match c {
            'C' => ScheduleMode::Comfort,
            'E' => ScheduleMode::Eco,
            _ => ScheduleMode::Off,
        }
    }
}