spodes_rs/classes/
register.rs1use crate::interface::InterfaceClass;
2use crate::obis::ObisCode;
3use crate::types::attrs::{Choice, ScalerUnit};
4use crate::types::{BerError, CosemDataType};
5use serde::{Deserialize, Serialize};
6use std::any::Any;
7
8#[derive(Clone, Serialize, Deserialize, Debug)]
16pub struct Register {
17 logical_name: ObisCode,
18 value: Choice,
19 scaler_unit: ScalerUnit,
20}
21
22impl Register {
23 pub fn new(logical_name: ObisCode, value: Choice, scaler_unit: ScalerUnit) -> Self {
25 Register { logical_name, value, scaler_unit }
26 }
27
28 pub fn value(&self) -> &Choice {
30 &self.value
31 }
32
33 pub fn set_value(&mut self, value: Choice) {
35 self.value = value;
36 }
37
38 pub fn scaler_unit(&self) -> &ScalerUnit {
40 &self.scaler_unit
41 }
42
43 pub fn set_scaler_unit(&mut self, scaler_unit: ScalerUnit) {
45 self.scaler_unit = scaler_unit;
46 }
47
48 fn reset(&mut self) -> Result<CosemDataType, String> {
54 match &self.value {
55 CosemDataType::Integer(_) => {
56 self.value = CosemDataType::Integer(0);
57 Ok(CosemDataType::Null)
58 }
59 CosemDataType::Long(_) => {
60 self.value = CosemDataType::Long(0);
61 Ok(CosemDataType::Null)
62 }
63 CosemDataType::DoubleLong(_) => {
64 self.value = CosemDataType::DoubleLong(0);
65 Ok(CosemDataType::Null)
66 }
67 CosemDataType::Unsigned(_) => {
68 self.value = CosemDataType::Unsigned(0);
69 Ok(CosemDataType::Null)
70 }
71 CosemDataType::LongUnsigned(_) => {
72 self.value = CosemDataType::LongUnsigned(0);
73 Ok(CosemDataType::Null)
74 }
75 CosemDataType::DoubleLongUnsigned(_) => {
76 self.value = CosemDataType::DoubleLongUnsigned(0);
77 Ok(CosemDataType::Null)
78 }
79 _ => Err("Unsupported value type for reset".to_string()),
80 }
81 }
82}
83
84impl InterfaceClass for Register {
85 fn class_id(&self) -> u16 {
86 3
87 }
88
89 fn version(&self) -> u8 {
90 0
91 }
92
93 fn logical_name(&self) -> &ObisCode {
94 &self.logical_name
95 }
96
97 fn attributes(&self) -> Vec<(u8, CosemDataType)> {
98 vec![
99 (1, CosemDataType::OctetString(self.logical_name.to_bytes())),
100 (2, self.value.clone()),
101 (3, self.scaler_unit.clone().into()),
102 ]
103 }
104
105 fn methods(&self) -> Vec<(u8, String)> {
106 vec![(1, "reset".to_string())]
107 }
108
109 fn serialize_ber(&self, buf: &mut Vec<u8>) -> Result<(), BerError> {
110 let mut seq_buf = Vec::new();
111 CosemDataType::LongUnsigned(self.class_id()).serialize_ber(&mut seq_buf)?;
112 for (_, attr) in self.attributes() {
113 attr.serialize_ber(&mut seq_buf)?;
114 }
115 buf.push(0x02); write_length(1 + self.attributes().len(), buf); buf.extend_from_slice(&seq_buf);
118 Ok(())
119 }
120
121 fn deserialize_ber(&mut self, data: &[u8]) -> Result<(), BerError> {
122 let (tlv, rest) = CosemDataType::deserialize_ber(data)?;
123 if rest.is_empty() {
124 if let CosemDataType::Structure(seq) = tlv {
125 if seq.len() == 4 {
126 if let CosemDataType::LongUnsigned(class_id) = seq[0] {
127 if class_id != self.class_id() {
128 return Err(BerError::InvalidValue);
129 }
130 } else {
131 return Err(BerError::InvalidTag);
132 }
133 if let CosemDataType::OctetString(obis) = &seq[1] {
134 if obis.len() == 6 {
135 self.logical_name = ObisCode::new(obis[0], obis[1], obis[2], obis[3], obis[4], obis[5]);
136 } else {
137 return Err(BerError::InvalidLength);
138 }
139 } else {
140 return Err(BerError::InvalidTag);
141 }
142 self.value = seq[2].clone();
143 self.scaler_unit = ScalerUnit::try_from(&seq[3]).map_err(|_| BerError::InvalidValue)?;
144 return Ok(());
145 }
146 }
147 }
148 Err(BerError::InvalidTag)
149 }
150
151 fn set_attribute(&mut self, attribute_id: u8, value: CosemDataType) -> Result<(), String> {
152 match attribute_id {
153 2 => {
154 self.value = value;
155 Ok(())
156 }
157 3 => {
158 self.scaler_unit = ScalerUnit::try_from(&value)?;
159 Ok(())
160 }
161 _ => Err(format!("Register attribute {attribute_id} is not writable")),
162 }
163 }
164
165 fn invoke_method(&mut self, method_id: u8, _params: Option<CosemDataType>) -> Result<CosemDataType, String> {
166 match method_id {
167 1 => self.reset(),
168 _ => Err(format!("Method {method_id} not supported for Register class")),
169 }
170 }
171
172 fn as_any(&self) -> &dyn Any {
173 self
174 }
175}
176
177#[allow(clippy::cast_possible_truncation)] fn write_length(length: usize, buf: &mut Vec<u8>) {
180 if length < 128 {
181 buf.push(length as u8);
182 } else {
183 let bytes = (length as u64).to_be_bytes();
184 let first_non_zero = bytes.iter().position(|&b| b != 0).unwrap_or(7);
185 let num_octets = 8 - first_non_zero;
186 buf.push(0x80 | num_octets as u8);
187 buf.extend_from_slice(&bytes[first_non_zero..]);
188 }
189}