use core::cell::{Cell, RefCell};
use crate::clusters::generated::level_control as spec_level;
use crate::dm::spec::{Conforming, Optional};
use crate::dm::{Resolved, ResolvedCommand};
use crate::im::{
ClusterHandler, ClusterId, CommandId, InteractionContext, Status, StatusIb, WriteOp,
};
use crate::platform::{Duration, Instant};
use crate::tlv::{ContainerKind, Tag, TlvReader, TlvWriter, Value};
use super::Cluster;
pub use spec_level::attribute::{
CURRENT_FREQUENCY, CURRENT_LEVEL, DEFAULT_MOVE_RATE, MAX_FREQUENCY, MAX_LEVEL, MIN_FREQUENCY,
MIN_LEVEL, OFF_TRANSITION_TIME, ON_LEVEL, ON_OFF_TRANSITION_TIME, ON_TRANSITION_TIME, OPTIONS,
REMAINING_TIME, START_UP_CURRENT_LEVEL,
};
pub use spec_level::command::{
MOVE, MOVE_TO_CLOSEST_FREQUENCY, MOVE_TO_LEVEL, MOVE_TO_LEVEL_WITH_ON_OFF, MOVE_WITH_ON_OFF,
STEP, STEP_WITH_ON_OFF, STOP, STOP_WITH_ON_OFF,
};
pub use spec_level::{ID, MoveModeEnum, OptionsBitmap, PICS, REVISION, StepModeEnum, feature};
pub const TICK: Duration = Duration::from_millis(100);
pub const LIGHTING_MIN: u8 = 1;
pub const LIGHTING_MAX: u8 = 254;
const MAX_CATCH_UP: u32 = 36_000;
pub trait LevelControlHooks {
fn level(&self, level: Option<u8>);
fn frequency(&self, frequency: u16) -> bool {
let _ = frequency;
false
}
}
pub trait OnOffState {
fn present(&self) -> bool {
true
}
fn is_on(&self) -> bool;
fn set_from_level(&self, on: bool);
}
#[derive(Debug, Clone, Copy, Default)]
pub struct NoOnOff;
impl OnOffState for NoOnOff {
fn present(&self) -> bool {
false
}
fn is_on(&self) -> bool {
false
}
fn set_from_level(&self, _on: bool) {}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Motion {
Idle,
Transition {
from: u8,
to: u8,
ticks: u32,
elapsed: u32,
with_on_off: bool,
},
Move {
up: bool,
rate: u8,
fraction: u32,
with_on_off: bool,
},
}
#[derive(Debug)]
struct State {
level: Option<u8>,
motion: Motion,
next_tick: Option<Instant>,
}
#[derive(Debug)]
pub struct LevelControl<'a, H: LevelControlHooks, O: OnOffState = NoOnOff> {
hooks: &'a H,
on_off: &'a O,
feature_map: u32,
min_level: u8,
max_level: u8,
state: RefCell<State>,
options: Cell<OptionsBitmap>,
on_off_transition_time: Cell<u16>,
on_level: Cell<Option<u8>>,
on_transition_time: Cell<Option<u16>>,
off_transition_time: Cell<Option<u16>>,
default_move_rate: Cell<Option<u8>>,
start_up_current_level: Cell<Option<u8>>,
frequency: Cell<u16>,
min_frequency: u16,
max_frequency: u16,
with_on_off_pending: Cell<bool>,
}
impl<'a, H: LevelControlHooks> LevelControl<'a, H, NoOnOff> {
#[must_use]
pub fn new(hooks: &'a H, feature_map: u32) -> Self {
Self::with_on_off(hooks, &NoOnOff, feature_map)
}
}
impl<'a, H: LevelControlHooks, O: OnOffState> LevelControl<'a, H, O> {
#[must_use]
pub fn with_on_off(hooks: &'a H, on_off: &'a O, feature_map: u32) -> Self {
let (min_level, max_level) = (LIGHTING_MIN, LIGHTING_MAX);
Self {
hooks,
on_off,
feature_map,
min_level,
max_level,
state: RefCell::new(State {
level: None,
motion: Motion::Idle,
next_tick: None,
}),
options: Cell::new(OptionsBitmap::empty()),
on_off_transition_time: Cell::new(0),
on_level: Cell::new(None),
on_transition_time: Cell::new(None),
off_transition_time: Cell::new(None),
default_move_rate: Cell::new(None),
start_up_current_level: Cell::new(None),
frequency: Cell::new(0),
min_frequency: 0,
max_frequency: 0,
with_on_off_pending: Cell::new(false),
}
}
#[must_use]
pub fn with_range(mut self, min_level: u8, max_level: u8) -> Self {
if self.feature_map & feature::LIGHTING == 0 && min_level <= max_level {
self.min_level = min_level;
self.max_level = max_level;
}
self
}
#[must_use]
pub const fn with_frequency(mut self, min: u16, max: u16) -> Self {
self.min_frequency = min;
self.max_frequency = max;
self
}
pub fn conforming(
feature_map: u32,
optional: &Optional<'_>,
) -> crate::error::Result<Conforming<14, 9, 0, 0>> {
Conforming::new(&spec_level::CLUSTER, feature_map, optional)
}
pub const WITH_ALL_OPTIONAL: Optional<'static> = Optional {
attributes: &[
MIN_LEVEL,
MAX_LEVEL,
ON_OFF_TRANSITION_TIME,
ON_TRANSITION_TIME,
OFF_TRANSITION_TIME,
DEFAULT_MOVE_RATE,
],
commands: &[],
events: &[],
};
pub const WITH_RANGE: Optional<'static> = Optional {
attributes: &[MIN_LEVEL, MAX_LEVEL],
commands: &[],
events: &[],
};
pub fn start(&self, previous: Option<u8>) {
let level = match self.start_up_current_level.get() {
Some(0) => Some(self.min_level),
Some(other) => Some(other.clamp(self.min_level, self.max_level)),
None => previous.map(|level| level.clamp(self.min_level, self.max_level)),
};
self.state.borrow_mut().level = level;
self.hooks.level(level);
}
#[must_use]
pub fn level(&self) -> Option<u8> {
self.state.borrow().level
}
#[must_use]
pub fn remaining_time(&self) -> u16 {
match self.state.borrow().motion {
Motion::Idle => 0,
Motion::Transition { ticks, elapsed, .. } => {
u16::try_from(ticks.saturating_sub(elapsed)).unwrap_or(u16::MAX)
}
Motion::Move { up, rate, .. } => {
let level = self.state.borrow().level.unwrap_or(self.min_level);
let distance = if up {
u32::from(self.max_level.saturating_sub(level))
} else {
u32::from(level.saturating_sub(self.min_level))
};
let rate = u32::from(rate);
let Some(tenths) = distance
.saturating_mul(10)
.saturating_add(rate.saturating_sub(1))
.checked_div(rate)
else {
return 0;
};
u16::try_from(tenths).unwrap_or(u16::MAX)
}
}
}
#[must_use]
pub const fn min_level(&self) -> u8 {
self.min_level
}
#[must_use]
pub const fn max_level(&self) -> u8 {
self.max_level
}
#[must_use]
pub fn options(&self) -> OptionsBitmap {
self.options.get()
}
#[must_use]
pub fn on_level(&self) -> Option<u8> {
self.on_level.get()
}
pub fn set_on_level(&self, level: Option<u8>) {
self.on_level.set(level);
}
pub fn set_start_up_level(&self, level: Option<u8>) {
self.start_up_current_level.set(level);
}
#[must_use]
pub fn wake_at(&self) -> Option<Instant> {
self.state.borrow().next_tick
}
pub fn poll(&self, now: Instant) {
let (level, finished) = {
let mut state = self.state.borrow_mut();
let Some(mut due) = state.next_tick else {
return;
};
if now < due {
return;
}
let mut ticks = 0u32;
while now >= due && ticks < MAX_CATCH_UP && state.motion != Motion::Idle {
ticks = ticks.saturating_add(1);
due = due.saturating_add(TICK);
self.advance(&mut state);
}
let finished = state.motion == Motion::Idle;
state.next_tick = if finished { None } else { Some(due) };
(state.level, finished)
};
self.hooks.level(level);
if finished {
self.settle(level);
}
}
fn advance(&self, state: &mut State) {
match &mut state.motion {
Motion::Idle => {}
Motion::Transition {
from,
to,
ticks,
elapsed,
..
} => {
*elapsed = elapsed.saturating_add(1);
if *elapsed >= *ticks {
state.level = Some(*to);
state.motion = Motion::Idle;
} else {
let span = i32::from(*to).saturating_sub(i32::from(*from));
let moved = span
.saturating_mul(i32::try_from(*elapsed).unwrap_or(i32::MAX))
.checked_div(i32::try_from(*ticks).unwrap_or(1))
.unwrap_or(span);
let next = i32::from(*from).saturating_add(moved);
state.level = Some(u8::try_from(next.clamp(0, 255)).unwrap_or(*to));
}
}
Motion::Move {
up, rate, fraction, ..
} => {
*fraction = fraction.saturating_add(u32::from(*rate));
let whole = *fraction / 10;
*fraction %= 10;
let level = state.level.unwrap_or(self.min_level);
let next = if *up {
u32::from(level)
.saturating_add(whole)
.min(u32::from(self.max_level))
} else {
u32::from(level)
.saturating_sub(whole)
.max(u32::from(self.min_level))
};
let next = u8::try_from(next).unwrap_or(level);
state.level = Some(next);
if (*up && next >= self.max_level) || (!*up && next <= self.min_level) {
state.motion = Motion::Idle;
}
}
}
}
fn settle(&self, level: Option<u8>) {
if !self.with_on_off_pending.get() {
return;
}
self.with_on_off_pending.set(false);
if level == Some(self.min_level) {
self.on_off.set_from_level(false);
}
}
}
impl<H: LevelControlHooks, O: OnOffState> LevelControl<'_, H, O> {
fn effective(&self, mask: OptionsBitmap, override_bits: OptionsBitmap) -> OptionsBitmap {
(self.options.get() & !mask) | (override_bits & mask)
}
fn blocked(&self, options: OptionsBitmap) -> bool {
self.on_off.present()
&& !self.on_off.is_on()
&& !options.contains(OptionsBitmap::EXECUTE_IF_OFF)
}
fn transition_ticks(&self, requested: crate::tlv::Nullable<u16>) -> u32 {
match requested.0 {
Some(tenths) => u32::from(tenths),
None => u32::from(self.on_off_transition_time.get()),
}
}
fn begin_transition(&self, target: u8, ticks: u32, with_on_off: bool, now: Instant) {
let target = target.clamp(self.min_level, self.max_level);
if with_on_off && target > self.min_level {
self.on_off.set_from_level(true);
}
let level = {
let mut state = self.state.borrow_mut();
let from = state.level.unwrap_or(self.min_level);
if ticks == 0 || from == target {
state.level = Some(target);
state.motion = Motion::Idle;
state.next_tick = None;
} else {
state.motion = Motion::Transition {
from,
to: target,
ticks,
elapsed: 0,
with_on_off,
};
state.next_tick = Some(now.saturating_add(TICK));
}
state.level
};
self.with_on_off_pending.set(with_on_off);
self.hooks.level(level);
if self.state.borrow().motion == Motion::Idle {
self.settle(level);
}
}
fn begin_move(&self, up: bool, rate: u8, with_on_off: bool, now: Instant) {
if with_on_off && up {
self.on_off.set_from_level(true);
}
if rate == 0 {
let target = if up { self.max_level } else { self.min_level };
self.begin_transition(target, 0, with_on_off, now);
return;
}
{
let mut state = self.state.borrow_mut();
state.motion = Motion::Move {
up,
rate,
fraction: 0,
with_on_off,
};
state.next_tick = Some(now.saturating_add(TICK));
}
self.with_on_off_pending.set(with_on_off);
}
fn stop(&self) {
let level = {
let mut state = self.state.borrow_mut();
state.motion = Motion::Idle;
state.next_tick = None;
state.level
};
self.with_on_off_pending.set(false);
let _ = level;
}
pub fn on_off_changed(&self, on: bool, stored: Option<u8>, now: Instant) {
let ticks = if on {
u32::from(
self.on_transition_time
.get()
.unwrap_or_else(|| self.on_off_transition_time.get()),
)
} else {
u32::from(
self.off_transition_time
.get()
.unwrap_or_else(|| self.on_off_transition_time.get()),
)
};
if on {
let target = self.on_level.get().or(stored).unwrap_or(self.max_level);
self.state.borrow_mut().level = Some(self.min_level);
self.begin_transition(target, ticks, false, now);
} else {
self.begin_transition(self.min_level, ticks, false, now);
}
}
}
impl<H: LevelControlHooks, O: OnOffState> ClusterHandler for LevelControl<'_, H, O> {
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<u16>| match value {
Some(value) => full(w.unsigned(tag, u64::from(value))),
None => full(w.null(tag)),
};
match resolved.attribute {
CURRENT_LEVEL => match self.level() {
Some(level) => full(w.unsigned(tag, u64::from(level))),
None => full(w.null(tag)),
},
REMAINING_TIME => full(w.unsigned(tag, u64::from(self.remaining_time()))),
MIN_LEVEL => full(w.unsigned(tag, u64::from(self.min_level))),
MAX_LEVEL => full(w.unsigned(tag, u64::from(self.max_level))),
OPTIONS => full(w.unsigned(tag, u64::from(self.options.get().bits()))),
ON_OFF_TRANSITION_TIME => {
full(w.unsigned(tag, u64::from(self.on_off_transition_time.get())))
}
ON_LEVEL => match self.on_level.get() {
Some(level) => full(w.unsigned(tag, u64::from(level))),
None => full(w.null(tag)),
},
ON_TRANSITION_TIME => nullable(w, self.on_transition_time.get()),
OFF_TRANSITION_TIME => nullable(w, self.off_transition_time.get()),
DEFAULT_MOVE_RATE => match self.default_move_rate.get() {
Some(rate) => full(w.unsigned(tag, u64::from(rate))),
None => full(w.null(tag)),
},
START_UP_CURRENT_LEVEL => match self.start_up_current_level.get() {
Some(level) => full(w.unsigned(tag, u64::from(level))),
None => full(w.null(tag)),
},
CURRENT_FREQUENCY => full(w.unsigned(tag, u64::from(self.frequency.get()))),
MIN_FREQUENCY => full(w.unsigned(tag, u64::from(self.min_frequency))),
MAX_FREQUENCY => full(w.unsigned(tag, u64::from(self.max_frequency))),
_ => 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 number = |value: &Value<'_>| -> Result<Option<u64>, Status> {
match value {
Value::Unsigned(value) => Ok(Some(*value)),
Value::Null => Ok(None),
_ => Err(Status::InvalidDataType),
}
};
let byte = |value: &Value<'_>| -> Result<Option<u8>, Status> {
match number(value)? {
Some(value) => Ok(Some(
u8::try_from(value).map_err(|_| Status::ConstraintError)?,
)),
None => Ok(None),
}
};
let short = |value: &Value<'_>| -> Result<Option<u16>, Status> {
match number(value)? {
Some(value) => Ok(Some(
u16::try_from(value).map_err(|_| Status::ConstraintError)?,
)),
None => Ok(None),
}
};
match resolved.attribute {
OPTIONS => {
let bits = byte(&element.value)?.ok_or(Status::InvalidDataType)?;
let options = OptionsBitmap::from_bits(bits).ok_or(Status::ConstraintError)?;
self.options.set(options);
Ok(())
}
ON_OFF_TRANSITION_TIME => {
self.on_off_transition_time
.set(short(&element.value)?.ok_or(Status::InvalidDataType)?);
Ok(())
}
ON_LEVEL => {
let level = byte(&element.value)?;
if let Some(level) = level
&& (level < self.min_level || level > self.max_level)
{
return Err(Status::ConstraintError);
}
self.on_level.set(level);
Ok(())
}
ON_TRANSITION_TIME => {
self.on_transition_time.set(short(&element.value)?);
Ok(())
}
OFF_TRANSITION_TIME => {
self.off_transition_time.set(short(&element.value)?);
Ok(())
}
DEFAULT_MOVE_RATE => {
let rate = byte(&element.value)?;
if rate == Some(0) {
return Err(Status::ConstraintError);
}
self.default_move_rate.set(rate);
Ok(())
}
START_UP_CURRENT_LEVEL => {
self.start_up_current_level.set(byte(&element.value)?);
Ok(())
}
_ => Err(Status::UnsupportedWrite),
}
}
fn invoke(
&self,
resolved: &ResolvedCommand<'_>,
fields: Option<&[u8]>,
ctx: &InteractionContext<'_>,
_w: &mut TlvWriter<'_>,
_tag: Tag,
) -> Result<Option<CommandId>, StatusIb> {
let payload = || fields.ok_or(StatusIb::from(Status::InvalidCommand));
let id = resolved.command.id;
let with_on_off = matches!(
id,
MOVE_TO_LEVEL_WITH_ON_OFF | MOVE_WITH_ON_OFF | STEP_WITH_ON_OFF | STOP_WITH_ON_OFF
);
match id {
MOVE_TO_LEVEL | MOVE_TO_LEVEL_WITH_ON_OFF => {
let decoded: spec_level::MoveToLevelFields = super::decode_fields(payload()?)?;
let options = self.effective(decoded.options_mask, decoded.options_override);
if !with_on_off && self.blocked(options) {
return Ok(None);
}
let ticks = self.transition_ticks(decoded.transition_time);
self.begin_transition(decoded.level, ticks, with_on_off, ctx.now);
Ok(None)
}
MOVE | MOVE_WITH_ON_OFF => {
let decoded: spec_level::MoveFields = super::decode_fields(payload()?)?;
if decoded.rate.0 == Some(0) {
return Err(Status::InvalidCommand.into());
}
let options = self.effective(decoded.options_mask, decoded.options_override);
if !with_on_off && self.blocked(options) {
return Ok(None);
}
let rate = decoded
.rate
.0
.or_else(|| self.default_move_rate.get())
.unwrap_or(0);
self.begin_move(
decoded.move_mode == MoveModeEnum::Up,
rate,
with_on_off,
ctx.now,
);
Ok(None)
}
STEP | STEP_WITH_ON_OFF => {
let decoded: spec_level::StepFields = super::decode_fields(payload()?)?;
if decoded.step_size == 0 {
return Err(Status::InvalidCommand.into());
}
let options = self.effective(decoded.options_mask, decoded.options_override);
if !with_on_off && self.blocked(options) {
return Ok(None);
}
let from = self.state.borrow().level.unwrap_or(self.min_level);
let up = decoded.step_mode == StepModeEnum::Up;
let unclipped = if up {
u32::from(from).saturating_add(u32::from(decoded.step_size))
} else {
u32::from(from).saturating_sub(u32::from(decoded.step_size))
};
let target = u8::try_from(unclipped.min(u32::from(self.max_level)))
.unwrap_or(self.max_level)
.clamp(self.min_level, self.max_level);
let requested = self.transition_ticks(decoded.transition_time);
let actual = u32::from(from.abs_diff(target));
let ticks = if decoded.step_size == 0 {
0
} else {
requested
.saturating_mul(actual)
.checked_div(u32::from(decoded.step_size))
.unwrap_or(requested)
};
self.begin_transition(target, ticks, with_on_off, ctx.now);
Ok(None)
}
STOP | STOP_WITH_ON_OFF => {
let decoded: spec_level::StopFields = super::decode_fields(payload()?)?;
let options = self.effective(decoded.options_mask, decoded.options_override);
if !with_on_off && self.blocked(options) {
return Ok(None);
}
self.stop();
Ok(None)
}
MOVE_TO_CLOSEST_FREQUENCY => {
let decoded: spec_level::MoveToClosestFrequencyFields =
super::decode_fields(payload()?)?;
if self.hooks.frequency(decoded.frequency) {
self.frequency.set(decoded.frequency);
Ok(None)
} else {
Err(Status::ConstraintError.into())
}
}
_ => Err(Status::UnsupportedCommand.into()),
}
}
}
impl<H: LevelControlHooks, O: OnOffState> Cluster for LevelControl<'_, H, O> {
const ID: ClusterId = ID;
}