vcontrol 0.6.0

A library for communication with Viessmann heating controllers.
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
153
154
155

use phf;

use crate::{
  Command,
  types::{DeviceId, DeviceIdF0},
};

mod device_id_range;
pub use device_id_range::DeviceIdRange;

const USE_HARDWARE_INDEX: bool = false;

#[allow(clippy::unreadable_literal)]
mod codegen {
  use super::*;

  include!(concat!(env!("OUT_DIR"), "/devices.rs"));
}

pub use self::codegen::*;

/// Representation of a heating system device.
#[derive(Debug)]
pub struct Device {
  name: &'static str,
  commands: &'static phf::Map<&'static str, &'static Command>,
  errors: &'static phf::Map<i32, &'static str>,
}

impl Device {
  /// Get the name of the device.
  pub fn name(&self) -> &'static str {
    self.name
  }

  /// Get all supported commands for the device.
  pub fn commands(&self) -> &'static phf::Map<&'static str, &'static Command> {
    self.commands
  }

  /// Get a specific command for the device, if it is supported.
  pub fn command(&self, name: impl AsRef<str>) -> Option<&'static Command> {
    self.commands.get(name.as_ref()).copied()
  }

  /// Get mapping from error codes to strings.
  pub fn errors(&self) -> &'static phf::Map<i32, &'static str> {
    self.errors
  }

  /// Detect a device by identifier.
  pub fn detect(device_id: DeviceId, device_id_f0: Option<DeviceIdF0>) -> Option<&'static Self> {
    let devices = DEVICES.entries().filter(|(device_id_range, _)| device_id.id == device_id_range.id);

    if let Some(device_id_f0) = device_id_f0
      && (192..=203).contains(&device_id.id)
      && device_id.software_index >= 200
    {
      // Find exact F0 match.
      for (device_id_range, device) in devices.clone() {
        if let Some(f0) = device_id_range.f0
          && device_id_f0.0 == f0
        {
          log::debug!("Found device with exact ID and F0.");

          return Some(device);
        }
      }

      // Find match in F0 range.
      for (device_id_range, device) in devices.clone() {
        if let Some((f0, f0_till)) = device_id_range.f0.zip(device_id_range.f0_till) {
          let f0_range = f0..=f0_till;

          if f0_range.contains(&device_id_f0.0) {
            log::debug!("Found device with exact ID and F0 in range {:?}.", f0_range);

            return Some(device);
          }
        }
      }
    }

    let mut device_fallback = None;

    // Find exact hardware/software index match.
    for (device_id_range, device) in devices.clone() {
      if let Some((hardware_index, software_index)) = device_id_range.hardware_index.zip(device_id_range.software_index)
        && (!USE_HARDWARE_INDEX || device_id.hardware_index == hardware_index)
        && device_id.software_index == software_index
      {
        log::debug!("Found device with exact ID, hardware index and software index.");

        return Some(device);
      }

      device_fallback = Some(*device);
    }

    // Find match in hardware/software index range.
    for (device_id_range, device) in devices.clone() {
      if let Some((hardware_index, software_index)) = device_id_range.hardware_index.zip(device_id_range.software_index)
        && let Some((hardware_index_till, software_index_till)) =
          device_id_range.hardware_index_till.zip(device_id_range.software_index_till)
      {
        let hardware_index_range = hardware_index..=hardware_index_till;
        let software_index_range = software_index..=software_index_till;

        if (!USE_HARDWARE_INDEX || hardware_index_range.contains(&device_id.hardware_index))
          && software_index_range.contains(&device_id.software_index)
        {
          log::debug!(
            "Found device with exact ID, hardware index in range {:?} and software index in range {:?}.",
            hardware_index_range,
            software_index_range,
          );
          return Some(device);
        }
      }
    }

    if let Some(device) = device_fallback {
      log::debug!("Found device with exact ID.");
      return Some(device);
    }

    None
  }
}

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

  #[test]
  fn detect_vscot_ho1_4() {
    let device_id = DeviceId::from_bytes(&[0x20, 0xCB, 0x00, 0x08, 0x00, 0x00, 0x01, 0x46]);
    let device = Device::detect(device_id, None).unwrap();
    assert_eq!(device.name(), "VScotHO1_4");
  }

  #[test]
  fn detect_vscot_ho1_72() {
    let device_id = DeviceId::from_bytes(&[0x20, 0xCB, 0x03, 0x51, 0x00, 0x00, 0x01, 0x46]);
    let device = Device::detect(device_id, None).unwrap();
    assert_eq!(device.name(), "VScotHO1_72");
  }

  #[test]
  fn detect_ecotronic() {
    let device_id = DeviceId::from_bytes(&[0x20, 0x34, 0x00, 0x18, 0x00, 0x00, 0x0f, 0x0f]);
    let device = Device::detect(device_id, None).unwrap();
    assert_eq!(device.name(), "Ecotronic");
  }
}