WIP

Author: Bergmann89

Cargo.lock

@@ -5,6 +5,7 @@ edition = "2021"
 
 [dependencies]
 anyhow = "1.0.99"
+arrayvec = "0.7.6"
 bitflags = "2.9.1"
 color_space = "0.5.4"
 crc = "3.3.0"

Cargo.toml

@@ -1,4 +1,2 @@
-#![allow(missing_docs)] // TODO
-
 pub mod misc;
 pub mod protocol;

src/lib.rs

@@ -1,5 +1,3 @@
-#![allow(missing_docs)] // TODO
-
 use std::io::stdin;
 use std::mem::take;
 use std::num::ParseIntError;

src/main.rs

@@ -1,11 +1,9 @@
-#![allow(missing_docs, clippy::missing_errors_doc)] // TODO
-
 use std::convert::Infallible;
 use std::fmt::Display;
 use std::io::{Error as IoError, Read, Write};
 use std::marker::PhantomData;
 
-use smallvec::{Array, SmallVec};
+use arrayvec::ArrayVec;
 use thiserror::Error;
 
 use crate::misc::wrapped::RangeError;
@@ -216,10 +214,9 @@ impl BinaryRead for i16 {
 impl<T, const N: usize> BinaryRead for [T; N]
 where
     T: BinaryRead,
-    [T; N]: Array<Item = T>,
 {
     fn decode<R: Reader>(reader: &mut R) -> Result<ReaderOutput<R, Self>, Error> {
-        let mut data = R::guard(|_| SmallVec::<[T; N]>::new());
+        let mut data = R::guard(|_| ArrayVec::<T, N>::new());
 
         for _ in 0..N {
             let item = T::decode(reader)?;

src/misc/binary_io.rs

@@ -1,5 +1,3 @@
-#![allow(missing_docs)] // TODO
-
 mod binary_io;
 mod crc;
 mod wrapped;

src/misc/mod.rs

@@ -1,5 +1,3 @@
-#![allow(missing_docs, clippy::missing_errors_doc)] // TODO
-
 use std::fmt::{Debug, Display};
 use std::marker::PhantomData;
 use std::ops::Deref;
@@ -10,9 +8,11 @@ use crate::misc::{BinaryIoError, BinaryRead, Guard, Reader, ReaderOutput};
 
 #[macro_export]
 macro_rules! define_wrapped {
-    ($name:ident<$base:ty, $tag:ident>) => {
+    ($(#[$meta:meta])* $name:ident<$base:ty, $tag:ident>) => {
+        $(#[$meta])*
         pub type $name = $crate::misc::Wrapped<$base, $tag>;
 
+        #[allow(missing_docs)]
         #[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
         pub struct $tag;
     };

src/misc/wrapped.rs

@@ -1,14 +1,12 @@
-#![allow(missing_docs)] // TODO
-
-pub mod sensor_values;
+pub mod settings;
 
 use crate::misc::{BinaryIoError, BinaryRead, CrcReader, Guard, Reader, ReaderOutput};
 
-pub use self::sensor_values::SensorValues;
+pub use self::settings::Settings;
 
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum Frame {
-    SensorValues(SensorValues),
+    SensorValues(Settings),
 }
 
 impl BinaryRead for Frame {
@@ -18,7 +16,7 @@ impl BinaryRead for Frame {
 
         let ret = match op_code {
             0x03 => {
-                let ret = SensorValues::decode(&mut crc)?;
+                let ret = Settings::decode(&mut crc)?;
 
                 R::guard(|x| Self::SensorValues(x.extract(ret)))
             }

src/protocol/mod.rs

@@ -0,0 +1,145 @@
+use bitflags::bitflags;
+
+use crate::{define_wrapped, impl_ranged, misc::{BinaryIoError, BinaryRead, Guard, Reader, ReaderOutput}};
+
+use super::{Flow, flag_set};
+
+/// Alarm related settings for a high flow NEXT device.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct AlarmSettings {
+    /// Different flags.
+    pub flags: AlarmFlags,
+
+    /// Time to disable the alarms after boot to give the system time to start.
+    pub startup_delay: StartupDelay,
+
+    /// Whether to raise an alarm if the flow of the device drops below the
+    /// configured value or not.
+    pub flow_alarm_limit: Option<Flow>,
+
+    /// Whether to raise an alarm if the water temperature of the device raises
+    /// above the configured value or not.
+    pub water_temperature_limit: Option<Temperature>,
+
+    /// Whether to raise an alarm if the external temperature of the device raises
+    /// above the configured value or not.
+    pub external_temperature_limit: Option<Temperature>,
+
+    /// Whether to raise an alarm if the water quality of the device drops below
+    /// the configured value or not.
+    pub water_quality_limit: Option<WaterQuality>,
+
+    /// Signal to output at the signal output connector.
+    pub output_signal: OutputSignal,
+}
+
+impl BinaryRead for AlarmSettings {
+    fn decode<R: Reader>(reader: &mut R) -> Result<ReaderOutput<R, Self>, BinaryIoError> {
+        let flags = AlarmFlags::decode(reader)?;
+        let alarms = reader.read_u8()?;
+        reader.skip::<1>()?;
+        let startup_delay = StartupDelay::decode(reader)?;
+        let flow_alarm_limit = Flow::decode_opt(reader, flag_set(alarms, 0x01))?;
+        let water_temperature_limit = Temperature::decode_opt(reader, flag_set(alarms, 0x02))?;
+        let external_temperature_limit = Temperature::decode_opt(reader, flag_set(alarms, 0x04))?;
+        let water_quality_limit = WaterQuality::decode_opt(reader, flag_set(alarms, 0x08))?;
+        let output_signal = OutputSignal::decode(reader)?;
+
+        Ok(R::guard(|x| Self {
+            flags: x.extract(flags),
+            startup_delay: x.extract(startup_delay),
+            flow_alarm_limit: x.extract(flow_alarm_limit),
+            water_temperature_limit: x.extract(water_temperature_limit),
+            external_temperature_limit: x.extract(external_temperature_limit),
+            water_quality_limit: x.extract(water_quality_limit),
+            output_signal: x.extract(output_signal),
+        }))
+    }
+}
+
+/// Signal to output at the signal output connector.
+///
+/// Used in [`AlarmSettings::output_signal`].
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum OutputSignal {
+    /// Generate a constant speed signal.
+    ConstantSpeed,
+
+    /// Generate high flow sensor (53069) signal.
+    HighFlowSensor,
+
+    /// Generate a fan speed signal from the flow rate (1000rpm = 100l/h).
+    FanFromFlow,
+
+    /// Power switch for 1 seconds at alarm.
+    PulseOnAlarm,
+
+    /// Permanently switch on the output signal.
+    PermanentOn,
+
+    /// Permanently switch off the output signal
+    PermanentOff,
+}
+
+impl BinaryRead for OutputSignal {
+    fn decode<R: Reader>(reader: &mut R) -> Result<ReaderOutput<R, Self>, BinaryIoError> {
+        match reader.read_u8()? {
+            0x00 => Ok(R::guard(|_| Self::ConstantSpeed)),
+            0x01 => Ok(R::guard(|_| Self::HighFlowSensor)),
+            0x02 => Ok(R::guard(|_| Self::FanFromFlow)),
+            0x03 => Ok(R::guard(|_| Self::PulseOnAlarm)),
+            0x04 => Ok(R::guard(|_| Self::PermanentOn)),
+            0x05 => Ok(R::guard(|_| Self::PermanentOff)),
+            x => Err(BinaryIoError::InvalidValue("OutputSignal", x.into())),
+        }
+    }
+}
+
+bitflags! {
+    /// Different flags uses in [`AlarmSettings::flags`].
+    #[derive(Debug, Clone, Copy, Eq, PartialEq)]
+    pub struct AlarmFlags: u8 {
+        /// Disable signal output during alarm.
+        const DISABLE_SIGNAL_OUTPUT_DURING_ALARM = 0x20;
+
+        /// Enable optical indicator during alarm (red ring flashing).
+        const ENABLE_OPTICAL_INDICATOR = 0x40;
+
+        /// Enable acustic indicator during alarm (beep tone).
+        const ENABLE_ACUSTIC_INDICATOR = 0x80;
+    }
+}
+
+impl BinaryRead for AlarmFlags {
+    fn decode<R: Reader>(reader: &mut R) -> Result<ReaderOutput<R, Self>, BinaryIoError> {
+        let bits = reader.read_u8()?;
+
+        Ok(R::guard(|_| Self::from_bits_truncate(bits)))
+    }
+}
+
+define_wrapped! {
+    /// Time to disable the alarms after boot to give the system time to start.
+    ///
+    /// Used in [`AlarmSettings::startup_delay`].
+    ///
+    /// Valid value range: 0..100 in seconds
+    StartupDelay<u8, StartupDelayTag>
+}
+impl_ranged!(StartupDelay<u8, StartupDelayTag>, 0, 100);
+
+define_wrapped! {
+    /// Temperature value.
+    ///
+    /// Valid value range: 0..10000 in 1/100 degree celsius / fahrenheit (1/100 °C / °F)
+    Temperature<u16, TemperatureTag>
+}
+impl_ranged!(Temperature<u16, TemperatureTag>, 0, 10_000);
+
+define_wrapped! {
+    /// Water quality value.
+    ///
+    /// Valid value range: 0..10000 in 1/100 percent (1/100 %)
+    WaterQuality<u16, WaterQualityTag>
+}
+impl_ranged!(WaterQuality<u16, WaterQualityTag>, 0, 10000);