use crate::frame::{ModbusError, RegisterCount};
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum RegisterKind {
U16,
I16,
U32Be,
F32Be,
}
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct Scale(f64);
impl RegisterKind {
#[must_use]
pub const fn registers(self) -> u16 {
match self {
Self::U16 | Self::I16 => 1,
Self::U32Be | Self::F32Be => 2,
}
}
#[must_use]
pub const fn fits(self, count: RegisterCount) -> bool {
count.get() == self.registers()
}
#[must_use]
pub const fn name(self) -> &'static str {
match self {
Self::U16 => "u16",
Self::I16 => "i16",
Self::U32Be => "u32be",
Self::F32Be => "f32be",
}
}
pub fn decode(self, words: &[u16]) -> Result<f64, ModbusError> {
match (self, words) {
(Self::U16, [word]) => Ok(f64::from(*word)),
(Self::I16, [word]) => Ok(f64::from(i16::from_be_bytes(word.to_be_bytes()))),
(Self::U32Be, [high, low]) => Ok(f64::from(wide(*high, *low))),
(Self::F32Be, [high, low]) => Ok(f64::from(f32::from_bits(wide(*high, *low)))),
(Self::U16 | Self::I16 | Self::U32Be | Self::F32Be, _) => Err(ModbusError::WordCount {
kind: self.name(),
expected: self.registers(),
found: words.len(),
}),
}
}
}
fn wide(high: u16, low: u16) -> u32 {
(u32::from(high) << u16::BITS) | u32::from(low)
}
impl Scale {
pub fn new(factor: f64) -> Result<Self, ModbusError> {
if !factor.is_finite() {
return Err(ModbusError::NonFiniteScale);
}
if factor == 0.0 {
return Err(ModbusError::ZeroScale);
}
Ok(Self(factor))
}
#[must_use]
pub const fn one() -> Self {
Self(1.0)
}
#[must_use]
pub const fn get(self) -> f64 {
self.0
}
#[must_use]
pub fn apply(self, value: f64) -> f64 {
value * self.0
}
}
#[cfg(test)]
mod tests {
use super::{RegisterKind, Scale};
use crate::frame::{ModbusError, RegisterCount};
#[test]
fn a_float_register_pair_decodes_to_the_number_its_manual_prints() {
let decoded = RegisterKind::F32Be.decode(&[0x4248, 0x0000]);
assert_eq!(decoded, Ok(50.0));
}
#[test]
fn a_signed_register_decodes_below_zero() {
let decoded = RegisterKind::I16.decode(&[0xFF38]);
assert_eq!(decoded, Ok(-200.0));
}
#[test]
fn the_same_word_is_two_numbers_depending_on_the_kind() {
assert_eq!(RegisterKind::U16.decode(&[0xFFFF]), Ok(65_535.0));
assert_eq!(RegisterKind::I16.decode(&[0xFFFF]), Ok(-1.0));
}
#[test]
fn a_wide_register_pair_decodes_most_significant_word_first() {
let decoded = RegisterKind::U32Be.decode(&[0x0001, 0x86A0]);
assert_eq!(decoded, Ok(100_000.0));
}
#[test]
fn each_kind_knows_how_many_registers_it_occupies() {
assert_eq!(RegisterKind::U16.registers(), 1);
assert_eq!(RegisterKind::I16.registers(), 1);
assert_eq!(RegisterKind::U32Be.registers(), 2);
assert_eq!(RegisterKind::F32Be.registers(), 2);
}
#[test]
fn each_kind_names_itself() {
assert_eq!(RegisterKind::U16.name(), "u16");
assert_eq!(RegisterKind::I16.name(), "i16");
assert_eq!(RegisterKind::U32Be.name(), "u32be");
assert_eq!(RegisterKind::F32Be.name(), "f32be");
}
#[test]
fn a_count_fits_only_the_kind_that_is_that_wide() {
let one = RegisterCount::new(1).expect("one register is a count");
let two = RegisterCount::new(2).expect("two registers is a count");
assert!(RegisterKind::I16.fits(one));
assert!(!RegisterKind::I16.fits(two));
assert!(RegisterKind::F32Be.fits(two));
assert!(!RegisterKind::F32Be.fits(one));
}
#[test]
fn a_wide_kind_handed_one_word_is_refused() {
let refused = RegisterKind::U32Be.decode(&[0x0001]);
assert_eq!(
refused,
Err(ModbusError::WordCount {
kind: "u32be",
expected: 2,
found: 1,
})
);
}
#[test]
fn a_narrow_kind_handed_two_words_is_refused() {
let refused = RegisterKind::U16.decode(&[1, 2]);
assert_eq!(
refused,
Err(ModbusError::WordCount {
kind: "u16",
expected: 1,
found: 2,
})
);
}
#[test]
fn a_kind_handed_no_words_is_refused() {
let refused = RegisterKind::F32Be.decode(&[]);
assert_eq!(
refused,
Err(ModbusError::WordCount {
kind: "f32be",
expected: 2,
found: 0,
})
);
}
fn near(found: f64, expected: f64) -> bool {
(found - expected).abs() < 1e-9
}
#[test]
fn a_scale_turns_tenths_into_the_unit() {
let scale = Scale::new(0.1).expect("a tenth is a scale");
let scaled = scale.apply(2500.0);
assert!(near(scaled, 250.0), "2500 tenths is 250, found {scaled}");
assert!(near(scale.get(), 0.1));
}
#[test]
fn a_scale_of_one_changes_nothing() {
assert!(near(Scale::one().apply(412.0), 412.0));
}
#[test]
fn a_negative_scale_is_a_map_and_is_accepted() {
let scale = Scale::new(-1.0).expect("a sign flip is a scale");
assert!(near(scale.apply(250.0), -250.0));
}
#[test]
fn a_scale_of_zero_is_refused() {
assert_eq!(Scale::new(0.0), Err(ModbusError::ZeroScale));
}
#[test]
fn a_scale_that_is_not_a_number_is_refused() {
assert_eq!(Scale::new(f64::NAN), Err(ModbusError::NonFiniteScale));
assert_eq!(Scale::new(f64::INFINITY), Err(ModbusError::NonFiniteScale));
assert_eq!(
Scale::new(f64::NEG_INFINITY),
Err(ModbusError::NonFiniteScale)
);
}
}