use crate::classes::data::Data;
use crate::types::CosemDataType;
use super::obis;
pub mod service_id {
pub const GET: u8 = 1;
pub const SET: u8 = 2;
pub const ACTION: u8 = 3;
}
#[derive(Clone, Debug, Default)]
pub struct Script {
pub service_id: u8,
pub class_id: u8,
pub obis: Vec<u8>,
pub index: u8,
pub range_descriptor: Option<CosemDataType>,
pub entry_descriptor: Option<CosemDataType>,
pub value: Option<CosemDataType>,
}
impl Script {
fn to_structure(&self) -> CosemDataType {
let opt = |v: &Option<CosemDataType>| v.clone().unwrap_or(CosemDataType::Null);
CosemDataType::Structure(vec![
CosemDataType::Unsigned(self.service_id),
CosemDataType::Unsigned(self.class_id),
CosemDataType::OctetString(self.obis.clone()),
CosemDataType::Unsigned(self.index),
opt(&self.range_descriptor),
opt(&self.entry_descriptor),
opt(&self.value),
])
}
}
#[derive(Clone, Debug, Default)]
pub struct ExecutionTime {
pub time: Vec<u8>,
pub date: Vec<u8>,
}
#[derive(Clone, Debug, Default)]
pub struct ExchangeTask {
pub task_id: u32,
pub meter_ids: Vec<Vec<u8>>,
pub scripts: Vec<Script>,
pub execution_type: u8,
pub execution_times: Vec<ExecutionTime>,
pub priority: u16,
}
impl ExchangeTask {
fn to_structure(&self) -> CosemDataType {
let meter_ids = self.meter_ids.iter().map(|m| CosemDataType::OctetString(m.clone())).collect();
let scripts = self.scripts.iter().map(Script::to_structure).collect();
let times = self
.execution_times
.iter()
.map(|t| {
CosemDataType::Structure(vec![
CosemDataType::OctetString(t.time.clone()),
CosemDataType::OctetString(t.date.clone()),
])
})
.collect();
#[allow(clippy::cast_possible_truncation)]
let task_id = self.task_id as u16;
CosemDataType::Structure(vec![
CosemDataType::LongUnsigned(task_id),
CosemDataType::Array(meter_ids),
CosemDataType::Array(scripts),
CosemDataType::Enum(self.execution_type),
CosemDataType::Array(times),
CosemDataType::LongUnsigned(self.priority),
])
}
}
#[derive(Clone, Debug, Default)]
pub struct ExchangeTasks {
tasks: Vec<ExchangeTask>,
}
impl ExchangeTasks {
pub fn new() -> Self {
Self::default()
}
pub fn add(&mut self, task: ExchangeTask) {
self.tasks.push(task);
}
pub fn find(&self, task_id: u32) -> Option<&ExchangeTask> {
self.tasks.iter().find(|t| t.task_id == task_id)
}
pub fn build(&self) -> Data {
let array = self.tasks.iter().map(ExchangeTask::to_structure).collect();
Data::new(obis::data_exchange_tasks(), CosemDataType::Array(array))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::interface::InterfaceClass;
#[test]
fn exchange_tasks_build_data_object() {
let mut tasks = ExchangeTasks::new();
tasks.add(ExchangeTask {
task_id: 7,
meter_ids: vec![b"SIT12260004".to_vec()],
scripts: vec![Script {
service_id: service_id::GET,
class_id: 1,
obis: vec![1, 0, 1, 8, 0, 255],
index: 2,
..Default::default()
}],
execution_type: 0,
execution_times: vec![ExecutionTime { time: vec![0, 0, 0, 0], date: vec![0xFF; 5] }],
priority: 1,
});
assert_eq!(tasks.find(7).unwrap().priority, 1);
assert!(tasks.find(9).is_none());
let object = tasks.build();
assert_eq!(object.class_id(), 1);
assert_eq!(object.logical_name(), &obis::data_exchange_tasks());
let CosemDataType::Array(rows) = &object.attributes()[1].1 else { panic!("array") };
assert_eq!(rows.len(), 1);
let CosemDataType::Structure(fields) = &rows[0] else { panic!("exchange structure") };
assert_eq!(fields.len(), 6);
assert_eq!(fields[0], CosemDataType::LongUnsigned(7));
let CosemDataType::Array(scripts) = &fields[2] else { panic!("scripts array") };
let CosemDataType::Structure(script) = &scripts[0] else { panic!("script structure") };
assert_eq!(script.len(), 7);
assert_eq!(script[0], CosemDataType::Unsigned(service_id::GET));
assert_eq!(script[4], CosemDataType::Null);
}
}