huesmith 0.1.0

Hue-compatible Zigbee light library for ESP32-C6/H2 (ESP-IDF)
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

use super::ffi;
use huesmith_core::light::command::{
    LightCommand, DEFAULT_COLOR_TRANSITION_TENTHS, DEFAULT_LEVEL_TRANSITION_TENTHS,
};

/// Dispatch an incoming ZCL set_attribute_value message into a [`LightCommand`].
/// Returns `None` if the message is not relevant to light control.
///
/// `size` is the attribute value's declared byte length from the ZCL frame. Each
/// branch reads a fixed width (1 or 2 bytes) through a raw pointer, so it is
/// checked against `size` first: a malformed frame that declares a shorter value
/// than its attribute's type is rejected rather than read past its buffer. The
/// ZBOSS stack normally validates type/size before this callback, so this is
/// defense in depth — but the read is `unsafe` and the guard is nearly free.
pub fn parse_set_attribute(
    cluster_id: u16,
    attr_id: u16,
    size: u16,
    data: *const core::ffi::c_void,
) -> Option<LightCommand> {
    match cluster_id {
        ffi::CLUSTER_ON_OFF => match attr_id {
            ffi::ATTR_ON_OFF => {
                if size < 1 {
                    return None;
                }
                let on = unsafe { (data as *const u8).read() != 0 };
                Some(if on {
                    LightCommand::On
                } else {
                    LightCommand::Off
                })
            }
            _ => None,
        },
        ffi::CLUSTER_LEVEL_CONTROL => match attr_id {
            ffi::ATTR_LEVEL_CURRENT_LEVEL => {
                if size < 1 {
                    return None;
                }
                // Raw wire value: LightState normalizes every 0-254 ZCL domain
                // (level/hue/saturation) at its single transition entry point,
                // so 255 (reserved) can't wrap downstream scaling math.
                let level = unsafe { (data as *const u8).read() };
                Some(LightCommand::SetLevel {
                    level,
                    transition_time: DEFAULT_LEVEL_TRANSITION_TENTHS,
                })
            }
            _ => None,
        },
        ffi::CLUSTER_COLOR_CONTROL => match attr_id {
            ffi::ATTR_COLOR_CURRENT_X => {
                if size < 2 {
                    return None;
                }
                let x = unsafe { (data as *const u16).read_unaligned() };
                Some(LightCommand::MoveToColor {
                    x: Some(x),
                    y: None,
                    transition_time: DEFAULT_COLOR_TRANSITION_TENTHS,
                })
            }
            ffi::ATTR_COLOR_CURRENT_Y => {
                if size < 2 {
                    return None;
                }
                let y = unsafe { (data as *const u16).read_unaligned() };
                Some(LightCommand::MoveToColor {
                    x: None,
                    y: Some(y),
                    transition_time: DEFAULT_COLOR_TRANSITION_TENTHS,
                })
            }
            ffi::ATTR_COLOR_TEMPERATURE_MIREDS => {
                if size < 2 {
                    return None;
                }
                let mireds = unsafe { (data as *const u16).read_unaligned() };
                Some(LightCommand::MoveToColorTemp {
                    mireds,
                    transition_time: DEFAULT_COLOR_TRANSITION_TENTHS,
                })
            }
            ffi::ATTR_COLOR_CURRENT_HUE => {
                if size < 1 {
                    return None;
                }
                let hue = unsafe { (data as *const u8).read() };
                Some(LightCommand::MoveToHueAndSaturation {
                    hue: Some(hue),
                    saturation: None,
                    transition_time: DEFAULT_COLOR_TRANSITION_TENTHS,
                })
            }
            ffi::ATTR_COLOR_CURRENT_SATURATION => {
                if size < 1 {
                    return None;
                }
                let sat = unsafe { (data as *const u8).read() };
                Some(LightCommand::MoveToHueAndSaturation {
                    hue: None,
                    saturation: Some(sat),
                    transition_time: DEFAULT_COLOR_TRANSITION_TENTHS,
                })
            }
            ffi::ATTR_COLOR_ENHANCED_CURRENT_HUE => {
                if size < 2 {
                    return None;
                }
                let enhanced = unsafe { (data as *const u16).read_unaligned() };
                Some(LightCommand::EnhancedMoveToHueAndSaturation {
                    enhanced_hue: enhanced,
                    saturation: None,
                    transition_time: DEFAULT_COLOR_TRANSITION_TENTHS,
                })
            }
            ffi::ATTR_COLOR_MODE | ffi::ATTR_COLOR_ENHANCED_COLOR_MODE => None,
            _ => None,
        },
        ffi::CLUSTER_IDENTIFY => match attr_id {
            0x0000 => {
                if size < 2 {
                    return None;
                }
                let duration = unsafe { (data as *const u16).read_unaligned() };
                Some(LightCommand::Identify { duration })
            }
            _ => None,
        },
        _ => None,
    }
}