use core::cell::{Cell, RefCell};
use crate::clusters::generated::energy_evse as spec_evse;
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 use spec_evse::attribute::{
APPROXIMATE_EV_EFFICIENCY, BATTERY_CAPACITY, CHARGING_ENABLED_UNTIL, CIRCUIT_CAPACITY,
DISCHARGING_ENABLED_UNTIL, FAULT_STATE, MAXIMUM_CHARGE_CURRENT, MAXIMUM_DISCHARGE_CURRENT,
MINIMUM_CHARGE_CURRENT, NEXT_CHARGE_REQUIRED_ENERGY, NEXT_CHARGE_START_TIME,
NEXT_CHARGE_TARGET_SO_C, NEXT_CHARGE_TARGET_TIME, RANDOMIZATION_DELAY_WINDOW, SESSION_DURATION,
SESSION_ENERGY_CHARGED, SESSION_ENERGY_DISCHARGED, SESSION_ID, STATE, STATE_OF_CHARGE,
SUPPLY_STATE, USER_MAXIMUM_CHARGE_CURRENT, VEHICLE_ID,
};
pub use spec_evse::command::{
CLEAR_TARGETS, DISABLE, ENABLE_CHARGING, ENABLE_DISCHARGING, GET_TARGETS, GET_TARGETS_RESPONSE,
SET_TARGETS, START_DIAGNOSTICS,
};
pub use spec_evse::event::{
ENERGY_TRANSFER_STARTED, ENERGY_TRANSFER_STOPPED, EV_CONNECTED, EV_NOT_DETECTED, FAULT, RFID,
};
pub use spec_evse::{
ChargingTargetScheduleStruct, ChargingTargetStruct, EnergyTransferStoppedReasonEnum,
FaultStateEnum, ID, PICS, REVISION, StateEnum, SupplyStateEnum, TargetDayOfWeekBitmap, feature,
};
pub const SCHEDULES_MAX: usize = 7;
pub const MINUTES_MAX: u16 = 1439;
const DAYS: [TargetDayOfWeekBitmap; 7] = [
TargetDayOfWeekBitmap::SUNDAY,
TargetDayOfWeekBitmap::MONDAY,
TargetDayOfWeekBitmap::TUESDAY,
TargetDayOfWeekBitmap::WEDNESDAY,
TargetDayOfWeekBitmap::THURSDAY,
TargetDayOfWeekBitmap::FRIDAY,
TargetDayOfWeekBitmap::SATURDAY,
];
pub trait EvseHooks {
fn state(&self) -> Option<StateEnum>;
fn fault(&self) -> FaultStateEnum {
FaultStateEnum::NoError
}
fn utc(&self) -> Option<u32> {
None
}
fn circuit_capacity(&self) -> i64;
fn user_maximum_charge_current(&self) -> i64 {
0
}
fn randomization_delay_window(&self) -> u32 {
0
}
fn session_id(&self) -> Option<u32>;
fn session_duration(&self) -> Option<u32>;
fn session_energy_charged(&self) -> Option<i64>;
fn session_energy_discharged(&self) -> Option<i64> {
None
}
fn state_of_charge(&self) -> Option<u8> {
None
}
fn battery_capacity(&self) -> Option<i64> {
None
}
fn vehicle_id(&self) -> Option<&str> {
None
}
fn next_charge(&self) -> NextCharge {
NextCharge::default()
}
fn approximate_ev_efficiency(&self) -> Option<u16> {
None
}
fn disable(&self) -> bool {
true
}
fn enable_charging(&self, minimum_ma: i64, maximum_ma: i64) -> bool;
fn enable_discharging(&self, maximum_ma: i64) -> bool {
let _ = maximum_ma;
false
}
fn start_diagnostics(&self) -> bool {
false
}
fn targets_changed(&self) {}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct NextCharge {
pub start_time: Option<u32>,
pub target_time: Option<u32>,
pub required_energy: Option<i64>,
pub target_soc: Option<u8>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Event {
EvConnected(u32),
EvNotDetected,
EnergyTransferStarted,
EnergyTransferStopped(EnergyTransferStoppedReasonEnum),
Fault(FaultStateEnum),
}
type DayTargets<const T: usize> = heapless::Vec<ChargingTargetStruct, T>;
#[derive(Debug)]
pub struct EnergyEvse<'a, H: EvseHooks, const T: usize = 10> {
hooks: &'a H,
feature_map: u32,
supply: Cell<SupplyStateEnum>,
charging_until: Cell<Option<u32>>,
discharging_until: Cell<Option<u32>>,
minimum_charge_current: Cell<i64>,
maximum_charge_current: Cell<i64>,
maximum_discharge_current: Cell<i64>,
targets: RefCell<[DayTargets<T>; 7]>,
events: RefCell<heapless::Vec<Event, 8>>,
}
impl<'a, H: EvseHooks, const T: usize> EnergyEvse<'a, H, T> {
#[must_use]
pub fn new(hooks: &'a H, feature_map: u32) -> Self {
Self {
hooks,
feature_map,
supply: Cell::new(SupplyStateEnum::Disabled),
charging_until: Cell::new(Some(0)),
discharging_until: Cell::new(Some(0)),
minimum_charge_current: Cell::new(0),
maximum_charge_current: Cell::new(0),
maximum_discharge_current: Cell::new(0),
targets: RefCell::new(core::array::from_fn(|_| heapless::Vec::new())),
events: RefCell::new(heapless::Vec::new()),
}
}
pub fn conforming(
feature_map: u32,
optional: &Optional<'_>,
) -> crate::error::Result<Conforming<23, 8, 1, 6>> {
Conforming::new(&spec_evse::CLUSTER, feature_map, optional)
}
pub const WITH_ALL_OPTIONAL: Optional<'static> = Optional {
attributes: &[USER_MAXIMUM_CHARGE_CURRENT, RANDOMIZATION_DELAY_WINDOW],
commands: &[START_DIAGNOSTICS],
events: &[],
};
pub fn start(&self, charging_until: Option<u32>, discharging_until: Option<u32>) {
self.charging_until.set(charging_until);
self.discharging_until.set(discharging_until);
self.resupply();
}
#[must_use]
pub fn supply_state(&self) -> SupplyStateEnum {
if self.hooks.fault() != FaultStateEnum::NoError {
return SupplyStateEnum::DisabledError;
}
self.supply.get()
}
#[must_use]
pub fn charging_enabled_until(&self) -> Option<u32> {
self.charging_until.get()
}
#[must_use]
pub fn discharging_enabled_until(&self) -> Option<u32> {
self.discharging_until.get()
}
#[must_use]
pub fn maximum_charge_current(&self) -> i64 {
let user = self.hooks.user_maximum_charge_current();
let commanded = self.maximum_charge_current.get();
if user > 0 {
user.min(commanded)
} else {
commanded
}
}
#[must_use]
pub fn transferring(&self) -> bool {
matches!(
self.hooks.state(),
Some(StateEnum::PluggedInCharging | StateEnum::PluggedInDischarging)
)
}
#[must_use]
pub fn targets_for(
&self,
day: TargetDayOfWeekBitmap,
) -> heapless::Vec<ChargingTargetStruct, T> {
let index = DAYS.iter().position(|d| *d == day);
match index.and_then(|index| self.targets.borrow().get(index).cloned()) {
Some(targets) => targets,
None => heapless::Vec::new(),
}
}
pub fn diagnostics_complete(&self) {
if self.supply.get() == SupplyStateEnum::DisabledDiagnostics {
self.supply.set(SupplyStateEnum::Disabled);
}
}
pub fn poll(&self) {
let before = self.supply.get();
self.resupply();
if before != self.supply.get() && self.transferring() {
self.record(Event::EnergyTransferStopped(
EnergyTransferStoppedReasonEnum::EVSEStopped,
));
}
}
fn resupply(&self) {
if matches!(
self.supply.get(),
SupplyStateEnum::DisabledDiagnostics | SupplyStateEnum::DisabledError
) {
return;
}
let charging = self.window_open(self.charging_until.get());
let discharging = self.window_open(self.discharging_until.get()) && self.has(feature::V2_X);
self.supply.set(match (charging, discharging) {
(true, true) => SupplyStateEnum::Enabled,
(true, false) => SupplyStateEnum::ChargingEnabled,
(false, true) => SupplyStateEnum::DischargingEnabled,
(false, false) => SupplyStateEnum::Disabled,
});
}
fn window_open(&self, until: Option<u32>) -> bool {
match until {
None => true,
Some(0) => false,
Some(until) => match self.hooks.utc() {
Some(now) => until > now,
None => true,
},
}
}
const fn has(&self, bit: u32) -> bool {
self.feature_map & bit != 0
}
pub fn record(&self, event: Event) {
let mut events = self.events.borrow_mut();
if events.is_full() {
events.remove(0);
}
let _ = events.push(event);
}
pub fn take_events(&self) -> heapless::Vec<Event, 8> {
core::mem::take(&mut self.events.borrow_mut())
}
fn refuses_commands(&self) -> bool {
self.hooks.fault() != FaultStateEnum::NoError
|| self.supply.get() == SupplyStateEnum::DisabledDiagnostics
}
fn set_targets(
&self,
schedules: crate::tlv::TlvList<'_, ChargingTargetScheduleStruct<'_>>,
) -> Status {
let mut seen = TargetDayOfWeekBitmap::empty();
let mut staged: [Option<DayTargets<T>>; 7] = core::array::from_fn(|_| None);
let mut count = 0usize;
for schedule in schedules.iter() {
let Ok(schedule) = schedule else {
return Status::ConstraintError;
};
count = count.saturating_add(1);
if count > SCHEDULES_MAX {
return Status::ConstraintError;
}
if schedule.day_of_week_for_sequence.intersects(seen) {
return Status::ConstraintError;
}
seen |= schedule.day_of_week_for_sequence;
let mut targets: DayTargets<T> = heapless::Vec::new();
for target in schedule.charging_targets.iter() {
let Ok(target) = target else {
return Status::ConstraintError;
};
if target.target_time_minutes_past_midnight > MINUTES_MAX
|| target.target_so_c.is_some_and(|soc| soc > 100)
|| target.added_energy.is_some_and(|energy| energy < 0)
{
return Status::ConstraintError;
}
if targets.push(target).is_err() {
return Status::ResourceExhausted;
}
}
for (index, day) in DAYS.iter().enumerate() {
if schedule.day_of_week_for_sequence.contains(*day)
&& let Some(slot) = staged.get_mut(index)
{
*slot = Some(targets.clone());
}
}
}
let mut stored = self.targets.borrow_mut();
for (index, staged) in staged.into_iter().enumerate() {
if let (Some(staged), Some(slot)) = (staged, stored.get_mut(index)) {
*slot = staged;
}
}
drop(stored);
self.hooks.targets_changed();
Status::Success
}
}
impl<H: EvseHooks, const T: usize> ClusterHandler for EnergyEvse<'_, H, T> {
#[allow(clippy::too_many_lines)]
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 epoch = |w: &mut TlvWriter<'_>, value: Option<u32>| match value {
Some(value) => full(w.unsigned(tag, u64::from(value))),
None => full(w.null(tag)),
};
let energy = |w: &mut TlvWriter<'_>, value: Option<i64>| match value {
Some(value) => full(w.signed(tag, value)),
None => full(w.null(tag)),
};
let next = self.hooks.next_charge();
match resolved.attribute {
STATE => match self.hooks.state() {
Some(state) => full(w.unsigned(tag, u64::from(state.value()))),
None => full(w.null(tag)),
},
SUPPLY_STATE => full(w.unsigned(tag, u64::from(self.supply_state().value()))),
FAULT_STATE => full(w.unsigned(tag, u64::from(self.hooks.fault().value()))),
CHARGING_ENABLED_UNTIL => epoch(w, self.charging_until.get()),
DISCHARGING_ENABLED_UNTIL => epoch(w, self.discharging_until.get()),
CIRCUIT_CAPACITY => full(w.signed(tag, self.hooks.circuit_capacity())),
MINIMUM_CHARGE_CURRENT => full(w.signed(tag, self.minimum_charge_current.get())),
MAXIMUM_CHARGE_CURRENT => full(w.signed(tag, self.maximum_charge_current())),
MAXIMUM_DISCHARGE_CURRENT => full(w.signed(tag, self.maximum_discharge_current.get())),
USER_MAXIMUM_CHARGE_CURRENT => {
full(w.signed(tag, self.hooks.user_maximum_charge_current()))
}
RANDOMIZATION_DELAY_WINDOW => {
full(w.unsigned(tag, u64::from(self.hooks.randomization_delay_window())))
}
NEXT_CHARGE_START_TIME => epoch(w, next.start_time),
NEXT_CHARGE_TARGET_TIME => epoch(w, next.target_time),
NEXT_CHARGE_REQUIRED_ENERGY => energy(w, next.required_energy),
NEXT_CHARGE_TARGET_SO_C => match next.target_soc {
Some(soc) => full(w.unsigned(tag, u64::from(soc))),
None => full(w.null(tag)),
},
APPROXIMATE_EV_EFFICIENCY => match self.hooks.approximate_ev_efficiency() {
Some(value) => full(w.unsigned(tag, u64::from(value))),
None => full(w.null(tag)),
},
STATE_OF_CHARGE => match self.hooks.state_of_charge() {
Some(soc) => full(w.unsigned(tag, u64::from(soc))),
None => full(w.null(tag)),
},
BATTERY_CAPACITY => energy(w, self.hooks.battery_capacity()),
VEHICLE_ID => match self.hooks.vehicle_id() {
Some(id) => full(w.utf8(tag, id)),
None => full(w.null(tag)),
},
SESSION_ID => epoch(w, self.hooks.session_id()),
SESSION_DURATION => epoch(w, self.hooks.session_duration()),
SESSION_ENERGY_CHARGED => energy(w, self.hooks.session_energy_charged()),
SESSION_ENERGY_DISCHARGED => energy(w, self.hooks.session_energy_discharged()),
_ => Err(Status::UnsupportedAttribute),
}
}
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));
match resolved.command.id {
DISABLE => {
let transferring = self.transferring();
if !self.hooks.disable() {
return Err(Status::Failure.into());
}
self.charging_until.set(Some(0));
self.discharging_until.set(Some(0));
if self.supply.get() != SupplyStateEnum::DisabledDiagnostics {
self.supply.set(SupplyStateEnum::Disabled);
}
if transferring {
self.record(Event::EnergyTransferStopped(
EnergyTransferStoppedReasonEnum::EVSEStopped,
));
}
Ok(None)
}
ENABLE_CHARGING => {
let decoded: spec_evse::EnableChargingFields = super::decode_fields(payload()?)?;
if self.refuses_commands() {
return Err(Status::Failure.into());
}
if decoded.minimum_charge_current < 0
|| decoded.maximum_charge_current < 0
|| decoded.minimum_charge_current > decoded.maximum_charge_current
{
return Err(Status::ConstraintError.into());
}
let minimum = i64::from(decoded.minimum_charge_current);
let maximum = i64::from(decoded.maximum_charge_current);
if !self.hooks.enable_charging(minimum, maximum) {
return Err(Status::Failure.into());
}
self.minimum_charge_current.set(minimum);
self.maximum_charge_current.set(maximum);
self.charging_until.set(decoded.charging_enabled_until.0);
self.resupply();
Ok(None)
}
ENABLE_DISCHARGING => {
let decoded: spec_evse::EnableDischargingFields = super::decode_fields(payload()?)?;
if self.refuses_commands() {
return Err(Status::Failure.into());
}
if decoded.maximum_discharge_current < 0 {
return Err(Status::ConstraintError.into());
}
let maximum = i64::from(decoded.maximum_discharge_current);
if !self.hooks.enable_discharging(maximum) {
return Err(Status::Failure.into());
}
self.maximum_discharge_current.set(maximum);
self.discharging_until
.set(decoded.discharging_enabled_until.0);
self.resupply();
Ok(None)
}
START_DIAGNOSTICS => {
if self.supply_state() != SupplyStateEnum::Disabled
|| !self.hooks.start_diagnostics()
{
return Err(Status::Failure.into());
}
self.supply.set(SupplyStateEnum::DisabledDiagnostics);
Ok(None)
}
SET_TARGETS => {
let decoded: spec_evse::SetTargetsFields<'_> = super::decode_fields(payload()?)?;
match self.set_targets(decoded.charging_target_schedules) {
Status::Success => Ok(None),
other => Err(other.into()),
}
}
GET_TARGETS => {
let full =
|r: crate::error::Result<()>| r.map_err(|_| StatusIb::from(Status::Failure));
let targets = self.targets.borrow();
full(w.start_structure(tag))?;
full(w.start_array(Tag::Context(0)))?;
for (index, day) in DAYS.iter().enumerate() {
let Some(day_targets) = targets.get(index) else {
continue;
};
if day_targets.is_empty() {
continue;
}
full(w.start_structure(Tag::Anonymous))?;
full(w.unsigned(Tag::Context(0), u64::from(day.bits())))?;
full(w.start_array(Tag::Context(1)))?;
for target in day_targets {
full(target.to_tlv(w, Tag::Anonymous))?;
}
full(w.end_container())?;
full(w.end_container())?;
}
full(w.end_container())?;
full(w.end_container())?;
Ok(Some(GET_TARGETS_RESPONSE))
}
CLEAR_TARGETS => {
for day in self.targets.borrow_mut().iter_mut() {
day.clear();
}
self.hooks.targets_changed();
Ok(None)
}
_ => Err(Status::UnsupportedCommand.into()),
}
}
}
impl<H: EvseHooks, const T: usize> Cluster for EnergyEvse<'_, H, T> {
const ID: ClusterId = ID;
}