#![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 = 0x0202;
pub const REVISION: u16 = 6;
pub const PICS: &str = "FAN";
pub mod feature {
pub const MULTI_SPEED: u32 = 1 << 0;
pub const AUTO: u32 = 1 << 1;
pub const ROCKING: u32 = 1 << 2;
pub const WIND: u32 = 1 << 3;
pub const STEP: u32 = 1 << 4;
pub const AIRFLOW_DIRECTION: u32 = 1 << 5;
}
pub const FEATURES: &[Feature] = &[
Feature {
bit: 0,
code: "SPD",
name: "MultiSpeed",
conform: Conform::OPTIONAL,
},
Feature {
bit: 1,
code: "AUT",
name: "Auto",
conform: Conform::OPTIONAL,
},
Feature {
bit: 2,
code: "RCK",
name: "Rocking",
conform: Conform::OPTIONAL,
},
Feature {
bit: 3,
code: "WND",
name: "Wind",
conform: Conform::OPTIONAL,
},
Feature {
bit: 4,
code: "STEP",
name: "Step",
conform: Conform::OPTIONAL,
},
Feature {
bit: 5,
code: "DIR",
name: "AirflowDirection",
conform: Conform::OPTIONAL,
},
];
pub mod attribute {
use crate::im::AttributeId;
pub const FAN_MODE: AttributeId = 0x00;
pub const FAN_MODE_SEQUENCE: AttributeId = 0x01;
pub const PERCENT_SETTING: AttributeId = 0x02;
pub const PERCENT_CURRENT: AttributeId = 0x03;
pub const SPEED_MAX: AttributeId = 0x04;
pub const SPEED_SETTING: AttributeId = 0x05;
pub const SPEED_CURRENT: AttributeId = 0x06;
pub const ROCK_SUPPORT: AttributeId = 0x07;
pub const ROCK_SETTING: AttributeId = 0x08;
pub const WIND_SUPPORT: AttributeId = 0x09;
pub const WIND_SETTING: AttributeId = 0x0A;
pub const AIRFLOW_DIRECTION: AttributeId = 0x0B;
}
pub mod command {
use crate::im::CommandId;
pub const STEP: CommandId = 0x00;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum AirflowDirectionEnum {
Forward = 0,
Reverse = 1,
}
impl AirflowDirectionEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Forward),
1 => Some(Self::Reverse),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for AirflowDirectionEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for AirflowDirectionEnum {
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 FanModeEnum {
Off = 0,
Low = 1,
Medium = 2,
High = 3,
On = 4,
Auto = 5,
Smart = 6,
}
impl FanModeEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Off),
1 => Some(Self::Low),
2 => Some(Self::Medium),
3 => Some(Self::High),
4 => Some(Self::On),
5 => Some(Self::Auto),
6 => Some(Self::Smart),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for FanModeEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for FanModeEnum {
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 FanModeSequenceEnum {
OffLowMedHigh = 0,
OffLowHigh = 1,
OffLowMedHighAuto = 2,
OffLowHighAuto = 3,
OffHighAuto = 4,
OffHigh = 5,
}
impl FanModeSequenceEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::OffLowMedHigh),
1 => Some(Self::OffLowHigh),
2 => Some(Self::OffLowMedHighAuto),
3 => Some(Self::OffLowHighAuto),
4 => Some(Self::OffHighAuto),
5 => Some(Self::OffHigh),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for FanModeSequenceEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for FanModeSequenceEnum {
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 StepDirectionEnum {
Increase = 0,
Decrease = 1,
}
impl StepDirectionEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Increase),
1 => Some(Self::Decrease),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for StepDirectionEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for StepDirectionEnum {
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 RockBitmap: u8 {
const ROCK_LEFT_RIGHT = 1 << 0;
const ROCK_UP_DOWN = 1 << 1;
const ROCK_ROUND = 1 << 2;
}
}
impl ToTlv for RockBitmap {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.bits().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for RockBitmap {
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))
}
}
bitflags::bitflags! {
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct WindBitmap: u8 {
const SLEEP_WIND = 1 << 0;
const NATURAL_WIND = 1 << 1;
}
}
impl ToTlv for WindBitmap {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.bits().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for WindBitmap {
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 StepFields {
pub direction: StepDirectionEnum,
pub wrap: Option<bool>,
pub lowest_off: Option<bool>,
}
impl ToTlv for StepFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.direction.to_tlv(w, Tag::Context(0))?;
if let Some(value) = &self.wrap {
value.to_tlv(w, Tag::Context(1))?;
}
if let Some(value) = &self.lowest_off {
value.to_tlv(w, Tag::Context(2))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for StepFields {
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 direction = None;
let mut wrap = None;
let mut lowest_off = 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) => direction = Some(<StepDirectionEnum>::from_tlv(reader, &field)?),
Some(1) => wrap = Some(<bool>::from_tlv(reader, &field)?),
Some(2) => lowest_off = Some(<bool>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
direction: direction.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
wrap,
lowest_off,
})
}
}
pub const ATTRIBUTES: &[Attribute] = &[
Attribute {
id: 0x0000,
name: "FanMode",
kind: "FanModeEnum",
access: Access::read_write_with(Privilege::View, Privilege::Operate),
qualities: AttributeQualities::NON_VOLATILE,
reporting: Reporting::OnChange,
conform: Conform::MANDATORY,
},
Attribute {
id: 0x0001,
name: "FanModeSequence",
kind: "FanModeSequenceEnum",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::FIXED,
reporting: Reporting::OnChange,
conform: Conform::MANDATORY,
},
Attribute {
id: 0x0002,
name: "PercentSetting",
kind: "percent",
access: Access::read_write_with(Privilege::View, Privilege::Operate),
qualities: AttributeQualities::NULLABLE,
reporting: Reporting::OnChange,
conform: Conform::MANDATORY,
},
Attribute {
id: 0x0003,
name: "PercentCurrent",
kind: "percent",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::empty(),
reporting: Reporting::OnChange,
conform: Conform::MANDATORY,
},
Attribute {
id: 0x0004,
name: "SpeedMax",
kind: "uint8",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::FIXED,
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(0),
}],
},
},
Attribute {
id: 0x0005,
name: "SpeedSetting",
kind: "uint8",
access: Access::read_write_with(Privilege::View, Privilege::Operate),
qualities: AttributeQualities::NULLABLE,
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(0),
}],
},
},
Attribute {
id: 0x0006,
name: "SpeedCurrent",
kind: "uint8",
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: 0x0007,
name: "RockSupport",
kind: "RockBitmap",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::FIXED,
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(2),
}],
},
},
Attribute {
id: 0x0008,
name: "RockSetting",
kind: "RockBitmap",
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(2),
}],
},
},
Attribute {
id: 0x0009,
name: "WindSupport",
kind: "WindBitmap",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::FIXED,
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(3),
}],
},
},
Attribute {
id: 0x000A,
name: "WindSetting",
kind: "WindBitmap",
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(3),
}],
},
},
Attribute {
id: 0x000B,
name: "AirflowDirection",
kind: "AirflowDirectionEnum",
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(5),
}],
},
},
];
pub const COMMANDS: &[Command] = &[Command {
id: 0x00,
name: "Step",
to_server: true,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(4),
}],
},
}];
pub const EVENTS: &[Event] = &[];
pub const CLUSTER: Cluster = Cluster {
id: ID,
name: "Fan Control",
revision: REVISION,
pics: "FAN",
derived_from: None,
features: FEATURES,
attributes: ATTRIBUTES,
commands: COMMANDS,
events: EVENTS,
};