use core::cell::Cell;
use crate::clusters::generated::energy_evse_mode as spec_mode;
use crate::dm::spec::{Conforming, Optional};
use crate::dm::{Resolved, ResolvedCommand};
use crate::im::{
ClusterHandler, ClusterId, CommandId, InteractionContext, Status, StatusIb, WriteOp,
};
use crate::tlv::{ContainerKind, Tag, TlvReader, TlvWriter, ToTlv, Value};
use super::Cluster;
pub use spec_mode::attribute::{CURRENT_MODE, ON_MODE, START_UP_MODE, SUPPORTED_MODES};
pub use spec_mode::command::{CHANGE_TO_MODE, CHANGE_TO_MODE_RESPONSE};
pub use spec_mode::{ModeOptionStruct, ModeTagStruct, feature};
pub mod status {
pub const SUCCESS: u8 = 0x00;
pub const UNSUPPORTED_MODE: u8 = 0x01;
pub const GENERIC_FAILURE: u8 = 0x02;
pub const MANUFACTURER_SPECIFIC: u8 = 0x40;
}
pub const MODES_MIN: usize = 2;
pub trait ModeHooks {
fn change_to(&self, mode: u8) -> Result<(), (u8, &'static str)>;
}
#[derive(Debug)]
pub struct Mode<'a, H: ModeHooks, const CLUSTER: ClusterId> {
spec: &'static crate::dm::spec::Cluster,
hooks: &'a H,
supported: &'a [ModeOptionStruct<'a>],
current: Cell<u8>,
start_up: Cell<Option<u8>>,
on_mode: Cell<Option<u8>>,
}
impl<'a, H: ModeHooks, const CLUSTER: ClusterId> Mode<'a, H, CLUSTER> {
pub fn new(
spec: &'static crate::dm::spec::Cluster,
hooks: &'a H,
supported: &'a [ModeOptionStruct<'a>],
current: u8,
) -> crate::error::Result<Self> {
if spec.id != CLUSTER {
return Err(crate::Error::new(crate::ErrorCode::InvalidArgument));
}
if supported.len() < MODES_MIN {
return Err(crate::Error::new(crate::ErrorCode::InvalidArgument));
}
for (index, entry) in supported.iter().enumerate() {
for other in supported.iter().skip(index.saturating_add(1)) {
if entry.mode == other.mode
|| entry.label == other.label
|| same_tags(entry, other)?
{
return Err(crate::Error::new(crate::ErrorCode::InvalidArgument));
}
}
}
if !supported.iter().any(|entry| entry.mode == current) {
return Err(crate::Error::new(crate::ErrorCode::InvalidArgument));
}
Ok(Self {
spec,
hooks,
supported,
current: Cell::new(current),
start_up: Cell::new(None),
on_mode: Cell::new(None),
})
}
pub fn conforming(
spec: &'static crate::dm::spec::Cluster,
feature_map: u32,
optional: &Optional<'_>,
) -> crate::error::Result<Conforming<4, 1, 1, 0>> {
Conforming::new(spec, feature_map, optional)
}
pub const WITH_START_UP_MODE: Optional<'static> = Optional {
attributes: &[START_UP_MODE],
commands: &[],
events: &[],
};
#[must_use]
pub const fn spec(&self) -> &'static crate::dm::spec::Cluster {
self.spec
}
#[must_use]
pub fn current(&self) -> u8 {
self.current.get()
}
#[must_use]
pub const fn supported(&self) -> &'a [ModeOptionStruct<'a>] {
self.supported
}
#[must_use]
pub fn start_up_mode(&self) -> Option<u8> {
self.start_up.get()
}
pub fn set_start_up_mode(&self, mode: Option<u8>) -> Result<(), Status> {
self.checked(mode)?;
self.start_up.set(mode);
Ok(())
}
pub fn set_on_mode(&self, mode: Option<u8>) -> Result<(), Status> {
self.checked(mode)?;
self.on_mode.set(mode);
Ok(())
}
pub fn start(&self, start_up_on_off_is_on: bool) {
let chosen = if start_up_on_off_is_on {
self.on_mode.get().or_else(|| self.start_up.get())
} else {
self.start_up.get()
};
if let Some(mode) = chosen
&& self.supported.iter().any(|entry| entry.mode == mode)
{
self.current.set(mode);
}
}
pub fn on_off_changed(&self, was_on: bool, is_on: bool) {
if was_on || !is_on {
return;
}
if let Some(mode) = self.on_mode.get()
&& self.hooks.change_to(mode).is_ok()
{
self.current.set(mode);
}
}
fn checked(&self, mode: Option<u8>) -> Result<(), Status> {
match mode {
None => Ok(()),
Some(mode) if self.supported.iter().any(|entry| entry.mode == mode) => Ok(()),
Some(_) => Err(Status::ConstraintError),
}
}
}
fn same_tags(a: &ModeOptionStruct<'_>, b: &ModeOptionStruct<'_>) -> crate::error::Result<bool> {
let contains = |list: &crate::tlv::TlvList<'_, ModeTagStruct>,
tag: &ModeTagStruct|
-> crate::error::Result<bool> {
for entry in list.iter() {
let entry = entry?;
if entry.value == tag.value && entry.mfg_code == tag.mfg_code {
return Ok(true);
}
}
Ok(false)
};
for tag in a.mode_tags.iter() {
if !contains(&b.mode_tags, &tag?)? {
return Ok(false);
}
}
for tag in b.mode_tags.iter() {
if !contains(&a.mode_tags, &tag?)? {
return Ok(false);
}
}
Ok(true)
}
impl<H: ModeHooks, const CLUSTER: ClusterId> ClusterHandler for Mode<'_, H, CLUSTER> {
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 nullable = |w: &mut TlvWriter<'_>, value: Option<u8>| match value {
Some(value) => full(w.unsigned(tag, u64::from(value))),
None => full(w.null(tag)),
};
match resolved.attribute {
SUPPORTED_MODES => {
full(w.start_array(tag))?;
for entry in self.supported {
full(entry.to_tlv(w, Tag::Anonymous))?;
}
full(w.end_container())
}
CURRENT_MODE => full(w.unsigned(tag, u64::from(self.current.get()))),
START_UP_MODE => nullable(w, self.start_up.get()),
ON_MODE => nullable(w, self.on_mode.get()),
_ => Err(Status::UnsupportedAttribute),
}
}
fn write(
&self,
resolved: &Resolved<'_>,
data: &[u8],
_op: WriteOp,
_ctx: &InteractionContext<'_>,
) -> Result<(), Status> {
let mut reader = TlvReader::new_in(data, ContainerKind::Structure);
let element = reader
.next_element()
.map_err(|_| Status::InvalidAction)?
.ok_or(Status::InvalidAction)?;
let mode = match element.value {
Value::Unsigned(value) => {
Some(u8::try_from(value).map_err(|_| Status::ConstraintError)?)
}
Value::Null => None,
_ => return Err(Status::InvalidDataType),
};
match resolved.attribute {
START_UP_MODE => self.set_start_up_mode(mode),
ON_MODE => self.set_on_mode(mode),
_ => Err(Status::UnsupportedWrite),
}
}
fn invoke(
&self,
resolved: &ResolvedCommand<'_>,
fields: Option<&[u8]>,
_ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<Option<CommandId>, StatusIb> {
if resolved.command.id != CHANGE_TO_MODE {
return Err(Status::UnsupportedCommand.into());
}
let decoded: spec_mode::ChangeToModeFields =
super::decode_fields(fields.ok_or(StatusIb::from(Status::InvalidCommand))?)?;
let (code, text) = if !self
.supported
.iter()
.any(|entry| entry.mode == decoded.new_mode)
{
(status::UNSUPPORTED_MODE, "no such mode")
} else if decoded.new_mode == self.current.get() {
(status::SUCCESS, "")
} else {
match self.hooks.change_to(decoded.new_mode) {
Ok(()) => {
self.current.set(decoded.new_mode);
(status::SUCCESS, "")
}
Err((code, text)) => (code, text),
}
};
spec_mode::ChangeToModeResponseFields {
status: code,
status_text: text,
}
.to_tlv(w, tag)
.map_err(|_| StatusIb::from(Status::ResourceExhausted))?;
Ok(Some(CHANGE_TO_MODE_RESPONSE))
}
}
impl<H: ModeHooks, const CLUSTER: ClusterId> Cluster for Mode<'_, H, CLUSTER> {
const ID: ClusterId = CLUSTER;
}