#![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 = 0x002F;
pub const REVISION: u16 = 3;
pub const PICS: &str = "PS";
pub mod feature {
pub const WIRED: u32 = 1 << 0;
pub const BATTERY: u32 = 1 << 1;
pub const RECHARGEABLE: u32 = 1 << 2;
pub const REPLACEABLE: u32 = 1 << 3;
}
pub const FEATURES: &[Feature] = &[
Feature {
bit: 0,
code: "WIRED",
name: "Wired",
conform: Conform::OPTIONAL,
},
Feature {
bit: 1,
code: "BAT",
name: "Battery",
conform: Conform::OPTIONAL,
},
Feature {
bit: 2,
code: "RECHG",
name: "Rechargeable",
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(1),
}],
},
},
Feature {
bit: 3,
code: "REPLC",
name: "Replaceable",
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(1),
}],
},
},
];
pub mod attribute {
use crate::im::AttributeId;
pub const STATUS: AttributeId = 0x00;
pub const ORDER: AttributeId = 0x01;
pub const DESCRIPTION: AttributeId = 0x02;
pub const WIRED_ASSESSED_INPUT_VOLTAGE: AttributeId = 0x03;
pub const WIRED_ASSESSED_INPUT_FREQUENCY: AttributeId = 0x04;
pub const WIRED_CURRENT_TYPE: AttributeId = 0x05;
pub const WIRED_ASSESSED_CURRENT: AttributeId = 0x06;
pub const WIRED_NOMINAL_VOLTAGE: AttributeId = 0x07;
pub const WIRED_MAXIMUM_CURRENT: AttributeId = 0x08;
pub const WIRED_PRESENT: AttributeId = 0x09;
pub const ACTIVE_WIRED_FAULTS: AttributeId = 0x0A;
pub const BAT_VOLTAGE: AttributeId = 0x0B;
pub const BAT_PERCENT_REMAINING: AttributeId = 0x0C;
pub const BAT_TIME_REMAINING: AttributeId = 0x0D;
pub const BAT_CHARGE_LEVEL: AttributeId = 0x0E;
pub const BAT_REPLACEMENT_NEEDED: AttributeId = 0x0F;
pub const BAT_REPLACEABILITY: AttributeId = 0x10;
pub const BAT_PRESENT: AttributeId = 0x11;
pub const ACTIVE_BAT_FAULTS: AttributeId = 0x12;
pub const BAT_REPLACEMENT_DESCRIPTION: AttributeId = 0x13;
pub const BAT_COMMON_DESIGNATION: AttributeId = 0x14;
pub const BAT_ANSI_DESIGNATION: AttributeId = 0x15;
pub const BAT_IEC_DESIGNATION: AttributeId = 0x16;
pub const BAT_APPROVED_CHEMISTRY: AttributeId = 0x17;
pub const BAT_CAPACITY: AttributeId = 0x18;
pub const BAT_QUANTITY: AttributeId = 0x19;
pub const BAT_CHARGE_STATE: AttributeId = 0x1A;
pub const BAT_TIME_TO_FULL_CHARGE: AttributeId = 0x1B;
pub const BAT_FUNCTIONAL_WHILE_CHARGING: AttributeId = 0x1C;
pub const BAT_CHARGING_CURRENT: AttributeId = 0x1D;
pub const ACTIVE_BAT_CHARGE_FAULTS: AttributeId = 0x1E;
pub const ENDPOINT_LIST: AttributeId = 0x1F;
}
pub mod event {
use crate::im::EventId;
pub const WIRED_FAULT_CHANGE: EventId = 0x00;
pub const BAT_FAULT_CHANGE: EventId = 0x01;
pub const BAT_CHARGE_FAULT_CHANGE: EventId = 0x02;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum BatApprovedChemistryEnum {
Unspecified = 0,
Alkaline = 1,
LithiumCarbonFluoride = 2,
LithiumChromiumOxide = 3,
LithiumCopperOxide = 4,
LithiumIronDisulfide = 5,
LithiumManganeseDioxide = 6,
LithiumThionylChloride = 7,
Magnesium = 8,
MercuryOxide = 9,
NickelOxyhydride = 10,
SilverOxide = 11,
ZincAir = 12,
ZincCarbon = 13,
ZincChloride = 14,
ZincManganeseDioxide = 15,
LeadAcid = 16,
LithiumCobaltOxide = 17,
LithiumIon = 18,
LithiumIonPolymer = 19,
LithiumIronPhosphate = 20,
LithiumSulfur = 21,
LithiumTitanate = 22,
NickelCadmium = 23,
NickelHydrogen = 24,
NickelIron = 25,
NickelMetalHydride = 26,
NickelZinc = 27,
SilverZinc = 28,
SodiumIon = 29,
SodiumSulfur = 30,
ZincBromide = 31,
ZincCerium = 32,
}
impl BatApprovedChemistryEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Unspecified),
1 => Some(Self::Alkaline),
2 => Some(Self::LithiumCarbonFluoride),
3 => Some(Self::LithiumChromiumOxide),
4 => Some(Self::LithiumCopperOxide),
5 => Some(Self::LithiumIronDisulfide),
6 => Some(Self::LithiumManganeseDioxide),
7 => Some(Self::LithiumThionylChloride),
8 => Some(Self::Magnesium),
9 => Some(Self::MercuryOxide),
10 => Some(Self::NickelOxyhydride),
11 => Some(Self::SilverOxide),
12 => Some(Self::ZincAir),
13 => Some(Self::ZincCarbon),
14 => Some(Self::ZincChloride),
15 => Some(Self::ZincManganeseDioxide),
16 => Some(Self::LeadAcid),
17 => Some(Self::LithiumCobaltOxide),
18 => Some(Self::LithiumIon),
19 => Some(Self::LithiumIonPolymer),
20 => Some(Self::LithiumIronPhosphate),
21 => Some(Self::LithiumSulfur),
22 => Some(Self::LithiumTitanate),
23 => Some(Self::NickelCadmium),
24 => Some(Self::NickelHydrogen),
25 => Some(Self::NickelIron),
26 => Some(Self::NickelMetalHydride),
27 => Some(Self::NickelZinc),
28 => Some(Self::SilverZinc),
29 => Some(Self::SodiumIon),
30 => Some(Self::SodiumSulfur),
31 => Some(Self::ZincBromide),
32 => Some(Self::ZincCerium),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for BatApprovedChemistryEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for BatApprovedChemistryEnum {
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 BatChargeFaultEnum {
Unspecified = 0,
AmbientTooHot = 1,
AmbientTooCold = 2,
BatteryTooHot = 3,
BatteryTooCold = 4,
BatteryAbsent = 5,
BatteryOverVoltage = 6,
BatteryUnderVoltage = 7,
ChargerOverVoltage = 8,
ChargerUnderVoltage = 9,
SafetyTimeout = 10,
}
impl BatChargeFaultEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Unspecified),
1 => Some(Self::AmbientTooHot),
2 => Some(Self::AmbientTooCold),
3 => Some(Self::BatteryTooHot),
4 => Some(Self::BatteryTooCold),
5 => Some(Self::BatteryAbsent),
6 => Some(Self::BatteryOverVoltage),
7 => Some(Self::BatteryUnderVoltage),
8 => Some(Self::ChargerOverVoltage),
9 => Some(Self::ChargerUnderVoltage),
10 => Some(Self::SafetyTimeout),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for BatChargeFaultEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for BatChargeFaultEnum {
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 BatChargeLevelEnum {
OK = 0,
Warning = 1,
Critical = 2,
}
impl BatChargeLevelEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::OK),
1 => Some(Self::Warning),
2 => Some(Self::Critical),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for BatChargeLevelEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for BatChargeLevelEnum {
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 BatChargeStateEnum {
Unknown = 0,
IsCharging = 1,
IsAtFullCharge = 2,
IsNotCharging = 3,
}
impl BatChargeStateEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Unknown),
1 => Some(Self::IsCharging),
2 => Some(Self::IsAtFullCharge),
3 => Some(Self::IsNotCharging),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for BatChargeStateEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for BatChargeStateEnum {
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 BatCommonDesignationEnum {
Unspecified = 0,
AAA = 1,
AA = 2,
C = 3,
D = 4,
N4V5 = 5,
N6V0 = 6,
N9V0 = 7,
N12AA = 8,
AAAA = 9,
A = 10,
B = 11,
F = 12,
N = 13,
No6 = 14,
SubC = 15,
A23 = 16,
A27 = 17,
BA5800 = 18,
Duplex = 19,
N4SR44 = 20,
N523 = 21,
N531 = 22,
N15V0 = 23,
N22V5 = 24,
N30V0 = 25,
N45V0 = 26,
N67V5 = 27,
J = 28,
CR123A = 29,
CR2 = 30,
N2CR5 = 31,
CRP2 = 32,
CRV3 = 33,
SR41 = 34,
SR43 = 35,
SR44 = 36,
SR45 = 37,
SR48 = 38,
SR54 = 39,
SR55 = 40,
SR57 = 41,
SR58 = 42,
SR59 = 43,
SR60 = 44,
SR63 = 45,
SR64 = 46,
SR65 = 47,
SR66 = 48,
SR67 = 49,
SR68 = 50,
SR69 = 51,
SR516 = 52,
SR731 = 53,
SR712 = 54,
LR932 = 55,
A5 = 56,
A10 = 57,
A13 = 58,
A312 = 59,
A675 = 60,
AC41E = 61,
N10180 = 62,
N10280 = 63,
N10440 = 64,
N14250 = 65,
N14430 = 66,
N14500 = 67,
N14650 = 68,
N15270 = 69,
N16340 = 70,
RCR123A = 71,
N17500 = 72,
N17670 = 73,
N18350 = 74,
N18500 = 75,
N18650 = 76,
N19670 = 77,
N25500 = 78,
N26650 = 79,
N32600 = 80,
}
impl BatCommonDesignationEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Unspecified),
1 => Some(Self::AAA),
2 => Some(Self::AA),
3 => Some(Self::C),
4 => Some(Self::D),
5 => Some(Self::N4V5),
6 => Some(Self::N6V0),
7 => Some(Self::N9V0),
8 => Some(Self::N12AA),
9 => Some(Self::AAAA),
10 => Some(Self::A),
11 => Some(Self::B),
12 => Some(Self::F),
13 => Some(Self::N),
14 => Some(Self::No6),
15 => Some(Self::SubC),
16 => Some(Self::A23),
17 => Some(Self::A27),
18 => Some(Self::BA5800),
19 => Some(Self::Duplex),
20 => Some(Self::N4SR44),
21 => Some(Self::N523),
22 => Some(Self::N531),
23 => Some(Self::N15V0),
24 => Some(Self::N22V5),
25 => Some(Self::N30V0),
26 => Some(Self::N45V0),
27 => Some(Self::N67V5),
28 => Some(Self::J),
29 => Some(Self::CR123A),
30 => Some(Self::CR2),
31 => Some(Self::N2CR5),
32 => Some(Self::CRP2),
33 => Some(Self::CRV3),
34 => Some(Self::SR41),
35 => Some(Self::SR43),
36 => Some(Self::SR44),
37 => Some(Self::SR45),
38 => Some(Self::SR48),
39 => Some(Self::SR54),
40 => Some(Self::SR55),
41 => Some(Self::SR57),
42 => Some(Self::SR58),
43 => Some(Self::SR59),
44 => Some(Self::SR60),
45 => Some(Self::SR63),
46 => Some(Self::SR64),
47 => Some(Self::SR65),
48 => Some(Self::SR66),
49 => Some(Self::SR67),
50 => Some(Self::SR68),
51 => Some(Self::SR69),
52 => Some(Self::SR516),
53 => Some(Self::SR731),
54 => Some(Self::SR712),
55 => Some(Self::LR932),
56 => Some(Self::A5),
57 => Some(Self::A10),
58 => Some(Self::A13),
59 => Some(Self::A312),
60 => Some(Self::A675),
61 => Some(Self::AC41E),
62 => Some(Self::N10180),
63 => Some(Self::N10280),
64 => Some(Self::N10440),
65 => Some(Self::N14250),
66 => Some(Self::N14430),
67 => Some(Self::N14500),
68 => Some(Self::N14650),
69 => Some(Self::N15270),
70 => Some(Self::N16340),
71 => Some(Self::RCR123A),
72 => Some(Self::N17500),
73 => Some(Self::N17670),
74 => Some(Self::N18350),
75 => Some(Self::N18500),
76 => Some(Self::N18650),
77 => Some(Self::N19670),
78 => Some(Self::N25500),
79 => Some(Self::N26650),
80 => Some(Self::N32600),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for BatCommonDesignationEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for BatCommonDesignationEnum {
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 BatFaultEnum {
Unspecified = 0,
OverTemp = 1,
UnderTemp = 2,
}
impl BatFaultEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Unspecified),
1 => Some(Self::OverTemp),
2 => Some(Self::UnderTemp),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for BatFaultEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for BatFaultEnum {
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 BatReplaceabilityEnum {
Unspecified = 0,
NotReplaceable = 1,
UserReplaceable = 2,
FactoryReplaceable = 3,
}
impl BatReplaceabilityEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Unspecified),
1 => Some(Self::NotReplaceable),
2 => Some(Self::UserReplaceable),
3 => Some(Self::FactoryReplaceable),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for BatReplaceabilityEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for BatReplaceabilityEnum {
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 PowerSourceStatusEnum {
Unspecified = 0,
Active = 1,
Standby = 2,
Unavailable = 3,
}
impl PowerSourceStatusEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Unspecified),
1 => Some(Self::Active),
2 => Some(Self::Standby),
3 => Some(Self::Unavailable),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for PowerSourceStatusEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for PowerSourceStatusEnum {
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 WiredCurrentTypeEnum {
AC = 0,
DC = 1,
}
impl WiredCurrentTypeEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::AC),
1 => Some(Self::DC),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for WiredCurrentTypeEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for WiredCurrentTypeEnum {
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 WiredFaultEnum {
Unspecified = 0,
OverVoltage = 1,
UnderVoltage = 2,
}
impl WiredFaultEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Unspecified),
1 => Some(Self::OverVoltage),
2 => Some(Self::UnderVoltage),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for WiredFaultEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for WiredFaultEnum {
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))
}
}
pub const ATTRIBUTES: &[Attribute] = &[
Attribute {
id: 0x0000,
name: "Status",
kind: "PowerSourceStatusEnum",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::empty(),
reporting: Reporting::OnChange,
conform: Conform::MANDATORY,
},
Attribute {
id: 0x0001,
name: "Order",
kind: "uint8",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::NON_VOLATILE,
reporting: Reporting::OnChange,
conform: Conform::MANDATORY,
},
Attribute {
id: 0x0002,
name: "Description",
kind: "string",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::FIXED,
reporting: Reporting::OnChange,
conform: Conform::MANDATORY,
},
Attribute {
id: 0x0003,
name: "WiredAssessedInputVoltage",
kind: "uint32",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::NULLABLE,
reporting: Reporting::ChangesOmitted,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(0),
}],
},
},
Attribute {
id: 0x0004,
name: "WiredAssessedInputFrequency",
kind: "uint16",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::NULLABLE,
reporting: Reporting::ChangesOmitted,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(0),
}],
},
},
Attribute {
id: 0x0005,
name: "WiredCurrentType",
kind: "WiredCurrentTypeEnum",
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: 0x0006,
name: "WiredAssessedCurrent",
kind: "uint32",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::NULLABLE,
reporting: Reporting::ChangesOmitted,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(0),
}],
},
},
Attribute {
id: 0x0007,
name: "WiredNominalVoltage",
kind: "uint32",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::FIXED,
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(0),
}],
},
},
Attribute {
id: 0x0008,
name: "WiredMaximumCurrent",
kind: "uint32",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::FIXED,
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(0),
}],
},
},
Attribute {
id: 0x0009,
name: "WiredPresent",
kind: "bool",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::empty(),
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(0),
}],
},
},
Attribute {
id: 0x000A,
name: "ActiveWiredFaults",
kind: "list[WiredFaultEnum]",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::empty(),
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(0),
}],
},
},
Attribute {
id: 0x000B,
name: "BatVoltage",
kind: "uint32",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::NULLABLE,
reporting: Reporting::ChangesOmitted,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(1),
}],
},
},
Attribute {
id: 0x000C,
name: "BatPercentRemaining",
kind: "uint8",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::NULLABLE,
reporting: Reporting::Quieter,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(1),
}],
},
},
Attribute {
id: 0x000D,
name: "BatTimeRemaining",
kind: "uint32",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::NULLABLE,
reporting: Reporting::Quieter,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(1),
}],
},
},
Attribute {
id: 0x000E,
name: "BatChargeLevel",
kind: "BatChargeLevelEnum",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::empty(),
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(1),
}],
},
},
Attribute {
id: 0x000F,
name: "BatReplacementNeeded",
kind: "bool",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::empty(),
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(1),
}],
},
},
Attribute {
id: 0x0010,
name: "BatReplaceability",
kind: "BatReplaceabilityEnum",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::FIXED,
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(1),
}],
},
},
Attribute {
id: 0x0011,
name: "BatPresent",
kind: "bool",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::empty(),
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(1),
}],
},
},
Attribute {
id: 0x0012,
name: "ActiveBatFaults",
kind: "list[BatFaultEnum]",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::empty(),
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(1),
}],
},
},
Attribute {
id: 0x0013,
name: "BatReplacementDescription",
kind: "string",
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: 0x0014,
name: "BatCommonDesignation",
kind: "BatCommonDesignationEnum",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::FIXED,
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(3),
}],
},
},
Attribute {
id: 0x0015,
name: "BatANSIDesignation",
kind: "string",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::FIXED,
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(3),
}],
},
},
Attribute {
id: 0x0016,
name: "BatIECDesignation",
kind: "string",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::FIXED,
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(3),
}],
},
},
Attribute {
id: 0x0017,
name: "BatApprovedChemistry",
kind: "BatApprovedChemistryEnum",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::FIXED,
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(3),
}],
},
},
Attribute {
id: 0x0018,
name: "BatCapacity",
kind: "uint32",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::FIXED,
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Any(&[Condition::Feature(3), Condition::Feature(2)]),
}],
},
},
Attribute {
id: 0x0019,
name: "BatQuantity",
kind: "uint8",
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: 0x001A,
name: "BatChargeState",
kind: "BatChargeStateEnum",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::empty(),
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(2),
}],
},
},
Attribute {
id: 0x001B,
name: "BatTimeToFullCharge",
kind: "uint32",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::NULLABLE,
reporting: Reporting::Quieter,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(2),
}],
},
},
Attribute {
id: 0x001C,
name: "BatFunctionalWhileCharging",
kind: "bool",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::empty(),
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Feature(2),
}],
},
},
Attribute {
id: 0x001D,
name: "BatChargingCurrent",
kind: "uint32",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::NULLABLE,
reporting: Reporting::ChangesOmitted,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(2),
}],
},
},
Attribute {
id: 0x001E,
name: "ActiveBatChargeFaults",
kind: "list[BatChargeFaultEnum]",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::empty(),
reporting: Reporting::OnChange,
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(2),
}],
},
},
Attribute {
id: 0x001F,
name: "EndpointList",
kind: "list[endpoint-no]",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::empty(),
reporting: Reporting::OnChange,
conform: Conform::MANDATORY,
},
];
pub const COMMANDS: &[Command] = &[];
pub const EVENTS: &[Event] = &[
Event {
id: 0x00,
name: "WiredFaultChange",
priority: EventPriority::Info,
access: Access::read_only(Privilege::View),
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(0),
}],
},
},
Event {
id: 0x01,
name: "BatFaultChange",
priority: EventPriority::Info,
access: Access::read_only(Privilege::View),
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(1),
}],
},
},
Event {
id: 0x02,
name: "BatChargeFaultChange",
priority: EventPriority::Info,
access: Access::read_only(Privilege::View),
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Optional,
when: Condition::Feature(2),
}],
},
},
];
pub const CLUSTER: Cluster = Cluster {
id: ID,
name: "Power Source",
revision: REVISION,
pics: "PS",
derived_from: None,
features: FEATURES,
attributes: ATTRIBUTES,
commands: COMMANDS,
events: EVENTS,
};