Skip to main content

spodes_rs/classes/
register_table.rs

1use crate::interface::InterfaceClass;
2use crate::obis::ObisCode;
3use crate::types::attrs::ScalerUnit;
4use crate::types::{BerError, CosemDataType};
5use serde::{Deserialize, Serialize};
6use std::any::Any;
7
8/// Configuration structure used to build a [`RegisterTable`] object.
9#[derive(Clone, Serialize, Deserialize, Debug)]
10pub struct RegisterTableConfig {
11    /// Attribute 1: the object's logical name (OBIS code).
12    pub logical_name: ObisCode,
13    /// Attribute 2: the table cell values.
14    pub table_cell_values: Vec<CosemDataType>,
15    /// Attribute 3: `table_cell_definition` structure describing the cells.
16    pub table_cell_definition: CosemDataType,
17    /// Attribute 4: `scaler_unit` applied to every cell value.
18    pub scaler_unit: ScalerUnit,
19}
20
21/// `Register table` interface class (class_id = 61, version = 0) per
22/// IEC 62056-6-2 §4.3.7. Holds a table of identically-scaled register values
23/// selected by the table cell definition.
24#[derive(Clone, Serialize, Deserialize, Debug)]
25pub struct RegisterTable {
26    logical_name: ObisCode,
27    table_cell_values: Vec<CosemDataType>,
28    table_cell_definition: CosemDataType,
29    scaler_unit: ScalerUnit,
30}
31
32impl RegisterTable {
33    /// Builds a new [`RegisterTable`] from its configuration.
34    pub fn new(config: RegisterTableConfig) -> Self {
35        RegisterTable {
36            logical_name: config.logical_name,
37            table_cell_values: config.table_cell_values,
38            table_cell_definition: config.table_cell_definition,
39            scaler_unit: config.scaler_unit,
40        }
41    }
42
43    /// Method 1: `reset` — clears the table cell values.
44    fn reset(&mut self) -> CosemDataType {
45        self.table_cell_values.clear();
46        CosemDataType::Null
47    }
48
49    /// Returns the table cell values (attribute 2).
50    pub fn table_cell_values(&self) -> &[CosemDataType] {
51        &self.table_cell_values
52    }
53}
54
55impl InterfaceClass for RegisterTable {
56    fn class_id(&self) -> u16 {
57        61
58    }
59
60    fn version(&self) -> u8 {
61        0
62    }
63
64    fn logical_name(&self) -> &ObisCode {
65        &self.logical_name
66    }
67
68    fn attributes(&self) -> Vec<(u8, CosemDataType)> {
69        vec![
70            (1, CosemDataType::OctetString(self.logical_name.to_bytes())),
71            (2, CosemDataType::Array(self.table_cell_values.clone())),
72            (3, self.table_cell_definition.clone()),
73            (4, self.scaler_unit.clone().into()),
74        ]
75    }
76
77    fn methods(&self) -> Vec<(u8, String)> {
78        vec![(1, "reset".to_string()), (2, "capture".to_string())]
79    }
80
81    fn serialize_ber(&self, buf: &mut Vec<u8>) -> Result<(), BerError> {
82        let mut seq_buf = Vec::new();
83        CosemDataType::LongUnsigned(self.class_id()).serialize_ber(&mut seq_buf)?;
84        for (_, attr) in self.attributes() {
85            attr.serialize_ber(&mut seq_buf)?;
86        }
87        buf.push(0x02); // structure [2]
88        write_length(1 + self.attributes().len(), buf);
89        buf.extend_from_slice(&seq_buf);
90        Ok(())
91    }
92
93    fn deserialize_ber(&mut self, data: &[u8]) -> Result<(), BerError> {
94        let (tlv, rest) = CosemDataType::deserialize_ber(data)?;
95        if !rest.is_empty() {
96            return Err(BerError::InvalidTag);
97        }
98        let CosemDataType::Structure(seq) = tlv else {
99            return Err(BerError::InvalidTag);
100        };
101        if seq.len() != 5 {
102            return Err(BerError::InvalidLength);
103        }
104        if let CosemDataType::LongUnsigned(class_id) = seq[0] {
105            if class_id != self.class_id() {
106                return Err(BerError::InvalidValue);
107            }
108        } else {
109            return Err(BerError::InvalidTag);
110        }
111        if let CosemDataType::OctetString(obis) = &seq[1] {
112            if obis.len() == 6 {
113                self.logical_name = ObisCode::new(obis[0], obis[1], obis[2], obis[3], obis[4], obis[5]);
114            } else {
115                return Err(BerError::InvalidLength);
116            }
117        } else {
118            return Err(BerError::InvalidTag);
119        }
120        self.table_cell_values = match &seq[2] {
121            CosemDataType::Array(v) => v.clone(),
122            _ => return Err(BerError::InvalidTag),
123        };
124        self.table_cell_definition = seq[3].clone();
125        self.scaler_unit = ScalerUnit::try_from(&seq[4]).map_err(|_| BerError::InvalidValue)?;
126        Ok(())
127    }
128
129    fn invoke_method(&mut self, method_id: u8, _params: Option<CosemDataType>) -> Result<CosemDataType, String> {
130        match method_id {
131            1 => Ok(self.reset()),
132            // Method 2 `capture` is host-driven: the values live outside the
133            // object model, so capturing is delegated to the application.
134            2 => Ok(CosemDataType::Null),
135            _ => Err(format!("Method {method_id} not supported for Register table class")),
136        }
137    }
138
139    fn as_any(&self) -> &dyn Any {
140        self
141    }
142}
143
144/// Writes a BER length octet (short or long form).
145#[allow(clippy::cast_possible_truncation)] // length < 128 and num_octets in 1..=8 always fit u8
146fn write_length(length: usize, buf: &mut Vec<u8>) {
147    if length < 128 {
148        buf.push(length as u8);
149    } else {
150        let bytes = (length as u64).to_be_bytes();
151        let first_non_zero = bytes.iter().position(|&b| b != 0).unwrap_or(7);
152        let num_octets = 8 - first_non_zero;
153        buf.push(0x80 | num_octets as u8);
154        buf.extend_from_slice(&bytes[first_non_zero..]);
155    }
156}
157
158#[cfg(test)]
159mod tests {
160    use super::*;
161
162    fn sample() -> RegisterTable {
163        RegisterTable::new(RegisterTableConfig {
164            logical_name: ObisCode::new(1, 0, 98, 10, 0, 255),
165            table_cell_values: vec![CosemDataType::DoubleLongUnsigned(100), CosemDataType::DoubleLongUnsigned(200)],
166            table_cell_definition: CosemDataType::Structure(vec![
167                CosemDataType::LongUnsigned(3),
168                CosemDataType::OctetString(vec![1, 0, 1, 8, 0, 255]),
169                CosemDataType::Integer(2),
170            ]),
171            scaler_unit: ScalerUnit { scaler: 0, unit: 30 },
172        })
173    }
174
175    #[test]
176    fn class_id_and_attributes() {
177        let obj = sample();
178        assert_eq!(obj.class_id(), 61);
179        assert_eq!(obj.attributes().len(), 4);
180        assert_eq!(obj.methods().len(), 2);
181    }
182
183    #[test]
184    fn reset_clears_values() {
185        let mut obj = sample();
186        obj.invoke_method(1, None).unwrap();
187        assert!(obj.table_cell_values().is_empty());
188    }
189
190    #[test]
191    fn round_trip() {
192        let obj = sample();
193        let mut buf = Vec::new();
194        obj.serialize_ber(&mut buf).unwrap();
195        let mut decoded = sample();
196        decoded.deserialize_ber(&buf).unwrap();
197        assert_eq!(decoded.attributes(), obj.attributes());
198    }
199}