139 lines
3.7 KiB
Rust
139 lines
3.7 KiB
Rust
#[cfg(feature = "serde")]
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
/// Generic trait for a device capable of switching itself on or off.
|
|
pub trait PowerSwitch {
|
|
type Error;
|
|
|
|
fn switch_on(&mut self) -> Result<(), Self::Error>;
|
|
fn switch_off(&mut self) -> Result<(), Self::Error>;
|
|
|
|
fn is_switch_on(&self) -> bool {
|
|
self.switch_state() == SwitchState::On
|
|
}
|
|
|
|
fn switch_state(&self) -> SwitchState;
|
|
}
|
|
|
|
#[derive(Debug, Eq, PartialEq, Copy, Clone)]
|
|
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
|
pub enum SwitchState {
|
|
Off = 0,
|
|
On = 1,
|
|
Unknown = 2,
|
|
Faulty = 3,
|
|
}
|
|
|
|
#[derive(Debug, Eq, PartialEq, Copy, Clone)]
|
|
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
|
|
pub enum SwitchStateBinary {
|
|
Off = 0,
|
|
On = 1,
|
|
}
|
|
|
|
impl TryFrom<SwitchState> for SwitchStateBinary {
|
|
type Error = ();
|
|
fn try_from(value: SwitchState) -> Result<Self, Self::Error> {
|
|
match value {
|
|
SwitchState::Off => Ok(SwitchStateBinary::Off),
|
|
SwitchState::On => Ok(SwitchStateBinary::On),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: Into<u64>> From<T> for SwitchStateBinary {
|
|
fn from(value: T) -> Self {
|
|
if value.into() == 0 {
|
|
return SwitchStateBinary::Off;
|
|
}
|
|
SwitchStateBinary::On
|
|
}
|
|
}
|
|
|
|
impl From<SwitchStateBinary> for SwitchState {
|
|
fn from(value: SwitchStateBinary) -> Self {
|
|
match value {
|
|
SwitchStateBinary::Off => SwitchState::Off,
|
|
SwitchStateBinary::On => SwitchState::On,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub type SwitchId = u16;
|
|
|
|
/// Generic trait for a device capable of turning on and off switches.
|
|
pub trait PowerSwitcherCommandSender {
|
|
type Error;
|
|
|
|
fn send_switch_on_cmd(&mut self, switch_id: SwitchId) -> Result<(), Self::Error>;
|
|
fn send_switch_off_cmd(&mut self, switch_id: SwitchId) -> Result<(), Self::Error>;
|
|
}
|
|
|
|
pub trait PowerSwitchInfo {
|
|
type Error;
|
|
|
|
/// Retrieve the switch state
|
|
fn get_switch_state(&mut self, switch_id: SwitchId) -> Result<SwitchState, Self::Error>;
|
|
|
|
fn get_is_switch_on(&mut self, switch_id: SwitchId) -> Result<bool, Self::Error> {
|
|
Ok(self.get_switch_state(switch_id)? == SwitchState::On)
|
|
}
|
|
|
|
/// The maximum delay it will take to change a switch.
|
|
///
|
|
/// This may take into account the time to send a command, wait for it to be executed, and
|
|
/// see the switch changed.
|
|
fn switch_delay_ms(&self) -> u32;
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
#![allow(dead_code)]
|
|
use super::*;
|
|
use std::boxed::Box;
|
|
|
|
struct Pcdu {
|
|
switch_rx: std::sync::mpsc::Receiver<(SwitchId, u16)>,
|
|
}
|
|
|
|
#[derive(Eq, PartialEq)]
|
|
enum DeviceState {
|
|
OFF,
|
|
SwitchingPower,
|
|
ON,
|
|
SETUP,
|
|
IDLE,
|
|
}
|
|
struct MyComplexDevice {
|
|
power_switcher: Box<dyn PowerSwitcherCommandSender<Error = ()>>,
|
|
power_info: Box<dyn PowerSwitchInfo<Error = ()>>,
|
|
switch_id: SwitchId,
|
|
some_state: u16,
|
|
dev_state: DeviceState,
|
|
mode: u32,
|
|
submode: u16,
|
|
}
|
|
|
|
impl MyComplexDevice {
|
|
pub fn periodic_op(&mut self) {
|
|
// .. mode command coming in
|
|
let mode = 1;
|
|
if mode == 1 {
|
|
if self.dev_state == DeviceState::OFF {
|
|
self.power_switcher
|
|
.send_switch_on_cmd(self.switch_id)
|
|
.expect("sending siwthc cmd failed");
|
|
self.dev_state = DeviceState::SwitchingPower;
|
|
}
|
|
if self.dev_state == DeviceState::SwitchingPower {
|
|
if self.power_info.get_is_switch_on(0).unwrap() {
|
|
self.dev_state = DeviceState::ON;
|
|
self.mode = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|