use crate::error::MessageError;
pub const FUNCTION_CODE: u8 = 0x01;
pub const MAX_COILS: usize = 2000;
pub const MAX_COIL_BYTES: usize = MAX_COILS.div_ceil(8);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ReadCoilsRequest {
pub starting_address: u16,
pub quantity: u16,
}
impl ReadCoilsRequest {
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_COILS {
return Err(MessageError::TooManyItems {
max: MAX_COILS,
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 ReadCoilsResponse {
pub byte_count: u8,
pub bits: [u8; MAX_COIL_BYTES],
}
impl ReadCoilsResponse {
#[must_use]
pub fn get(&self, index: usize) -> Option<bool> {
if index >= usize::from(self.byte_count) * 8 {
return None;
}
Some(self.bits[index / 8] & (1 << (index % 8)) != 0)
}
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(),
});
}
if usize::from(*byte_count) > MAX_COIL_BYTES {
return Err(MessageError::TooManyItems {
max: MAX_COIL_BYTES,
got: usize::from(*byte_count),
});
}
let mut bits = [0u8; MAX_COIL_BYTES];
bits[..usize::from(*byte_count)].copy_from_slice(&rest[..usize::from(*byte_count)]);
Ok(Self {
byte_count: *byte_count,
bits,
})
}
pub(crate) fn encode(&self, buf: &mut [u8]) -> Result<usize, MessageError> {
if usize::from(self.byte_count) > MAX_COIL_BYTES {
return Err(MessageError::TooManyItems {
max: MAX_COIL_BYTES,
got: usize::from(self.byte_count),
});
}
let total = 1 + usize::from(self.byte_count);
let Some(dest) = buf.get_mut(..total) else {
return Err(MessageError::BufferFull);
};
dest[0] = self.byte_count;
dest[1..].copy_from_slice(&self.bits[..usize::from(self.byte_count)]);
Ok(total)
}
}
#[cfg(kani)]
mod kani_proofs {
use super::{MAX_COIL_BYTES, ReadCoilsResponse};
#[kani::proof]
fn encode_never_panics() {
let byte_count: u8 = kani::any();
let bits = [0u8; MAX_COIL_BYTES];
let msg = ReadCoilsResponse { byte_count, bits };
let mut buf = [0u8; 1 + MAX_COIL_BYTES];
let _ = msg.encode(&mut buf);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn decodes_a_reference_request() {
let data = [0x00, 0x13, 0x00, 0x25];
let req = ReadCoilsRequest::decode(&data).unwrap();
assert_eq!(req.starting_address, 0x0013);
assert_eq!(req.quantity, 0x0025);
}
#[test]
fn rejects_a_request_quantity_over_the_spec_maximum() {
let data = [0x00, 0x00, 0x07, 0xD1];
assert_eq!(
ReadCoilsRequest::decode(&data),
Err(MessageError::TooManyItems {
max: MAX_COILS,
got: 2001
})
);
}
#[test]
fn decodes_a_reference_response() {
let data = [0x05, 0xCD, 0x6B, 0x05, 0x01, 0x00];
let resp = ReadCoilsResponse::decode(&data).unwrap();
assert_eq!(resp.byte_count, 5);
assert_eq!(resp.get(0), Some(true));
assert_eq!(resp.get(1), Some(false));
assert_eq!(resp.get(2), Some(true));
assert_eq!(resp.get(3), Some(true));
assert_eq!(resp.get(4), Some(false));
assert_eq!(resp.get(5), Some(false));
assert_eq!(resp.get(6), Some(true));
assert_eq!(resp.get(7), Some(true));
assert_eq!(resp.get(24), Some(true));
assert_eq!(resp.get(25), Some(false));
assert_eq!(resp.get(40), None); }
#[test]
fn rejects_a_byte_count_longer_than_the_data() {
let data = [0x05, 0xCD];
assert_eq!(
ReadCoilsResponse::decode(&data),
Err(MessageError::ByteCountMismatch {
declared: 5,
available: 1
})
);
}
#[test]
fn round_trips_a_request() {
let original = ReadCoilsRequest {
starting_address: 0x0013,
quantity: 0x0025,
};
let mut buf = [0u8; 4];
let n = original.encode(&mut buf).unwrap();
assert_eq!(ReadCoilsRequest::decode(&buf[..n]).unwrap(), original);
}
#[test]
fn round_trips_a_response() {
let mut bits = [0u8; MAX_COIL_BYTES];
bits[0] = 0xCD;
bits[1] = 0x6B;
let original = ReadCoilsResponse {
byte_count: 2,
bits,
};
let mut buf = [0u8; 1 + MAX_COIL_BYTES];
let n = original.encode(&mut buf).unwrap();
let decoded = ReadCoilsResponse::decode(&buf[..n]).unwrap();
assert_eq!(decoded, original);
}
#[test]
fn encode_rejects_a_byte_count_wider_than_the_backing_array() {
let bad = ReadCoilsResponse {
byte_count: 255,
bits: [0u8; MAX_COIL_BYTES],
};
let mut buf = [0u8; 1000];
assert_eq!(
bad.encode(&mut buf),
Err(MessageError::TooManyItems {
max: MAX_COIL_BYTES,
got: 255
})
);
}
}