mabi-knx 1.6.2

Mabinogion - KNXnet/IP simulator
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

//! KNX Datapoint Types (DPT).
//!
//! This module provides a trait-based, extensible system for KNX Datapoint Types.
//! New DPT types can be easily added by implementing the [`DptCodec`] trait.
//!
//! ## Architecture
//!
//! ```text
//! ┌─────────────────────────────────────────────────────────────┐
//! │                     DptCodec Trait                          │
//! │   encode(&DptValue) -> Vec<u8>                              │
//! │   decode(&[u8]) -> DptValue                                 │
//! │   size() -> usize                                           │
//! │   id() -> DptId                                             │
//! └─────────────────────────────────────────────────────────────┘
//!                              │
//!          ┌──────────────────┼──────────────────┐
//!          │                  │                  │
//!          ▼                  ▼                  ▼
//!   ┌────────────┐    ┌────────────┐    ┌────────────┐
//!   │  Dpt1Bool  │    │  Dpt9Float │    │  Custom    │
//!   │  (1-bit)   │    │  (2-byte)  │    │  DPT       │
//!   └────────────┘    └────────────┘    └────────────┘
//! ```
//!
//! ## Example
//!
//! ```rust,ignore
//! use mabi_knx::dpt::{DptCodec, Dpt1Switch, DptValue};
//!
//! let codec = Dpt1Switch;
//! let value = DptValue::Bool(true);
//! let encoded = codec.encode(&value).unwrap();
//! let decoded = codec.decode(&encoded).unwrap();
//! ```

mod codec;
mod registry;
mod types;
mod value;

pub use codec::{BoxedDptCodec, DptCodec, DptId};
pub use registry::DptRegistry;
pub use types::*;
pub use value::DptValue;

/// Standard KNX 16-bit float encoding.
pub fn encode_dpt9(value: f32) -> u16 {
    if value == 0.0 {
        return 0;
    }

    let mut exp: i32 = 0;
    let mut mantissa = (value * 100.0) as i32;

    // Normalize mantissa to fit in 11 bits (signed: -2048 to 2047)
    while mantissa.abs() > 2047 && exp < 15 {
        mantissa /= 2;
        exp += 1;
    }

    let sign = if mantissa < 0 { 1u16 } else { 0u16 };
    let mantissa = if sign == 1 {
        (mantissa + 2048) as u16
    } else {
        mantissa as u16
    };

    (sign << 15) | ((exp as u16 & 0x0F) << 11) | (mantissa & 0x07FF)
}

/// Standard KNX 16-bit float decoding.
pub fn decode_dpt9(raw: u16) -> f32 {
    let sign = (raw >> 15) & 0x01;
    let exp = ((raw >> 11) & 0x0F) as i32;
    let mantissa = (raw & 0x07FF) as i32;

    let mantissa = if sign == 1 { mantissa - 2048 } else { mantissa };

    0.01 * (mantissa as f32) * 2.0_f32.powi(exp)
}

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

    #[test]
    fn test_dpt9_encode_decode() {
        let values = [0.0, 1.0, -1.0, 25.5, -40.0, 100.0, 670760.0];

        for &original in &values {
            let encoded = encode_dpt9(original);
            let decoded = decode_dpt9(encoded);
            // DPT9 has limited precision
            let tolerance = original.abs() * 0.02 + 0.01;
            assert!(
                (decoded - original).abs() < tolerance,
                "Failed for {}: got {}",
                original,
                decoded
            );
        }
    }

    #[test]
    fn test_dpt9_zero() {
        assert_eq!(encode_dpt9(0.0), 0);
        assert_eq!(decode_dpt9(0), 0.0);
    }
}