use crate::clusters::generated::electrical_energy_measurement as spec_energy;
use crate::clusters::generated::electrical_power_measurement as spec_power;
use crate::clusters::generated::power_topology as spec_topology;
use crate::dm::spec::{Conforming, Optional};
use crate::dm::{Resolved, ResolvedCommand};
use crate::im::{ClusterHandler, ClusterId, CommandId, InteractionContext, Status, StatusIb};
use crate::tlv::{Tag, TlvWriter, ToTlv};
use super::Cluster;
pub mod power {
pub use super::spec_power::attribute::{
ACCURACY, ACTIVE_CURRENT, ACTIVE_POWER, APPARENT_CURRENT, APPARENT_POWER, FREQUENCY,
HARMONIC_CURRENTS, HARMONIC_PHASES, NEUTRAL_CURRENT, NUMBER_OF_MEASUREMENT_TYPES,
POWER_FACTOR, POWER_MODE, RANGES, REACTIVE_CURRENT, REACTIVE_POWER, RMS_CURRENT, RMS_POWER,
RMS_VOLTAGE, VOLTAGE,
};
pub use super::spec_power::event::MEASUREMENT_PERIOD_RANGES;
pub use super::spec_power::{
HarmonicMeasurementStruct, ID, MeasurementAccuracyRangeStruct, MeasurementAccuracyStruct,
MeasurementRangeStruct, MeasurementTypeEnum, PICS, PowerModeEnum, REVISION, feature,
};
}
pub mod energy {
pub use super::spec_energy::attribute::{
ACCURACY, CUMULATIVE_ENERGY_EXPORTED, CUMULATIVE_ENERGY_IMPORTED, CUMULATIVE_ENERGY_RESET,
PERIODIC_ENERGY_EXPORTED, PERIODIC_ENERGY_IMPORTED,
};
pub use super::spec_energy::event::{CUMULATIVE_ENERGY_MEASURED, PERIODIC_ENERGY_MEASURED};
pub use super::spec_energy::{
CumulativeEnergyResetStruct, EnergyMeasurementStruct, ID, MeasurementAccuracyStruct, PICS,
REVISION, feature,
};
}
pub trait PowerMeterHooks {
fn power_mode(&self) -> power::PowerModeEnum {
power::PowerModeEnum::Unknown
}
fn accuracy(&self) -> &[power::MeasurementAccuracyStruct<'_>];
fn ranges(&self) -> &[power::MeasurementRangeStruct] {
&[]
}
fn voltage(&self) -> Option<i64> {
None
}
fn active_current(&self) -> Option<i64> {
None
}
fn reactive_current(&self) -> Option<i64> {
None
}
fn apparent_current(&self) -> Option<i64> {
None
}
fn active_power(&self) -> Option<i64>;
fn reactive_power(&self) -> Option<i64> {
None
}
fn apparent_power(&self) -> Option<i64> {
None
}
fn rms_voltage(&self) -> Option<i64> {
None
}
fn rms_current(&self) -> Option<i64> {
None
}
fn rms_power(&self) -> Option<i64> {
None
}
fn frequency(&self) -> Option<i64> {
None
}
fn power_factor(&self) -> Option<i64> {
None
}
fn neutral_current(&self) -> Option<i64> {
None
}
fn harmonic_currents(&self) -> &[power::HarmonicMeasurementStruct] {
&[]
}
fn harmonic_phases(&self) -> &[power::HarmonicMeasurementStruct] {
&[]
}
}
#[derive(Debug)]
pub struct ElectricalPowerMeasurement<'a, H: PowerMeterHooks> {
hooks: &'a H,
}
impl<'a, H: PowerMeterHooks> ElectricalPowerMeasurement<'a, H> {
#[must_use]
pub const fn new(hooks: &'a H) -> Self {
Self { hooks }
}
pub fn conforming(
feature_map: u32,
optional: &Optional<'_>,
) -> crate::error::Result<Conforming<19, 0, 0, 1>> {
Conforming::new(&spec_power::CLUSTER, feature_map, optional)
}
pub const WITH_BASIC_READINGS: Optional<'static> = Optional {
attributes: &[
power::RANGES,
power::VOLTAGE,
power::ACTIVE_CURRENT,
power::APPARENT_CURRENT,
],
commands: &[],
events: &[],
};
}
impl<H: PowerMeterHooks> ClusterHandler for ElectricalPowerMeasurement<'_, H> {
fn read(
&self,
resolved: &Resolved<'_>,
_ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
let full = |r: crate::error::Result<()>| r.map_err(|_| Status::ResourceExhausted);
let measured = |w: &mut TlvWriter<'_>, value: Option<i64>| match value {
Some(value) => full(w.signed(tag, value)),
None => full(w.null(tag)),
};
let list = |w: &mut TlvWriter<'_>, items: &[power::HarmonicMeasurementStruct]| {
full(w.start_array(tag))?;
for item in items {
full(item.to_tlv(w, Tag::Anonymous))?;
}
full(w.end_container())
};
match resolved.attribute {
power::POWER_MODE => full(w.unsigned(tag, u64::from(self.hooks.power_mode().value()))),
power::NUMBER_OF_MEASUREMENT_TYPES => full(w.unsigned(
tag,
u64::try_from(self.hooks.accuracy().len()).unwrap_or(u64::MAX),
)),
power::ACCURACY => {
full(w.start_array(tag))?;
for entry in self.hooks.accuracy() {
full(entry.to_tlv(w, Tag::Anonymous))?;
}
full(w.end_container())
}
power::RANGES => {
full(w.start_array(tag))?;
for entry in self.hooks.ranges() {
full(entry.to_tlv(w, Tag::Anonymous))?;
}
full(w.end_container())
}
power::VOLTAGE => measured(w, self.hooks.voltage()),
power::ACTIVE_CURRENT => measured(w, self.hooks.active_current()),
power::REACTIVE_CURRENT => measured(w, self.hooks.reactive_current()),
power::APPARENT_CURRENT => measured(w, self.hooks.apparent_current()),
power::ACTIVE_POWER => measured(w, self.hooks.active_power()),
power::REACTIVE_POWER => measured(w, self.hooks.reactive_power()),
power::APPARENT_POWER => measured(w, self.hooks.apparent_power()),
power::RMS_VOLTAGE => measured(w, self.hooks.rms_voltage()),
power::RMS_CURRENT => measured(w, self.hooks.rms_current()),
power::RMS_POWER => measured(w, self.hooks.rms_power()),
power::FREQUENCY => measured(w, self.hooks.frequency()),
power::POWER_FACTOR => measured(w, self.hooks.power_factor()),
power::NEUTRAL_CURRENT => measured(w, self.hooks.neutral_current()),
power::HARMONIC_CURRENTS => list(w, self.hooks.harmonic_currents()),
power::HARMONIC_PHASES => list(w, self.hooks.harmonic_phases()),
_ => Err(Status::UnsupportedAttribute),
}
}
fn invoke(
&self,
_resolved: &ResolvedCommand<'_>,
_fields: Option<&[u8]>,
_ctx: &InteractionContext<'_>,
_w: &mut TlvWriter<'_>,
_tag: Tag,
) -> Result<Option<CommandId>, StatusIb> {
Err(Status::UnsupportedCommand.into())
}
}
impl<H: PowerMeterHooks> Cluster for ElectricalPowerMeasurement<'_, H> {
const ID: ClusterId = power::ID;
}
pub trait EnergyMeterHooks {
fn accuracy(&self) -> energy::MeasurementAccuracyStruct<'_>;
fn cumulative_imported(&self) -> Option<energy::EnergyMeasurementStruct> {
None
}
fn cumulative_exported(&self) -> Option<energy::EnergyMeasurementStruct> {
None
}
fn periodic_imported(&self) -> Option<energy::EnergyMeasurementStruct> {
None
}
fn periodic_exported(&self) -> Option<energy::EnergyMeasurementStruct> {
None
}
fn cumulative_reset(&self) -> Option<energy::CumulativeEnergyResetStruct> {
None
}
}
#[derive(Debug)]
pub struct ElectricalEnergyMeasurement<'a, H: EnergyMeterHooks> {
hooks: &'a H,
}
impl<'a, H: EnergyMeterHooks> ElectricalEnergyMeasurement<'a, H> {
#[must_use]
pub const fn new(hooks: &'a H) -> Self {
Self { hooks }
}
pub fn conforming(
feature_map: u32,
optional: &Optional<'_>,
) -> crate::error::Result<Conforming<6, 0, 0, 2>> {
Conforming::new(&spec_energy::CLUSTER, feature_map, optional)
}
}
impl<H: EnergyMeterHooks> ClusterHandler for ElectricalEnergyMeasurement<'_, H> {
fn read(
&self,
resolved: &Resolved<'_>,
_ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
let full = |r: crate::error::Result<()>| r.map_err(|_| Status::ResourceExhausted);
let reading =
|w: &mut TlvWriter<'_>, value: Option<energy::EnergyMeasurementStruct>| match value {
Some(value) => full(value.to_tlv(w, tag)),
None => full(w.null(tag)),
};
match resolved.attribute {
energy::ACCURACY => full(self.hooks.accuracy().to_tlv(w, tag)),
energy::CUMULATIVE_ENERGY_IMPORTED => reading(w, self.hooks.cumulative_imported()),
energy::CUMULATIVE_ENERGY_EXPORTED => reading(w, self.hooks.cumulative_exported()),
energy::PERIODIC_ENERGY_IMPORTED => reading(w, self.hooks.periodic_imported()),
energy::PERIODIC_ENERGY_EXPORTED => reading(w, self.hooks.periodic_exported()),
energy::CUMULATIVE_ENERGY_RESET => match self.hooks.cumulative_reset() {
Some(reset) => full(reset.to_tlv(w, tag)),
None => full(w.null(tag)),
},
_ => Err(Status::UnsupportedAttribute),
}
}
fn invoke(
&self,
_resolved: &ResolvedCommand<'_>,
_fields: Option<&[u8]>,
_ctx: &InteractionContext<'_>,
_w: &mut TlvWriter<'_>,
_tag: Tag,
) -> Result<Option<CommandId>, StatusIb> {
Err(Status::UnsupportedCommand.into())
}
}
impl<H: EnergyMeterHooks> Cluster for ElectricalEnergyMeasurement<'_, H> {
const ID: ClusterId = energy::ID;
}
pub mod topology {
pub use super::spec_topology::attribute::{ACTIVE_ENDPOINTS, AVAILABLE_ENDPOINTS};
pub use super::spec_topology::{ID, PICS, REVISION, feature};
}
#[derive(Debug)]
pub struct PowerTopology<'a> {
available: &'a [crate::im::EndpointId],
active: core::cell::RefCell<&'a [crate::im::EndpointId]>,
}
impl<'a> PowerTopology<'a> {
#[must_use]
pub const fn new(available: &'a [crate::im::EndpointId]) -> Self {
Self {
available,
active: core::cell::RefCell::new(available),
}
}
pub fn conforming(
feature_map: u32,
optional: &Optional<'_>,
) -> crate::error::Result<Conforming<2, 0, 0, 0>> {
Conforming::new(&spec_topology::CLUSTER, feature_map, optional)
}
pub fn set_active(&self, active: &'a [crate::im::EndpointId]) -> Result<(), Status> {
if !active.iter().all(|id| self.available.contains(id)) {
return Err(Status::ConstraintError);
}
*self.active.borrow_mut() = active;
Ok(())
}
#[must_use]
pub fn active(&self) -> &'a [crate::im::EndpointId] {
*self.active.borrow()
}
}
impl ClusterHandler for PowerTopology<'_> {
fn read(
&self,
resolved: &Resolved<'_>,
_ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
let full = |r: crate::error::Result<()>| r.map_err(|_| Status::ResourceExhausted);
let endpoints = |w: &mut TlvWriter<'_>, ids: &[crate::im::EndpointId]| {
full(w.start_array(tag))?;
for id in ids {
full(w.unsigned(Tag::Anonymous, u64::from(*id)))?;
}
full(w.end_container())
};
match resolved.attribute {
topology::AVAILABLE_ENDPOINTS => endpoints(w, self.available),
topology::ACTIVE_ENDPOINTS => endpoints(w, self.active()),
_ => Err(Status::UnsupportedAttribute),
}
}
fn invoke(
&self,
_resolved: &ResolvedCommand<'_>,
_fields: Option<&[u8]>,
_ctx: &InteractionContext<'_>,
_w: &mut TlvWriter<'_>,
_tag: Tag,
) -> Result<Option<CommandId>, StatusIb> {
Err(Status::UnsupportedCommand.into())
}
}
impl Cluster for PowerTopology<'_> {
const ID: ClusterId = topology::ID;
}