#![allow(unused_imports)]
use crate::dm::conformance::{Clause, Condition, Conform, Conformance};
use crate::dm::meta::{EventPriority, Reporting};
use crate::dm::spec::{Attribute, Cluster, Command, Event, Feature};
use crate::dm::{Access, AccessQualities, AttributeQualities, Privilege};
use crate::error::Result;
use crate::im::{AttributeId, ClusterId, CommandId, EventId};
use crate::tlv::{
ContainerKind, Element, FromTlv, Nullable, Tag, TlvList, TlvReader, TlvWriter, ToTlv, Value,
};
pub const ID: ClusterId = 0x0006;
pub const REVISION: u16 = 6;
pub const PICS: &str = "OO";
pub mod feature {
pub const LIGHTING: u32 = 1 << 0;
pub const DEAD_FRONT_BEHAVIOR: u32 = 1 << 1;
pub const OFF_ONLY: u32 = 1 << 2;
}
pub const FEATURES: &[Feature] = &[
Feature {
bit: 0,
code: "LT",
name: "Lighting",
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Not(&Condition::Feature(2)),
}],
},
},
Feature {
bit: 1,
code: "DF",
name: "DeadFrontBehavior",
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Not(&Condition::Feature(2)),
}],
},
},
Feature {
bit: 2,
code: "OFFONLY",
name: "OffOnly",
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Not(&Condition::Any(&[
Condition::Feature(0),
Condition::Feature(1),
])),
}],
},
},
];
pub mod attribute {
use crate::im::AttributeId;
pub const ON_OFF: AttributeId = 0x00;
pub const GLOBAL_SCENE_CONTROL: AttributeId = 0x4000;
pub const ON_TIME: AttributeId = 0x4001;
pub const OFF_WAIT_TIME: AttributeId = 0x4002;
pub const START_UP_ON_OFF: AttributeId = 0x4003;
}
pub mod command {
use crate::im::CommandId;
pub const OFF: CommandId = 0x00;
pub const ON: CommandId = 0x01;
pub const TOGGLE: CommandId = 0x02;
pub const OFF_WITH_EFFECT: CommandId = 0x40;
pub const ON_WITH_RECALL_GLOBAL_SCENE: CommandId = 0x41;
pub const ON_WITH_TIMED_OFF: CommandId = 0x42;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum DelayedAllOffEffectVariantEnum {
DelayedOffFastFade = 0,
NoFade = 1,
DelayedOffSlowFade = 2,
}
impl DelayedAllOffEffectVariantEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::DelayedOffFastFade),
1 => Some(Self::NoFade),
2 => Some(Self::DelayedOffSlowFade),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for DelayedAllOffEffectVariantEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for DelayedAllOffEffectVariantEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum DyingLightEffectVariantEnum {
DyingLightFadeOff = 0,
}
impl DyingLightEffectVariantEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::DyingLightFadeOff),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for DyingLightEffectVariantEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for DyingLightEffectVariantEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum EffectIdentifierEnum {
DelayedAllOff = 0,
DyingLight = 1,
}
impl EffectIdentifierEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::DelayedAllOff),
1 => Some(Self::DyingLight),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for EffectIdentifierEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for EffectIdentifierEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum StartUpOnOffEnum {
Off = 0,
On = 1,
Toggle = 2,
}
impl StartUpOnOffEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Off),
1 => Some(Self::On),
2 => Some(Self::Toggle),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for StartUpOnOffEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for StartUpOnOffEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
bitflags::bitflags! {
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct OnOffControlBitmap: u8 {
const ACCEPT_ONLY_WHEN_ON = 1 << 0;
}
}
impl ToTlv for OnOffControlBitmap {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.bits().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for OnOffControlBitmap {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let bits = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_bits(bits).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct OffWithEffectFields {
pub effect_identifier: EffectIdentifierEnum,
pub effect_variant: u8,
}
impl ToTlv for OffWithEffectFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.effect_identifier.to_tlv(w, Tag::Context(0))?;
self.effect_variant.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for OffWithEffectFields {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut effect_identifier = None;
let mut effect_variant = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => {
effect_identifier = Some(<EffectIdentifierEnum>::from_tlv(reader, &field)?)
}
Some(1) => effect_variant = Some(<u8>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
effect_identifier: effect_identifier
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
effect_variant: effect_variant
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct OnWithTimedOffFields {
pub on_off_control: OnOffControlBitmap,
pub on_time: u16,
pub off_wait_time: u16,
}
impl ToTlv for OnWithTimedOffFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.on_off_control.to_tlv(w, Tag::Context(0))?;
self.on_time.to_tlv(w, Tag::Context(1))?;
self.off_wait_time.to_tlv(w, Tag::Context(2))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for OnWithTimedOffFields {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut on_off_control = None;
let mut on_time = None;
let mut off_wait_time = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => on_off_control = Some(<OnOffControlBitmap>::from_tlv(reader, &field)?),
Some(1) => on_time = Some(<u16>::from_tlv(reader, &field)?),
Some(2) => off_wait_time = Some(<u16>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
on_off_control: on_off_control
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
on_time: on_time.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
off_wait_time: off_wait_time.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
pub const ATTRIBUTES: &[Attribute] = &[
Attribute {
id: 0x0000,
name: "OnOff",
kind: "bool",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::NON_VOLATILE.union(AttributeQualities::SCENE),
reporting: Reporting::OnChange,
conform: Conform::MANDATORY,
},
Attribute {
id: 0x4000,
name: "GlobalSceneControl",
kind: "bool",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::empty(),
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(0),
}],
},
},
Attribute {
id: 0x4001,
name: "OnTime",
kind: "uint16",
access: Access::read_write_with(Privilege::View, Privilege::Operate),
qualities: AttributeQualities::empty(),
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(0),
}],
},
},
Attribute {
id: 0x4002,
name: "OffWaitTime",
kind: "uint16",
access: Access::read_write_with(Privilege::View, Privilege::Operate),
qualities: AttributeQualities::empty(),
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(0),
}],
},
},
Attribute {
id: 0x4003,
name: "StartUpOnOff",
kind: "StartUpOnOffEnum",
access: Access::read_write_with(Privilege::View, Privilege::Manage),
qualities: AttributeQualities::NULLABLE.union(AttributeQualities::NON_VOLATILE),
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(0),
}],
},
},
];
pub const COMMANDS: &[Command] = &[
Command {
id: 0x00,
name: "Off",
to_server: true,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform::MANDATORY,
},
Command {
id: 0x01,
name: "On",
to_server: true,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Not(&Condition::Feature(2)),
}],
},
},
Command {
id: 0x02,
name: "Toggle",
to_server: true,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Not(&Condition::Feature(2)),
}],
},
},
Command {
id: 0x40,
name: "OffWithEffect",
to_server: true,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(0),
}],
},
},
Command {
id: 0x41,
name: "OnWithRecallGlobalScene",
to_server: true,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(0),
}],
},
},
Command {
id: 0x42,
name: "OnWithTimedOff",
to_server: true,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(0),
}],
},
},
];
pub const EVENTS: &[Event] = &[];
pub const CLUSTER: Cluster = Cluster {
id: ID,
name: "On/Off",
revision: REVISION,
pics: "OO",
derived_from: None,
features: FEATURES,
attributes: ATTRIBUTES,
commands: COMMANDS,
events: EVENTS,
};