matter_kit/clusters/generated/
identify.rs1#![allow(unused_imports)]
15
16use crate::dm::conformance::{Clause, Condition, Conform, Conformance};
17use crate::dm::meta::{EventPriority, Reporting};
18use crate::dm::spec::{Attribute, Cluster, Command, Event, Feature};
19use crate::dm::{Access, AccessQualities, AttributeQualities, Privilege};
20use crate::error::Result;
21use crate::im::{AttributeId, ClusterId, CommandId, EventId};
22use crate::tlv::{
23 ContainerKind, Element, FromTlv, Nullable, Tag, TlvList, TlvReader, TlvWriter, ToTlv, Value,
24};
25
26pub const ID: ClusterId = 0x0003;
28
29pub const REVISION: u16 = 6;
32
33pub const PICS: &str = "I";
35
36pub const FEATURES: &[Feature] = &[];
38
39pub mod attribute {
41 use crate::im::AttributeId;
42
43 pub const IDENTIFY_TIME: AttributeId = 0x00;
45 pub const IDENTIFY_TYPE: AttributeId = 0x01;
47}
48
49pub mod command {
51 use crate::im::CommandId;
52
53 pub const IDENTIFY: CommandId = 0x00;
55 pub const TRIGGER_EFFECT: CommandId = 0x40;
57}
58
59#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
61#[repr(u8)]
62pub enum EffectIdentifierEnum {
63 Blink = 0,
65 Breathe = 1,
67 Okay = 2,
69 ChannelChange = 11,
71 FinishEffect = 254,
73 StopEffect = 255,
75}
76
77impl EffectIdentifierEnum {
78 #[must_use]
80 pub const fn from_value(value: u8) -> Option<Self> {
81 match value {
82 0 => Some(Self::Blink),
83 1 => Some(Self::Breathe),
84 2 => Some(Self::Okay),
85 11 => Some(Self::ChannelChange),
86 254 => Some(Self::FinishEffect),
87 255 => Some(Self::StopEffect),
88 _ => None,
89 }
90 }
91
92 #[must_use]
94 pub const fn value(self) -> u8 {
95 self as u8
96 }
97}
98
99impl ToTlv for EffectIdentifierEnum {
100 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
101 self.value().to_tlv(w, tag)
102 }
103}
104
105impl<'a> FromTlv<'a> for EffectIdentifierEnum {
106 fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
107 let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
108 Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
109 }
110}
111
112#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
114#[repr(u8)]
115pub enum EffectVariantEnum {
116 Default = 0,
118}
119
120impl EffectVariantEnum {
121 #[must_use]
123 pub const fn from_value(value: u8) -> Option<Self> {
124 match value {
125 0 => Some(Self::Default),
126 _ => None,
127 }
128 }
129
130 #[must_use]
132 pub const fn value(self) -> u8 {
133 self as u8
134 }
135}
136
137impl ToTlv for EffectVariantEnum {
138 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
139 self.value().to_tlv(w, tag)
140 }
141}
142
143impl<'a> FromTlv<'a> for EffectVariantEnum {
144 fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
145 let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
146 Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
147 }
148}
149
150#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
152#[repr(u8)]
153pub enum IdentifyTypeEnum {
154 None = 0,
156 LightOutput = 1,
158 VisibleIndicator = 2,
160 AudibleBeep = 3,
162 Display = 4,
164 Actuator = 5,
166}
167
168impl IdentifyTypeEnum {
169 #[must_use]
171 pub const fn from_value(value: u8) -> Option<Self> {
172 match value {
173 0 => Some(Self::None),
174 1 => Some(Self::LightOutput),
175 2 => Some(Self::VisibleIndicator),
176 3 => Some(Self::AudibleBeep),
177 4 => Some(Self::Display),
178 5 => Some(Self::Actuator),
179 _ => None,
180 }
181 }
182
183 #[must_use]
185 pub const fn value(self) -> u8 {
186 self as u8
187 }
188}
189
190impl ToTlv for IdentifyTypeEnum {
191 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
192 self.value().to_tlv(w, tag)
193 }
194}
195
196impl<'a> FromTlv<'a> for IdentifyTypeEnum {
197 fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
198 let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
199 Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
200 }
201}
202
203#[derive(Debug, Clone, Copy, PartialEq)]
205pub struct IdentifyFields {
206 pub identify_time: u16,
208}
209
210impl ToTlv for IdentifyFields {
211 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
212 w.start_structure(tag)?;
213 self.identify_time.to_tlv(w, Tag::Context(0))?;
214 w.end_container()
215 }
216}
217
218impl<'a> FromTlv<'a> for IdentifyFields {
219 fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
220 if element.value.container() != Some(ContainerKind::Structure) {
221 return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
222 }
223 let mut identify_time = None;
224 loop {
225 let Some(field) = reader.next_element()? else {
226 return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
227 };
228 if field.value == Value::EndOfContainer {
229 break;
230 }
231 match field.tag.context() {
232 Some(0) => identify_time = Some(<u16>::from_tlv(reader, &field)?),
233 _ => reader.skip_value(&field)?,
237 }
238 }
239 Ok(Self {
240 identify_time: identify_time.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
241 })
242 }
243}
244
245#[derive(Debug, Clone, Copy, PartialEq)]
247pub struct TriggerEffectFields {
248 pub effect_identifier: EffectIdentifierEnum,
250 pub effect_variant: EffectVariantEnum,
252}
253
254impl ToTlv for TriggerEffectFields {
255 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
256 w.start_structure(tag)?;
257 self.effect_identifier.to_tlv(w, Tag::Context(0))?;
258 self.effect_variant.to_tlv(w, Tag::Context(1))?;
259 w.end_container()
260 }
261}
262
263impl<'a> FromTlv<'a> for TriggerEffectFields {
264 fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
265 if element.value.container() != Some(ContainerKind::Structure) {
266 return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
267 }
268 let mut effect_identifier = None;
269 let mut effect_variant = None;
270 loop {
271 let Some(field) = reader.next_element()? else {
272 return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
273 };
274 if field.value == Value::EndOfContainer {
275 break;
276 }
277 match field.tag.context() {
278 Some(0) => {
279 effect_identifier = Some(<EffectIdentifierEnum>::from_tlv(reader, &field)?)
280 }
281 Some(1) => effect_variant = Some(<EffectVariantEnum>::from_tlv(reader, &field)?),
282 _ => reader.skip_value(&field)?,
286 }
287 }
288 Ok(Self {
289 effect_identifier: effect_identifier
290 .ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
291 effect_variant: effect_variant
292 .ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
293 })
294 }
295}
296
297pub const ATTRIBUTES: &[Attribute] = &[
299 Attribute {
300 id: 0x0000,
301 name: "IdentifyTime",
302 kind: "uint16",
303 access: Access::read_write_with(Privilege::View, Privilege::Operate),
304 qualities: AttributeQualities::empty(),
305 reporting: Reporting::Quieter,
306 conform: Conform::MANDATORY,
307 },
308 Attribute {
309 id: 0x0001,
310 name: "IdentifyType",
311 kind: "IdentifyTypeEnum",
312 access: Access::read_only(Privilege::View),
313 qualities: AttributeQualities::empty(),
314 reporting: Reporting::OnChange,
315 conform: Conform::MANDATORY,
316 },
317];
318
319pub const COMMANDS: &[Command] = &[
321 Command {
322 id: 0x00,
323 name: "Identify",
324 to_server: true,
325 response: None,
326 access: Access::invoke(Privilege::Manage),
327 conform: Conform::MANDATORY,
328 },
329 Command {
330 id: 0x40,
331 name: "TriggerEffect",
332 to_server: true,
333 response: None,
334 access: Access::invoke(Privilege::Manage),
335 conform: Conform::OPTIONAL,
336 },
337];
338
339pub const EVENTS: &[Event] = &[];
341
342pub const CLUSTER: Cluster = Cluster {
344 id: ID,
345 name: "Identify",
346 revision: REVISION,
347 pics: "I",
348 derived_from: None,
349 features: FEATURES,
350 attributes: ATTRIBUTES,
351 commands: COMMANDS,
352 events: EVENTS,
353};