1use crate::frame::{ModbusError, RegisterCount};
8
9#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
20pub enum RegisterKind {
21 U16,
23 I16,
25 U32Be,
27 F32Be,
29}
30
31#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
39pub struct Scale(f64);
40
41impl RegisterKind {
42 #[must_use]
47 pub const fn registers(self) -> u16 {
48 match self {
49 Self::U16 | Self::I16 => 1,
50 Self::U32Be | Self::F32Be => 2,
51 }
52 }
53
54 #[must_use]
60 pub const fn fits(self, count: RegisterCount) -> bool {
61 count.get() == self.registers()
62 }
63
64 #[must_use]
66 pub const fn name(self) -> &'static str {
67 match self {
68 Self::U16 => "u16",
69 Self::I16 => "i16",
70 Self::U32Be => "u32be",
71 Self::F32Be => "f32be",
72 }
73 }
74
75 pub fn decode(self, words: &[u16]) -> Result<f64, ModbusError> {
86 match (self, words) {
87 (Self::U16, [word]) => Ok(f64::from(*word)),
88 (Self::I16, [word]) => Ok(f64::from(i16::from_be_bytes(word.to_be_bytes()))),
89 (Self::U32Be, [high, low]) => Ok(f64::from(wide(*high, *low))),
90 (Self::F32Be, [high, low]) => Ok(f64::from(f32::from_bits(wide(*high, *low)))),
93 (Self::U16 | Self::I16 | Self::U32Be | Self::F32Be, _) => Err(ModbusError::WordCount {
97 kind: self.name(),
98 expected: self.registers(),
99 found: words.len(),
100 }),
101 }
102 }
103}
104
105fn wide(high: u16, low: u16) -> u32 {
107 (u32::from(high) << u16::BITS) | u32::from(low)
108}
109
110impl Scale {
111 pub fn new(factor: f64) -> Result<Self, ModbusError> {
118 if !factor.is_finite() {
119 return Err(ModbusError::NonFiniteScale);
120 }
121 if factor == 0.0 {
122 return Err(ModbusError::ZeroScale);
123 }
124 Ok(Self(factor))
125 }
126
127 #[must_use]
130 pub const fn one() -> Self {
131 Self(1.0)
132 }
133
134 #[must_use]
136 pub const fn get(self) -> f64 {
137 self.0
138 }
139
140 #[must_use]
142 pub fn apply(self, value: f64) -> f64 {
143 value * self.0
144 }
145}
146
147#[cfg(test)]
148mod tests {
149 use super::{RegisterKind, Scale};
150 use crate::frame::{ModbusError, RegisterCount};
151
152 #[test]
158 fn a_float_register_pair_decodes_to_the_number_its_manual_prints() {
159 let decoded = RegisterKind::F32Be.decode(&[0x4248, 0x0000]);
160
161 assert_eq!(decoded, Ok(50.0));
162 }
163
164 #[test]
165 fn a_signed_register_decodes_below_zero() {
166 let decoded = RegisterKind::I16.decode(&[0xFF38]);
167
168 assert_eq!(decoded, Ok(-200.0));
169 }
170
171 #[test]
172 fn the_same_word_is_two_numbers_depending_on_the_kind() {
173 assert_eq!(RegisterKind::U16.decode(&[0xFFFF]), Ok(65_535.0));
174 assert_eq!(RegisterKind::I16.decode(&[0xFFFF]), Ok(-1.0));
175 }
176
177 #[test]
178 fn a_wide_register_pair_decodes_most_significant_word_first() {
179 let decoded = RegisterKind::U32Be.decode(&[0x0001, 0x86A0]);
180
181 assert_eq!(decoded, Ok(100_000.0));
182 }
183
184 #[test]
185 fn each_kind_knows_how_many_registers_it_occupies() {
186 assert_eq!(RegisterKind::U16.registers(), 1);
187 assert_eq!(RegisterKind::I16.registers(), 1);
188 assert_eq!(RegisterKind::U32Be.registers(), 2);
189 assert_eq!(RegisterKind::F32Be.registers(), 2);
190 }
191
192 #[test]
193 fn each_kind_names_itself() {
194 assert_eq!(RegisterKind::U16.name(), "u16");
195 assert_eq!(RegisterKind::I16.name(), "i16");
196 assert_eq!(RegisterKind::U32Be.name(), "u32be");
197 assert_eq!(RegisterKind::F32Be.name(), "f32be");
198 }
199
200 #[test]
203 fn a_count_fits_only_the_kind_that_is_that_wide() {
204 let one = RegisterCount::new(1).expect("one register is a count");
205 let two = RegisterCount::new(2).expect("two registers is a count");
206
207 assert!(RegisterKind::I16.fits(one));
208 assert!(!RegisterKind::I16.fits(two));
209 assert!(RegisterKind::F32Be.fits(two));
210 assert!(!RegisterKind::F32Be.fits(one));
211 }
212
213 #[test]
215 fn a_wide_kind_handed_one_word_is_refused() {
216 let refused = RegisterKind::U32Be.decode(&[0x0001]);
217
218 assert_eq!(
219 refused,
220 Err(ModbusError::WordCount {
221 kind: "u32be",
222 expected: 2,
223 found: 1,
224 })
225 );
226 }
227
228 #[test]
229 fn a_narrow_kind_handed_two_words_is_refused() {
230 let refused = RegisterKind::U16.decode(&[1, 2]);
231
232 assert_eq!(
233 refused,
234 Err(ModbusError::WordCount {
235 kind: "u16",
236 expected: 1,
237 found: 2,
238 })
239 );
240 }
241
242 #[test]
243 fn a_kind_handed_no_words_is_refused() {
244 let refused = RegisterKind::F32Be.decode(&[]);
245
246 assert_eq!(
247 refused,
248 Err(ModbusError::WordCount {
249 kind: "f32be",
250 expected: 2,
251 found: 0,
252 })
253 );
254 }
255
256 fn near(found: f64, expected: f64) -> bool {
260 (found - expected).abs() < 1e-9
261 }
262
263 #[test]
264 fn a_scale_turns_tenths_into_the_unit() {
265 let scale = Scale::new(0.1).expect("a tenth is a scale");
266
267 let scaled = scale.apply(2500.0);
268
269 assert!(near(scaled, 250.0), "2500 tenths is 250, found {scaled}");
270 assert!(near(scale.get(), 0.1));
271 }
272
273 #[test]
274 fn a_scale_of_one_changes_nothing() {
275 assert!(near(Scale::one().apply(412.0), 412.0));
276 }
277
278 #[test]
281 fn a_negative_scale_is_a_map_and_is_accepted() {
282 let scale = Scale::new(-1.0).expect("a sign flip is a scale");
283
284 assert!(near(scale.apply(250.0), -250.0));
285 }
286
287 #[test]
288 fn a_scale_of_zero_is_refused() {
289 assert_eq!(Scale::new(0.0), Err(ModbusError::ZeroScale));
290 }
291
292 #[test]
293 fn a_scale_that_is_not_a_number_is_refused() {
294 assert_eq!(Scale::new(f64::NAN), Err(ModbusError::NonFiniteScale));
295 assert_eq!(Scale::new(f64::INFINITY), Err(ModbusError::NonFiniteScale));
296 assert_eq!(
297 Scale::new(f64::NEG_INFINITY),
298 Err(ModbusError::NonFiniteScale)
299 );
300 }
301}