use alloc::boxed::Box;
use alloc::string::String;
use alloc::vec::Vec;
use core::fmt;
use crate::types::{DateTime, Decimal};
use crate::v2_1::{self, DERControl, DERUnit};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Effect {
Lowers,
Stops,
Slows,
Reactive,
Unknown,
}
impl Effect {
#[must_use]
pub const fn limits_active_power(self) -> bool {
matches!(self, Self::Lowers | Self::Stops | Self::Unknown)
}
}
#[must_use]
pub fn effect(kind: &DERControl) -> Effect {
match kind {
DERControl::FreqDroop
| DERControl::FreqWatt
| DERControl::VoltWatt
| DERControl::LimitMaxDischarge => Effect::Lowers,
DERControl::HFMustTrip
| DERControl::HFMayTrip
| DERControl::HVMustTrip
| DERControl::HVMomCess
| DERControl::HVMayTrip
| DERControl::LFMustTrip
| DERControl::LVMustTrip
| DERControl::LVMomCess
| DERControl::LVMayTrip
| DERControl::PowerMonitoringMustTrip => Effect::Stops,
DERControl::Gradients | DERControl::EnterService => Effect::Slows,
DERControl::VoltVar
| DERControl::WattVar
| DERControl::WattPF
| DERControl::FixedPFAbsorb
| DERControl::FixedPFInject
| DERControl::FixedVar => Effect::Reactive,
DERControl::UnknownValue(_) => Effect::Unknown,
}
}
fn has_own_field(kind: &DERControl) -> bool {
matches!(
kind,
DERControl::EnterService
| DERControl::FreqDroop
| DERControl::FixedPFAbsorb
| DERControl::FixedPFInject
| DERControl::FixedVar
| DERControl::Gradients
| DERControl::LimitMaxDischarge
)
}
#[derive(Clone, Debug, PartialEq)]
pub enum Setting {
Curve(v2_1::DERCurve),
EnterService(v2_1::EnterService),
FixedPfAbsorb(v2_1::FixedPF),
FixedPfInject(v2_1::FixedPF),
FixedVar(v2_1::FixedVar),
FreqDroop(v2_1::FreqDroop),
Gradient(v2_1::Gradient),
LimitMaxDischarge(v2_1::LimitMaxDischarge),
}
impl Setting {
#[must_use]
pub fn priority(&self) -> i32 {
match self {
Self::Curve(s) => s.priority,
Self::EnterService(s) => s.priority,
Self::FixedPfAbsorb(s) | Self::FixedPfInject(s) => s.priority,
Self::FixedVar(s) => s.priority,
Self::FreqDroop(s) => s.priority,
Self::Gradient(s) => s.priority,
Self::LimitMaxDischarge(s) => s.priority,
}
}
#[must_use]
pub fn start(&self) -> Option<DateTime> {
match self {
Self::Curve(s) => s.start_time,
Self::FixedPfAbsorb(s) | Self::FixedPfInject(s) => s.start_time,
Self::FixedVar(s) => s.start_time,
Self::FreqDroop(s) => s.start_time,
Self::LimitMaxDischarge(s) => s.start_time,
Self::EnterService(_) | Self::Gradient(_) => None,
}
}
#[must_use]
pub fn duration(&self) -> Option<Decimal> {
match self {
Self::Curve(s) => s.duration,
Self::FixedPfAbsorb(s) | Self::FixedPfInject(s) => s.duration,
Self::FixedVar(s) => s.duration,
Self::FreqDroop(s) => s.duration,
Self::LimitMaxDischarge(s) => s.duration,
Self::EnterService(_) | Self::Gradient(_) => None,
}
}
}
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct DerControl {
pub id: String,
pub kind: DERControl,
pub default: bool,
pub superseded: bool,
pub setting: Setting,
window: (Option<i64>, Option<i64>),
}
impl DerControl {
fn new(
id: &str,
kind: DERControl,
default: bool,
superseded: bool,
setting: Setting,
) -> Result<Self, DerError> {
let start = setting.start().map(|at| at.timestamp().as_millisecond());
let end = match setting.duration() {
None => None,
Some(duration) => {
let millis = duration
.checked_mul(Decimal::from(1000))
.and_then(|ms| ms.round_to(0))
.filter(|ms| ms.signum() >= 0)
.map(Decimal::mantissa)
.ok_or_else(|| DerError::BadDuration(id.into()))?;
match start {
Some(start) => Some(
start
.checked_add(millis)
.ok_or_else(|| DerError::BadDuration(id.into()))?,
),
None => None,
}
}
};
Ok(Self {
id: id.into(),
kind,
default,
superseded,
setting,
window: (start, end),
})
}
#[must_use]
pub fn priority(&self) -> i32 {
self.setting.priority()
}
#[must_use]
pub fn effect(&self) -> Effect {
effect(&self.kind)
}
#[must_use]
pub fn is_active_at(&self, at: DateTime) -> bool {
if self.default {
return true;
}
let at = at.timestamp().as_millisecond();
self.window.0.is_none_or(|start| start <= at) && self.window.1.is_none_or(|end| at < end)
}
}
#[derive(Clone, Debug)]
pub struct DerReport {
request_id: i32,
limit: usize,
complete: bool,
controls: Vec<DerControl>,
}
impl DerReport {
pub const DEFAULT_LIMIT: usize = 1024;
#[must_use]
pub fn new(request_id: i32) -> Self {
Self {
request_id,
limit: Self::DEFAULT_LIMIT,
complete: false,
controls: Vec::new(),
}
}
#[must_use]
pub fn with_limit(mut self, limit: usize) -> Self {
self.limit = limit;
self
}
#[must_use]
pub fn is_complete(&self) -> bool {
self.complete
}
pub fn add(&mut self, part: &v2_1::ReportDERControlRequest) -> Result<bool, DerError> {
if self.complete {
return Err(DerError::Complete);
}
if part.request_id != self.request_id {
return Err(DerError::RequestId {
expected: self.request_id,
got: part.request_id,
});
}
let added = controls_in(part)?;
if self.controls.len() + added.len() > self.limit {
return Err(DerError::TooManyControls { limit: self.limit });
}
for (index, control) in added.iter().enumerate() {
let seen = |other: &DerControl| other.id == control.id;
if self.controls.iter().any(seen) || added[..index].iter().any(seen) {
return Err(DerError::DuplicateId(control.id.clone()));
}
}
self.controls.extend(added);
self.complete = part.tbc != Some(true);
Ok(self.complete)
}
pub fn finish(self) -> Result<DerControls, DerError> {
if !self.complete {
return Err(DerError::Incomplete);
}
Ok(DerControls {
controls: self.controls,
})
}
}
fn controls_in(part: &v2_1::ReportDERControlRequest) -> Result<Vec<DerControl>, DerError> {
let mut added = Vec::new();
for c in part.curve.iter().flatten() {
if has_own_field(&c.curve_type) {
return Err(DerError::WrongArray {
id: c.id.clone(),
kind: c.curve_type.clone(),
});
}
added.push(DerControl::new(
&c.id,
c.curve_type.clone(),
c.is_default,
c.is_superseded,
Setting::Curve(c.curve.clone()),
)?);
}
for c in part.enter_service.iter().flatten() {
let setting = Setting::EnterService(c.enter_service.clone());
added.push(DerControl::new(
&c.id,
DERControl::EnterService,
true,
false,
setting,
)?);
}
for c in part.gradient.iter().flatten() {
let setting = Setting::Gradient(c.gradient.clone());
added.push(DerControl::new(
&c.id,
DERControl::Gradients,
true,
false,
setting,
)?);
}
for (list, kind, wrap) in [
(
&part.fixed_pf_absorb,
DERControl::FixedPFAbsorb,
Setting::FixedPfAbsorb as fn(v2_1::FixedPF) -> Setting,
),
(
&part.fixed_pf_inject,
DERControl::FixedPFInject,
Setting::FixedPfInject,
),
] {
for c in list.iter().flatten() {
let setting = wrap(c.fixed_pf.clone());
added.push(DerControl::new(
&c.id,
kind.clone(),
c.is_default,
c.is_superseded,
setting,
)?);
}
}
for c in part.fixed_var.iter().flatten() {
let setting = Setting::FixedVar(c.fixed_var.clone());
added.push(DerControl::new(
&c.id,
DERControl::FixedVar,
c.is_default,
c.is_superseded,
setting,
)?);
}
for c in part.freq_droop.iter().flatten() {
let setting = Setting::FreqDroop(c.freq_droop.clone());
added.push(DerControl::new(
&c.id,
DERControl::FreqDroop,
c.is_default,
c.is_superseded,
setting,
)?);
}
for c in part.limit_max_discharge.iter().flatten() {
let setting = Setting::LimitMaxDischarge(c.limit_max_discharge.clone());
added.push(DerControl::new(
&c.id,
DERControl::LimitMaxDischarge,
c.is_default,
c.is_superseded,
setting,
)?);
}
Ok(added)
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct DerControls {
controls: Vec<DerControl>,
}
impl DerControls {
pub fn iter(&self) -> impl Iterator<Item = &DerControl> {
self.controls.iter()
}
#[must_use]
pub fn len(&self) -> usize {
self.controls.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.controls.is_empty()
}
#[must_use]
pub fn get(&self, id: &str) -> Option<&DerControl> {
self.controls.iter().find(|control| control.id == id)
}
#[must_use]
pub fn effective(&self, kind: &DERControl, at: DateTime) -> Option<&DerControl> {
let best = |default: bool| {
self.controls
.iter()
.filter(|c| c.kind == *kind && c.default == default && !c.superseded)
.filter(|c| c.is_active_at(at))
.fold(None, |best: Option<&DerControl>, c| match best {
Some(b) if b.priority() <= c.priority() => Some(b),
_ => Some(c),
})
};
best(false).or_else(|| best(true))
}
#[must_use]
pub fn effective_at(&self, at: DateTime) -> Vec<&DerControl> {
let mut kinds: Vec<&DERControl> = Vec::new();
for control in &self.controls {
if !kinds.contains(&&control.kind) {
kinds.push(&control.kind);
}
}
kinds
.into_iter()
.filter_map(|kind| self.effective(kind, at))
.collect()
}
#[must_use]
pub fn limiting_at(&self, at: DateTime) -> Vec<&DerControl> {
self.effective_at(at)
.into_iter()
.filter(|control| control.effect().limits_active_power())
.collect()
}
pub fn apply(&mut self, notice: &v2_1::NotifyDERStartStopRequest) -> StartStop {
if notice.started {
let mut superseded = Vec::new();
for id in notice.superseded_ids.iter().flatten() {
if let Some(control) = self.controls.iter_mut().find(|c| c.id == *id) {
control.superseded = true;
superseded.push(id.clone());
}
}
if self.get(¬ice.control_id).is_none() {
return StartStop::UnknownControl(notice.control_id.clone());
}
StartStop::Started { superseded }
} else {
match self.controls.iter().position(|c| c.id == notice.control_id) {
Some(index) => StartStop::Ended(Box::new(self.controls.remove(index))),
None => StartStop::UnknownControl(notice.control_id.clone()),
}
}
}
}
impl<'a> IntoIterator for &'a DerControls {
type Item = &'a DerControl;
type IntoIter = core::slice::Iter<'a, DerControl>;
fn into_iter(self) -> Self::IntoIter {
self.controls.iter()
}
}
#[derive(Clone, Debug, PartialEq)]
#[must_use = "an unknown control means the inventory is stale: ask the station again"]
pub enum StartStop {
Started {
superseded: Vec<String>,
},
Ended(Box<DerControl>),
UnknownControl(String),
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct DerAlarm {
pub kind: DERControl,
pub fault: Option<v2_1::GridEventFault>,
pub since: DateTime,
pub extra_info: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct DerAlarmState {
current: Option<DerAlarm>,
}
impl DerAlarmState {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn current(&self) -> Option<&DerAlarm> {
self.current.as_ref()
}
pub fn apply(&mut self, notice: &v2_1::NotifyDERAlarmRequest) -> AlarmChange {
if notice.alarm_ended == Some(true) {
return match &self.current {
Some(alarm) if alarm.kind == notice.control_type => self
.current
.take()
.map_or(AlarmChange::Unmatched, AlarmChange::Cleared),
_ => AlarmChange::Unmatched,
};
}
let alarm = DerAlarm {
kind: notice.control_type.clone(),
fault: notice.grid_event_fault.clone(),
since: notice.timestamp,
extra_info: notice.extra_info.clone(),
};
match self.current.take() {
None => {
self.current = Some(alarm);
AlarmChange::Raised
}
Some(previous) if previous.kind == alarm.kind && previous.fault == alarm.fault => {
self.current = Some(previous);
AlarmChange::Repeated
}
Some(previous) => {
self.current = Some(alarm);
AlarmChange::Replaced(previous)
}
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[must_use = "an unmatched end means the alarm state and the station disagree"]
pub enum AlarmChange {
Raised,
Repeated,
Replaced(DerAlarm),
Cleared(DerAlarm),
Unmatched,
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum DerRule {
DefaultWithTime,
DefaultOnly,
FieldMismatch,
WrongYUnit {
kind: DERControl,
unit: DERUnit,
},
}
impl DerRule {
#[must_use]
pub fn requirement(&self) -> &'static str {
match self {
Self::DefaultWithTime => "R04.FR.13",
Self::DefaultOnly => "R04.FR.15",
Self::FieldMismatch => "R04.FR.17",
Self::WrongYUnit { kind, .. } => {
y_unit_rule(kind).map_or("R04.FR.50", |(rule, _)| rule)
}
}
}
}
impl fmt::Display for DerRule {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let rule = self.requirement();
match self {
Self::DefaultWithTime => {
write!(
f,
"a default DER control has no startTime or duration ({rule})"
)
}
Self::DefaultOnly => {
write!(
f,
"EnterService and Gradients exist only as defaults ({rule})"
)
}
Self::FieldMismatch => write!(
f,
"the request must carry exactly the one field its controlType maps to ({rule})"
),
Self::WrongYUnit { kind, unit } => {
write!(f, "a {kind} curve cannot use yUnit {unit} ({rule})")
}
}
}
}
#[cfg(feature = "std")]
impl std::error::Error for DerRule {}
fn y_unit_rule(kind: &DERControl) -> Option<(&'static str, &'static [DERUnit])> {
const POWER: &[DERUnit] = &[DERUnit::PctMaxW, DERUnit::PctWAvail];
const VAR: &[DERUnit] = &[DERUnit::PctMaxVar, DERUnit::PctVarAvail];
const NONE: &[DERUnit] = &[DERUnit::NotApplicable];
Some(match kind {
DERControl::FreqWatt => ("R04.FR.50", POWER),
DERControl::HFMustTrip
| DERControl::HFMayTrip
| DERControl::HVMustTrip
| DERControl::HVMomCess
| DERControl::HVMayTrip
| DERControl::LFMustTrip
| DERControl::LVMustTrip
| DERControl::LVMomCess
| DERControl::LVMayTrip => ("R04.FR.51", NONE),
DERControl::VoltVar => ("R04.FR.52", VAR),
DERControl::VoltWatt => ("R04.FR.53", POWER),
DERControl::WattPF => ("R04.FR.54", NONE),
DERControl::WattVar => ("R04.FR.55", VAR),
DERControl::LimitMaxDischarge => ("R04.FR.56", NONE),
_ => return None,
})
}
pub fn check(request: &v2_1::SetDERControlRequest) -> Result<(), DerRule> {
let kind = &request.control_type;
let present = [
("curve", request.curve.is_some()),
("enterService", request.enter_service.is_some()),
("fixedPFAbsorb", request.fixed_pf_absorb.is_some()),
("fixedPFInject", request.fixed_pf_inject.is_some()),
("fixedVar", request.fixed_var.is_some()),
("freqDroop", request.freq_droop.is_some()),
("gradient", request.gradient.is_some()),
("limitMaxDischarge", request.limit_max_discharge.is_some()),
];
let expected = match kind {
DERControl::EnterService => "enterService",
DERControl::FixedPFAbsorb => "fixedPFAbsorb",
DERControl::FixedPFInject => "fixedPFInject",
DERControl::FixedVar => "fixedVar",
DERControl::FreqDroop => "freqDroop",
DERControl::Gradients => "gradient",
DERControl::LimitMaxDischarge => "limitMaxDischarge",
_ => "curve",
};
let mut set = present.iter().filter(|(_, set)| *set);
if set.next().map(|(name, _)| *name) != Some(expected) || set.next().is_some() {
return Err(DerRule::FieldMismatch);
}
if !request.is_default && matches!(kind, DERControl::EnterService | DERControl::Gradients) {
return Err(DerRule::DefaultOnly);
}
let setting = request
.curve
.clone()
.map(Setting::Curve)
.or_else(|| request.fixed_pf_absorb.clone().map(Setting::FixedPfAbsorb))
.or_else(|| request.fixed_pf_inject.clone().map(Setting::FixedPfInject))
.or_else(|| request.fixed_var.clone().map(Setting::FixedVar))
.or_else(|| request.freq_droop.clone().map(Setting::FreqDroop))
.or_else(|| {
request
.limit_max_discharge
.clone()
.map(Setting::LimitMaxDischarge)
});
if request.is_default
&& setting
.as_ref()
.is_some_and(|s| s.start().is_some() || s.duration().is_some())
{
return Err(DerRule::DefaultWithTime);
}
let curve = match (&request.curve, &request.limit_max_discharge) {
(Some(curve), _) => Some(curve),
(None, Some(limit)) => limit.power_monitoring_must_trip.as_ref(),
(None, None) => None,
};
if let (Some(curve), Some((_, allowed))) = (curve, y_unit_rule(kind)) {
if !allowed.contains(&curve.y_unit) {
return Err(DerRule::WrongYUnit {
kind: kind.clone(),
unit: curve.y_unit.clone(),
});
}
}
Ok(())
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum DerError {
RequestId {
expected: i32,
got: i32,
},
Complete,
Incomplete,
WrongArray {
id: String,
kind: DERControl,
},
DuplicateId(String),
TooManyControls {
limit: usize,
},
BadDuration(String),
}
impl fmt::Display for DerError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::RequestId { expected, got } => write!(
f,
"report part for requestId {got}, expected {expected} (R04.FR.31)"
),
Self::Complete => f.write_str("report part after the last one (R04.FR.32)"),
Self::Incomplete => f.write_str("the report's last part has not arrived"),
Self::WrongArray { id, kind } => write!(
f,
"control {id:?} of type {kind} arrived as a curve; it has its own field (R04.FR.16)"
),
Self::DuplicateId(id) => write!(f, "control id {id:?} reported twice"),
Self::TooManyControls { limit } => {
write!(f, "report holds more than {limit} controls")
}
Self::BadDuration(id) => write!(
f,
"control {id:?} has a negative or unrepresentable duration"
),
}
}
}
#[cfg(feature = "std")]
impl std::error::Error for DerError {}
#[cfg(test)]
mod tests {
use super::*;
fn at(text: &str) -> DateTime {
text.parse().unwrap()
}
fn part(json: &str) -> v2_1::ReportDERControlRequest {
serde_json::from_str(json).unwrap()
}
fn curve(id: &str, kind: &str, default: bool, superseded: bool, extra: &str) -> String {
let unit = match kind {
"VoltVar" | "WattVar" => "PctMaxVar",
"VoltWatt" | "FreqWatt" => "PctMaxW",
_ => "Not_Applicable",
};
format!(
r#"{{"id":"{id}","curveType":"{kind}","isDefault":{default},"isSuperseded":{superseded},
"curve":{{"yUnit":"{unit}","curveData":[{{"x":1,"y":2}}]{extra}}}}}"#
)
}
fn controls(curves: &[String]) -> DerControls {
let mut report = DerReport::new(1);
let json = format!(r#"{{"requestId":1,"curve":[{}]}}"#, curves.join(","));
assert!(report.add(&part(&json)).unwrap());
report.finish().unwrap()
}
#[test]
fn a_running_scheduled_control_beats_the_default_and_the_default_returns_after_it() {
let set = controls(&[
curve("default", "VoltWatt", true, false, r#","priority":1"#),
curve(
"event",
"VoltWatt",
false,
false,
r#","priority":0,"startTime":"2026-11-20T14:00:00Z","duration":3600"#,
),
]);
let kind = DERControl::VoltWatt;
assert_eq!(
set.effective(&kind, at("2026-11-20T14:30:00Z")).unwrap().id,
"event"
);
assert_eq!(
set.effective(&kind, at("2026-11-20T16:00:00Z")).unwrap().id,
"default"
);
assert_eq!(
set.effective(&kind, at("2026-11-20T15:00:00Z")).unwrap().id,
"default"
);
assert_eq!(
set.effective(&kind, at("2026-11-20T13:59:59Z")).unwrap().id,
"default"
);
}
#[test]
fn the_lowest_priority_value_wins_and_a_superseded_control_is_never_in_effect() {
let set = controls(&[
curve("low", "FreqWatt", true, true, r#","priority":2"#),
curve("high", "FreqWatt", true, false, r#","priority":1"#),
curve("tie", "FreqWatt", true, false, r#","priority":1"#),
]);
let effective = set.effective(&DERControl::FreqWatt, at("2026-11-20T00:00:00Z"));
assert_eq!(effective.unwrap().id, "high");
let set = controls(&[
curve("default", "VoltWatt", true, false, r#","priority":3"#),
curve(
"gone",
"VoltWatt",
false,
true,
r#","priority":0,"startTime":"2026-11-20T00:00:00Z","duration":60"#,
),
]);
let effective = set.effective(&DERControl::VoltWatt, at("2026-11-20T00:00:30Z"));
assert_eq!(effective.unwrap().id, "default");
}
#[test]
fn only_controls_that_lower_or_stop_active_power_are_limiting() {
let mut report = DerReport::new(4);
report
.add(&part(&format!(
r#"{{"requestId":4,"tbc":true,"curve":[{},{}]}}"#,
curve("vv", "VoltVar", true, false, r#","priority":0"#),
curve("trip", "HVMustTrip", true, false, r#","priority":0"#),
)))
.unwrap();
report
.add(&part(
r#"{"requestId":4,"freqDroop":[{"id":"droop","isDefault":true,"isSuperseded":false,
"freqDroop":{"priority":0,"overFreq":50.2,"underFreq":49.8,"overDroop":5,
"underDroop":5,"responseTime":1}}]}"#,
))
.unwrap();
let set = report.finish().unwrap();
let ids: Vec<_> = set
.limiting_at(at("2026-11-20T00:00:00Z"))
.into_iter()
.map(|c| c.id.as_str())
.collect();
assert_eq!(ids, ["trip", "droop"]);
assert_eq!(set.effective_at(at("2026-11-20T00:00:00Z")).len(), 3);
}
#[test]
fn an_unknown_control_type_counts_as_limiting() {
assert_eq!(
effect(&DERControl::from_wire("VendorCurve")),
Effect::Unknown
);
assert!(Effect::Unknown.limits_active_power());
assert!(!Effect::Reactive.limits_active_power());
assert!(!Effect::Slows.limits_active_power());
let set = controls(&[curve("v", "VendorCurve", true, false, r#","priority":0"#)]);
assert_eq!(set.limiting_at(at("2026-11-20T00:00:00Z")).len(), 1);
}
#[test]
fn a_stray_late_or_malformed_part_is_refused_and_changes_nothing() {
let mut report = DerReport::new(7);
let other = part(r#"{"requestId":8}"#);
assert_eq!(
report.add(&other),
Err(DerError::RequestId {
expected: 7,
got: 8
})
);
let wrong_array = part(&format!(
r#"{{"requestId":7,"tbc":true,"curve":[{}]}}"#,
curve("x", "FreqDroop", true, false, r#","priority":0"#)
));
assert!(matches!(
report.add(&wrong_array),
Err(DerError::WrongArray { .. })
));
let negative = part(&format!(
r#"{{"requestId":7,"tbc":true,"curve":[{},{}]}}"#,
curve("fine", "VoltVar", true, false, r#","priority":0"#),
curve(
"neg",
"VoltVar",
false,
false,
r#","priority":0,"startTime":"2026-11-20T00:00:00Z","duration":-5"#
),
));
assert_eq!(
report.add(&negative),
Err(DerError::BadDuration("neg".into()))
);
let twice = part(&format!(
r#"{{"requestId":7,"tbc":true,"curve":[{0},{0}]}}"#,
curve("dup", "VoltVar", true, false, r#","priority":0"#)
));
assert_eq!(report.add(&twice), Err(DerError::DuplicateId("dup".into())));
assert!(!report.is_complete());
assert_eq!(report.clone().finish(), Err(DerError::Incomplete));
assert_eq!(report.add(&part(r#"{"requestId":7}"#)), Ok(true));
assert_eq!(
report.add(&part(r#"{"requestId":7}"#)),
Err(DerError::Complete)
);
assert!(report.finish().unwrap().is_empty());
}
#[test]
fn the_collector_is_bounded() {
let mut report = DerReport::new(1).with_limit(2);
let three = part(&format!(
r#"{{"requestId":1,"curve":[{},{},{}]}}"#,
curve("a", "VoltVar", true, false, r#","priority":0"#),
curve("b", "VoltWatt", true, false, r#","priority":0"#),
curve("c", "WattVar", true, false, r#","priority":0"#),
));
assert_eq!(
report.add(&three),
Err(DerError::TooManyControls { limit: 2 })
);
assert!(!report.is_complete());
}
#[test]
fn a_limit_max_discharge_control_is_carried_as_reported() {
let mut report = DerReport::new(1);
report
.add(&part(
r#"{"requestId":1,"limitMaxDischarge":[{"id":"cap","isDefault":true,
"isSuperseded":false,"limitMaxDischarge":{"priority":0,"pctMaxDischargePower":50.0}}]}"#,
))
.unwrap();
let set = report.finish().unwrap();
let control = set.get("cap").unwrap();
assert_eq!(control.effect(), Effect::Lowers);
let Setting::LimitMaxDischarge(setting) = &control.setting else {
panic!("not a LimitMaxDischarge setting");
};
assert_eq!(setting.pct_max_discharge_power.unwrap().to_string(), "50.0");
}
#[test]
fn start_stop_notices_keep_the_inventory_current() {
let mut set = controls(&[
curve(
"a",
"VoltWatt",
false,
false,
r#","priority":1,"startTime":"2026-11-20T00:00:00Z","duration":7200"#,
),
curve(
"b",
"VoltWatt",
false,
false,
r#","priority":0,"startTime":"2026-11-20T01:00:00Z","duration":600"#,
),
]);
let started = v2_1::NotifyDERStartStopRequest::new("b", true, at("2026-11-20T01:00:00Z"))
.with_superseded_ids(["a", "missing"]);
assert_eq!(
set.apply(&started),
StartStop::Started {
superseded: vec!["a".into()]
}
);
assert!(set.get("a").unwrap().superseded);
let ended = v2_1::NotifyDERStartStopRequest::new("b", false, at("2026-11-20T01:10:00Z"));
assert!(matches!(set.apply(&ended), StartStop::Ended(control) if control.id == "b"));
assert!(set.get("b").is_none());
assert_eq!(set.apply(&ended), StartStop::UnknownControl("b".into()));
}
fn alarm(
kind: DERControl,
fault: Option<v2_1::GridEventFault>,
ended: bool,
) -> v2_1::NotifyDERAlarmRequest {
let mut notice = v2_1::NotifyDERAlarmRequest::new(kind, at("2026-11-20T12:00:00Z"));
notice.grid_event_fault = fault;
notice.alarm_ended = ended.then_some(true);
notice
}
#[test]
fn an_alarm_has_one_level() {
use v2_1::GridEventFault::{OverFrequency, OverVoltage};
let mut state = DerAlarmState::new();
assert_eq!(
state.apply(&alarm(DERControl::VoltWatt, Some(OverVoltage), false)),
AlarmChange::Raised
);
assert_eq!(state.current().unwrap().kind, DERControl::VoltWatt);
assert_eq!(
state.apply(&alarm(DERControl::VoltWatt, Some(OverVoltage), false)),
AlarmChange::Repeated
);
let replaced = state.apply(&alarm(DERControl::FreqDroop, Some(OverFrequency), false));
assert!(
matches!(replaced, AlarmChange::Replaced(previous) if previous.kind == DERControl::VoltWatt)
);
assert_eq!(
state.apply(&alarm(DERControl::VoltWatt, None, true)),
AlarmChange::Unmatched
);
assert_eq!(state.current().unwrap().kind, DERControl::FreqDroop);
assert!(matches!(
state.apply(&alarm(DERControl::FreqDroop, Some(OverFrequency), true)),
AlarmChange::Cleared(_)
));
assert!(state.current().is_none());
assert_eq!(
state.apply(&alarm(DERControl::FreqDroop, None, true)),
AlarmChange::Unmatched
);
}
fn set_request(json: &str) -> v2_1::SetDERControlRequest {
serde_json::from_str(json).unwrap()
}
#[test]
fn check_refuses_what_r04_forbids_and_names_the_rule() {
let default_with_time = set_request(
r#"{"isDefault":true,"controlId":"a","controlType":"FreqDroop","freqDroop":{"priority":0,
"overFreq":50.2,"underFreq":49.8,"overDroop":5,"underDroop":5,"responseTime":1,
"startTime":"2026-11-20T00:00:00Z"}}"#,
);
assert_eq!(
check(&default_with_time).unwrap_err().requirement(),
"R04.FR.13"
);
let scheduled_enter_service = set_request(
r#"{"isDefault":false,"controlId":"a","controlType":"EnterService","enterService":{
"priority":0,"highVoltage":253,"lowVoltage":207,"highFreq":50.1,"lowFreq":47.5}}"#,
);
assert_eq!(check(&scheduled_enter_service), Err(DerRule::DefaultOnly));
let droop_as_curve = set_request(
r#"{"isDefault":true,"controlId":"a","controlType":"FreqDroop","curve":{"priority":0,
"yUnit":"PctMaxW","curveData":[{"x":1,"y":2}]}}"#,
);
assert_eq!(check(&droop_as_curve), Err(DerRule::FieldMismatch));
let two_fields = set_request(
r#"{"isDefault":true,"controlId":"a","controlType":"Gradients",
"gradient":{"priority":0,"gradient":10,"softGradient":0},
"curve":{"priority":0,"yUnit":"PctMaxW","curveData":[{"x":1,"y":2}]}}"#,
);
assert_eq!(check(&two_fields).unwrap_err().requirement(), "R04.FR.17");
let none = set_request(r#"{"isDefault":true,"controlId":"a","controlType":"VoltVar"}"#);
assert_eq!(check(&none), Err(DerRule::FieldMismatch));
let wrong_unit = set_request(
r#"{"isDefault":true,"controlId":"a","controlType":"VoltWatt","curve":{"priority":0,
"yUnit":"PctMaxVar","curveData":[{"x":1,"y":2}]}}"#,
);
let error = check(&wrong_unit).unwrap_err();
assert_eq!(error.requirement(), "R04.FR.53");
assert!(error.to_string().contains("VoltWatt"));
let monitoring = set_request(
r#"{"isDefault":true,"controlId":"a","controlType":"LimitMaxDischarge",
"limitMaxDischarge":{"priority":0,"pctMaxDischargePower":50,
"powerMonitoringMustTrip":{"priority":0,"yUnit":"PctMaxW","curveData":[{"x":1,"y":2}]}}}"#,
);
assert_eq!(check(&monitoring).unwrap_err().requirement(), "R04.FR.56");
}
#[test]
fn check_accepts_the_specifications_own_examples() {
let droop = set_request(
r#"{"isDefault":true,"controlId":"droop","controlType":"FreqDroop","freqDroop":{
"priority":0,"overFreq":50.2,"underFreq":49.8,"overDroop":5,"underDroop":5,
"responseTime":1}}"#,
);
assert_eq!(check(&droop), Ok(()));
let volt_watt = set_request(
r#"{"isDefault":true,"controlId":"vw","controlType":"VoltWatt","curve":{"priority":0,
"yUnit":"PctMaxW","curveData":[{"x":106,"y":100},{"x":110,"y":0}]}}"#,
);
assert_eq!(check(&volt_watt), Ok(()));
let limit = set_request(
r#"{"isDefault":true,"controlId":"lmd","controlType":"LimitMaxDischarge",
"limitMaxDischarge":{"priority":0,"pctMaxDischargePower":50.0}}"#,
);
assert_eq!(check(&limit), Ok(()));
let trip = set_request(
r#"{"isDefault":false,"controlId":"hv","controlType":"HVMustTrip","curve":{"priority":0,
"yUnit":"Not_Applicable","startTime":"2026-11-20T00:00:00Z","duration":3600,
"curveData":[{"x":0.16,"y":120}]}}"#,
);
assert_eq!(check(&trip), Ok(()));
}
}