mod exception;
mod read_coils;
mod read_holding_registers;
mod write_single_register;
pub use exception::{ExceptionCode, ExceptionResponse};
pub use read_coils::{ReadCoilsRequest, ReadCoilsResponse};
pub use read_holding_registers::{ReadHoldingRegistersRequest, ReadHoldingRegistersResponse};
pub use write_single_register::WriteSingleRegister;
use crate::error::MessageError;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum ModbusRequest {
ReadHoldingRegisters(ReadHoldingRegistersRequest),
ReadCoils(ReadCoilsRequest),
WriteSingleRegister(WriteSingleRegister),
}
impl ModbusRequest {
pub fn decode(function_code: u8, data: &[u8]) -> Result<Self, MessageError> {
match function_code {
read_holding_registers::FUNCTION_CODE => Ok(Self::ReadHoldingRegisters(
ReadHoldingRegistersRequest::decode(data)?,
)),
read_coils::FUNCTION_CODE => Ok(Self::ReadCoils(ReadCoilsRequest::decode(data)?)),
write_single_register::FUNCTION_CODE => Ok(Self::WriteSingleRegister(
WriteSingleRegister::decode(data)?,
)),
other => Err(MessageError::UnknownFunctionCode(other)),
}
}
#[must_use]
pub const fn function_code(&self) -> u8 {
match self {
Self::ReadHoldingRegisters(_) => read_holding_registers::FUNCTION_CODE,
Self::ReadCoils(_) => read_coils::FUNCTION_CODE,
Self::WriteSingleRegister(_) => write_single_register::FUNCTION_CODE,
}
}
pub fn encode(&self, buf: &mut [u8]) -> Result<usize, MessageError> {
match self {
Self::ReadHoldingRegisters(m) => m.encode(buf),
Self::ReadCoils(m) => m.encode(buf),
Self::WriteSingleRegister(m) => m.encode(buf),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum ModbusResponse {
ReadHoldingRegisters(ReadHoldingRegistersResponse),
ReadCoils(ReadCoilsResponse),
WriteSingleRegister(WriteSingleRegister),
Exception(ExceptionResponse),
}
impl ModbusResponse {
pub fn decode(function_code: u8, data: &[u8]) -> Result<Self, MessageError> {
if function_code & 0x80 != 0 {
return Ok(Self::Exception(ExceptionResponse::decode(
function_code,
data,
)?));
}
match function_code {
read_holding_registers::FUNCTION_CODE => Ok(Self::ReadHoldingRegisters(
ReadHoldingRegistersResponse::decode(data)?,
)),
read_coils::FUNCTION_CODE => Ok(Self::ReadCoils(ReadCoilsResponse::decode(data)?)),
write_single_register::FUNCTION_CODE => Ok(Self::WriteSingleRegister(
WriteSingleRegister::decode(data)?,
)),
other => Err(MessageError::UnknownFunctionCode(other)),
}
}
#[must_use]
pub const fn function_code(&self) -> u8 {
match self {
Self::ReadHoldingRegisters(_) => read_holding_registers::FUNCTION_CODE,
Self::ReadCoils(_) => read_coils::FUNCTION_CODE,
Self::WriteSingleRegister(_) => write_single_register::FUNCTION_CODE,
Self::Exception(e) => e.function_code | 0x80,
}
}
pub fn encode(&self, buf: &mut [u8]) -> Result<usize, MessageError> {
match self {
Self::ReadHoldingRegisters(m) => m.encode(buf),
Self::ReadCoils(m) => m.encode(buf),
Self::WriteSingleRegister(m) => m.encode(buf),
Self::Exception(m) => m.encode(buf),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn decodes_a_reference_request() {
let data = [0x00, 0x6B, 0x00, 0x03];
let req = ModbusRequest::decode(0x03, &data).unwrap();
assert_eq!(req.function_code(), 0x03);
assert!(matches!(req, ModbusRequest::ReadHoldingRegisters(_)));
}
#[test]
fn decodes_a_reference_response() {
let data = [0x06, 0x02, 0x2B, 0x00, 0x00, 0x00, 0x64];
let resp = ModbusResponse::decode(0x03, &data).unwrap();
assert_eq!(resp.function_code(), 0x03);
assert!(matches!(resp, ModbusResponse::ReadHoldingRegisters(_)));
}
#[test]
fn decodes_an_exception_response_regardless_of_which_function_failed() {
let data = [0x02];
let resp = ModbusResponse::decode(0x83, &data).unwrap();
assert_eq!(resp.function_code(), 0x83);
let ModbusResponse::Exception(exc) = resp else {
panic!("expected Exception");
};
assert_eq!(exc.function_code, 0x03);
}
#[test]
fn rejects_an_unknown_function_code() {
assert_eq!(
ModbusRequest::decode(0x2B, &[0, 0, 0, 0]),
Err(MessageError::UnknownFunctionCode(0x2B))
);
}
#[test]
fn encode_then_decode_round_trips_a_request() {
let original = ModbusRequest::WriteSingleRegister(WriteSingleRegister {
address: 5,
value: 42,
});
let mut buf = [0u8; 4];
let n = original.encode(&mut buf).unwrap();
let decoded = ModbusRequest::decode(original.function_code(), &buf[..n]).unwrap();
assert_eq!(decoded, original);
}
}
#[cfg(test)]
mod proptests {
extern crate std;
use proptest::prelude::*;
use super::{ModbusRequest, ModbusResponse, ReadCoilsResponse, ReadHoldingRegistersResponse};
proptest! {
#[test]
fn request_decode_never_panics(function_code: u8, data in prop::collection::vec(any::<u8>(), 0..260)) {
let _ = ModbusRequest::decode(function_code, &data);
}
#[test]
fn response_decode_never_panics(function_code: u8, data in prop::collection::vec(any::<u8>(), 0..260)) {
let _ = ModbusResponse::decode(function_code, &data);
}
#[test]
fn request_decode_never_panics_for_known_function_codes(
function_code in prop_oneof![Just(1u8), Just(3u8), Just(6u8)],
data in prop::collection::vec(any::<u8>(), 0..260),
) {
let _ = ModbusRequest::decode(function_code, &data);
}
#[test]
fn response_decode_never_panics_for_known_function_codes(
function_code in prop_oneof![Just(1u8), Just(3u8), Just(6u8), Just(0x81u8), Just(0x83u8), Just(0x86u8)],
data in prop::collection::vec(any::<u8>(), 0..260),
) {
let _ = ModbusResponse::decode(function_code, &data);
}
#[test]
fn read_holding_registers_response_encode_never_panics(count: u8) {
let msg = ReadHoldingRegistersResponse {
count,
registers: [0u16; super::read_holding_registers::MAX_REGISTERS],
};
let mut buf = [0u8; 1024];
let _ = msg.encode(&mut buf);
}
#[test]
fn read_coils_response_encode_never_panics(byte_count: u8) {
let msg = ReadCoilsResponse {
byte_count,
bits: [0u8; super::read_coils::MAX_COIL_BYTES],
};
let mut buf = [0u8; 1024];
let _ = msg.encode(&mut buf);
}
}
}