1use crate::interface::InterfaceClass;
2use crate::obis::ObisCode;
3use crate::types::attrs::{Choice, DateTime, ScalerUnit};
4use crate::types::{BerError, CosemDataType};
5use serde::{Deserialize, Serialize};
6use std::any::Any;
7
8#[derive(Clone, Serialize, Deserialize, Debug)]
10pub struct DemandRegisterConfig {
11 pub logical_name: ObisCode,
13 pub current_average_value: Choice,
15 pub last_average_value: Choice,
17 pub scaler_unit: ScalerUnit,
19 pub status: Choice,
21 pub capture_time: DateTime,
23 pub start_time_current: DateTime,
25 pub period: u32,
27 pub number_of_periods: u16,
29}
30
31#[derive(Clone, Serialize, Deserialize, Debug)]
46pub struct DemandRegister {
47 logical_name: ObisCode,
48 current_average_value: Choice,
49 last_average_value: Choice,
50 scaler_unit: ScalerUnit,
51 status: Choice,
52 capture_time: DateTime,
53 start_time_current: DateTime,
54 period: u32,
55 number_of_periods: u16,
56}
57
58impl DemandRegister {
59 pub fn new(config: DemandRegisterConfig) -> Self {
67 DemandRegister {
68 logical_name: config.logical_name,
69 current_average_value: config.current_average_value,
70 last_average_value: config.last_average_value,
71 scaler_unit: config.scaler_unit,
72 status: config.status,
73 capture_time: config.capture_time,
74 start_time_current: config.start_time_current,
75 period: config.period,
76 number_of_periods: config.number_of_periods,
77 }
78 }
79
80 fn reset(&mut self) -> Result<CosemDataType, String> {
83 match &self.current_average_value {
84 CosemDataType::Integer(_) => {
85 self.current_average_value = CosemDataType::Integer(0);
86 self.last_average_value = CosemDataType::Integer(0);
87 }
88 CosemDataType::Long(_) => {
89 self.current_average_value = CosemDataType::Long(0);
90 self.last_average_value = CosemDataType::Long(0);
91 }
92 CosemDataType::DoubleLong(_) => {
93 self.current_average_value = CosemDataType::DoubleLong(0);
94 self.last_average_value = CosemDataType::DoubleLong(0);
95 }
96 CosemDataType::Unsigned(_) => {
97 self.current_average_value = CosemDataType::Unsigned(0);
98 self.last_average_value = CosemDataType::Unsigned(0);
99 }
100 CosemDataType::LongUnsigned(_) => {
101 self.current_average_value = CosemDataType::LongUnsigned(0);
102 self.last_average_value = CosemDataType::LongUnsigned(0);
103 }
104 CosemDataType::DoubleLongUnsigned(_) => {
105 self.current_average_value = CosemDataType::DoubleLongUnsigned(0);
106 self.last_average_value = CosemDataType::DoubleLongUnsigned(0);
107 }
108 _ => return Err("Unsupported value type for reset".to_string()),
109 }
110 self.status = CosemDataType::Null;
111 self.capture_time = DateTime::new([0u8; 12]);
112 self.start_time_current = DateTime::new([0u8; 12]);
113 Ok(CosemDataType::Null)
114 }
115
116 fn next_period(&mut self) -> Result<CosemDataType, String> {
124 self.last_average_value = self.current_average_value.clone();
126 match &self.current_average_value {
128 CosemDataType::Integer(_) => self.current_average_value = CosemDataType::Integer(0),
129 CosemDataType::Long(_) => self.current_average_value = CosemDataType::Long(0),
130 CosemDataType::DoubleLong(_) => self.current_average_value = CosemDataType::DoubleLong(0),
131 CosemDataType::Unsigned(_) => self.current_average_value = CosemDataType::Unsigned(0),
132 CosemDataType::LongUnsigned(_) => self.current_average_value = CosemDataType::LongUnsigned(0),
133 CosemDataType::DoubleLongUnsigned(_) => self.current_average_value = CosemDataType::DoubleLongUnsigned(0),
134 _ => return Err("Unsupported value type for next_period".to_string()),
135 }
136 self.status = CosemDataType::Unsigned(1);
138 let new_time = DateTime::new([
140 0x07, 0xE5, 0x05, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ]);
146 self.capture_time = new_time.clone();
147 self.start_time_current = new_time;
148 Ok(CosemDataType::Null)
149 }
150}
151
152impl InterfaceClass for DemandRegister {
153 fn class_id(&self) -> u16 {
154 5
155 }
156
157 fn version(&self) -> u8 {
158 0
159 }
160
161 fn logical_name(&self) -> &ObisCode {
162 &self.logical_name
163 }
164
165 fn attributes(&self) -> Vec<(u8, CosemDataType)> {
166 vec![
167 (1, CosemDataType::OctetString(self.logical_name.to_bytes())),
168 (2, self.current_average_value.clone()),
169 (3, self.last_average_value.clone()),
170 (4, self.scaler_unit.clone().into()),
171 (5, self.status.clone()),
172 (6, self.capture_time.clone().into()),
173 (7, self.start_time_current.clone().into()),
174 (8, CosemDataType::DoubleLongUnsigned(self.period)),
175 (9, CosemDataType::LongUnsigned(self.number_of_periods)),
176 ]
177 }
178
179 fn methods(&self) -> Vec<(u8, String)> {
180 vec![(1, "reset".to_string()), (2, "next_period".to_string())]
181 }
182
183 fn serialize_ber(&self, buf: &mut Vec<u8>) -> Result<(), BerError> {
184 let mut seq_buf = Vec::new();
185 CosemDataType::LongUnsigned(self.class_id()).serialize_ber(&mut seq_buf)?;
186 for (_, attr) in self.attributes() {
187 attr.serialize_ber(&mut seq_buf)?;
188 }
189 buf.push(0x02); write_length(1 + self.attributes().len(), buf); buf.extend_from_slice(&seq_buf);
192 Ok(())
193 }
194
195 fn deserialize_ber(&mut self, data: &[u8]) -> Result<(), BerError> {
196 let (tlv, rest) = CosemDataType::deserialize_ber(data)?;
197 if !rest.is_empty() {
198 return Err(BerError::InvalidTag);
199 }
200 if let CosemDataType::Structure(seq) = tlv {
201 if seq.len() == 10 {
202 if let CosemDataType::LongUnsigned(class_id) = seq[0] {
203 if class_id != self.class_id() {
204 return Err(BerError::InvalidValue);
205 }
206 } else {
207 return Err(BerError::InvalidTag);
208 }
209 if let CosemDataType::OctetString(obis) = &seq[1] {
210 if obis.len() == 6 {
211 self.logical_name = ObisCode::new(obis[0], obis[1], obis[2], obis[3], obis[4], obis[5]);
212 } else {
213 return Err(BerError::InvalidLength);
214 }
215 } else {
216 return Err(BerError::InvalidTag);
217 }
218 self.current_average_value = seq[2].clone();
219 self.last_average_value = seq[3].clone();
220 self.scaler_unit = ScalerUnit::try_from(&seq[4]).map_err(|_| BerError::InvalidValue)?;
221 self.status = seq[5].clone();
222 self.capture_time = DateTime::try_from(&seq[6]).map_err(|_| BerError::InvalidValue)?;
223 self.start_time_current = DateTime::try_from(&seq[7]).map_err(|_| BerError::InvalidValue)?;
224 self.period = match &seq[8] {
225 CosemDataType::DoubleLongUnsigned(v) => *v,
226 _ => return Err(BerError::InvalidTag),
227 };
228 self.number_of_periods = match &seq[9] {
229 CosemDataType::LongUnsigned(v) => *v,
230 _ => return Err(BerError::InvalidTag),
231 };
232 return Ok(());
233 }
234 return Err(BerError::InvalidLength);
235 }
236 Err(BerError::InvalidTag)
237 }
238
239 fn set_attribute(&mut self, attribute_id: u8, value: CosemDataType) -> Result<(), String> {
240 match attribute_id {
241 8 => match value {
242 CosemDataType::DoubleLongUnsigned(v) => {
243 self.period = v;
244 Ok(())
245 }
246 _ => Err("period must be double-long-unsigned".into()),
247 },
248 9 => match value {
249 CosemDataType::LongUnsigned(v) => {
250 self.number_of_periods = v;
251 Ok(())
252 }
253 _ => Err("number_of_periods must be long-unsigned".into()),
254 },
255 _ => Err(format!("DemandRegister attribute {attribute_id} is not writable")),
256 }
257 }
258
259 fn invoke_method(&mut self, method_id: u8, _params: Option<CosemDataType>) -> Result<CosemDataType, String> {
260 match method_id {
261 1 => self.reset(),
262 2 => self.next_period(),
263 _ => Err(format!("Method {method_id} not supported for DemandRegister class")),
264 }
265 }
266
267 fn as_any(&self) -> &dyn Any {
268 self
269 }
270}
271
272#[allow(clippy::cast_possible_truncation)] fn write_length(length: usize, buf: &mut Vec<u8>) {
275 if length < 128 {
276 buf.push(length as u8);
277 } else {
278 let bytes = (length as u64).to_be_bytes();
279 let first_non_zero = bytes.iter().position(|&b| b != 0).unwrap_or(7);
280 let num_octets = 8 - first_non_zero;
281 buf.push(0x80 | num_octets as u8);
282 buf.extend_from_slice(&bytes[first_non_zero..]);
283 }
284}