use crate::error::MessageError;
pub const FUNCTION_CODE: u8 = 0x03;
pub const MAX_REGISTERS: usize = 125;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ReadHoldingRegistersRequest {
pub starting_address: u16,
pub quantity: u16,
}
impl ReadHoldingRegistersRequest {
pub(crate) fn decode(data: &[u8]) -> Result<Self, MessageError> {
let [a1, a0, q1, q0, ..] = data else {
return Err(MessageError::UnexpectedEof);
};
let quantity = u16::from_be_bytes([*q1, *q0]);
if usize::from(quantity) > MAX_REGISTERS {
return Err(MessageError::TooManyItems {
max: MAX_REGISTERS,
got: usize::from(quantity),
});
}
Ok(Self {
starting_address: u16::from_be_bytes([*a1, *a0]),
quantity,
})
}
pub(crate) fn encode(self, buf: &mut [u8]) -> Result<usize, MessageError> {
let [d0, d1, d2, d3, ..] = buf else {
return Err(MessageError::BufferFull);
};
[*d0, *d1] = self.starting_address.to_be_bytes();
[*d2, *d3] = self.quantity.to_be_bytes();
Ok(4)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ReadHoldingRegistersResponse {
pub count: u8,
pub registers: [u16; MAX_REGISTERS],
}
impl ReadHoldingRegistersResponse {
pub(crate) fn decode(data: &[u8]) -> Result<Self, MessageError> {
let [byte_count, rest @ ..] = data else {
return Err(MessageError::UnexpectedEof);
};
if usize::from(*byte_count) > rest.len() {
return Err(MessageError::ByteCountMismatch {
declared: *byte_count,
available: rest.len(),
});
}
let count = byte_count / 2;
if usize::from(count) > MAX_REGISTERS {
return Err(MessageError::TooManyItems {
max: MAX_REGISTERS,
got: usize::from(count),
});
}
let mut registers = [0u16; MAX_REGISTERS];
for (i, reg) in registers.iter_mut().take(usize::from(count)).enumerate() {
*reg = u16::from_be_bytes([rest[2 * i], rest[2 * i + 1]]);
}
Ok(Self { count, registers })
}
pub(crate) fn encode(self, buf: &mut [u8]) -> Result<usize, MessageError> {
if usize::from(self.count) > MAX_REGISTERS {
return Err(MessageError::TooManyItems {
max: MAX_REGISTERS,
got: usize::from(self.count),
});
}
let byte_count = usize::from(self.count) * 2;
let total = 1 + byte_count;
let Some(dest) = buf.get_mut(..total) else {
return Err(MessageError::BufferFull);
};
#[allow(
clippy::cast_possible_truncation,
reason = "checked above: count <= MAX_REGISTERS (125), so count * 2 <= 250, always fits in u8"
)]
{
dest[0] = byte_count as u8;
}
for (i, reg) in self
.registers
.iter()
.take(usize::from(self.count))
.enumerate()
{
dest[1 + 2 * i..3 + 2 * i].copy_from_slice(®.to_be_bytes());
}
Ok(total)
}
}
#[cfg(kani)]
mod kani_proofs {
use super::{MAX_REGISTERS, ReadHoldingRegistersResponse};
#[kani::proof]
#[kani::unwind(126)]
fn encode_never_panics() {
let count: u8 = kani::any();
let registers = [0u16; MAX_REGISTERS];
let msg = ReadHoldingRegistersResponse { count, registers };
let mut buf = [0u8; 1 + MAX_REGISTERS * 2];
let _ = msg.encode(&mut buf);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn decodes_a_reference_request() {
let data = [0x00, 0x6B, 0x00, 0x03];
let req = ReadHoldingRegistersRequest::decode(&data).unwrap();
assert_eq!(req.starting_address, 0x006B);
assert_eq!(req.quantity, 3);
}
#[test]
fn rejects_a_request_quantity_over_the_spec_maximum() {
let data = [0x00, 0x00, 0x00, 0x7E];
assert_eq!(
ReadHoldingRegistersRequest::decode(&data),
Err(MessageError::TooManyItems {
max: MAX_REGISTERS,
got: 126
})
);
}
#[test]
fn decodes_a_reference_response() {
let data = [0x06, 0x02, 0x2B, 0x00, 0x00, 0x00, 0x64];
let resp = ReadHoldingRegistersResponse::decode(&data).unwrap();
assert_eq!(resp.count, 3);
assert_eq!(&resp.registers[..3], &[0x022B, 0x0000, 0x0064]);
}
#[test]
fn rejects_a_byte_count_longer_than_the_data() {
let data = [0x04, 0x00, 0x01];
assert_eq!(
ReadHoldingRegistersResponse::decode(&data),
Err(MessageError::ByteCountMismatch {
declared: 4,
available: 2
})
);
}
#[test]
fn round_trips_a_request() {
let original = ReadHoldingRegistersRequest {
starting_address: 0x0100,
quantity: 10,
};
let mut buf = [0u8; 4];
let n = original.encode(&mut buf).unwrap();
assert_eq!(
ReadHoldingRegistersRequest::decode(&buf[..n]).unwrap(),
original
);
}
#[test]
fn round_trips_a_response() {
let mut registers = [0u16; MAX_REGISTERS];
registers[0] = 0x1234;
registers[1] = 0xABCD;
let original = ReadHoldingRegistersResponse {
count: 2,
registers,
};
let mut buf = [0u8; 1 + MAX_REGISTERS * 2];
let n = original.encode(&mut buf).unwrap();
let decoded = ReadHoldingRegistersResponse::decode(&buf[..n]).unwrap();
assert_eq!(decoded.count, 2);
assert_eq!(&decoded.registers[..2], ®isters[..2]);
}
#[test]
fn encode_rejects_a_count_wider_than_the_backing_array() {
let bad = ReadHoldingRegistersResponse {
count: 200,
registers: [0xAAAAu16; MAX_REGISTERS],
};
let mut buf = [0u8; 1000];
assert_eq!(
bad.encode(&mut buf),
Err(MessageError::TooManyItems {
max: MAX_REGISTERS,
got: 200
})
);
}
}