add defmt feature

Author: paul-fornage

Cargo.toml

@@ -16,12 +16,14 @@ all-features = true
 [dependencies]
 log = "0.4.26"
 byteorder = { version =  "1.5.0", default-features = false }
+defmt = {version = "1.0.1", optional = true}
 
 [features]
 default = ["tcp", "rtu"]
 tcp = []
 rtu = []
 std = ["byteorder/std"]
+defmt = ["dep:defmt"]
 
 [badges]
 maintenance = { status = "actively-developed" }

src/codec/mod.rs

@@ -5,6 +5,7 @@ pub mod rtu;
 pub mod tcp;
 
 /// The type of decoding
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum DecoderType {
     Request,

src/codec/rtu/mod.rs

@@ -12,13 +12,15 @@ pub use crate::frame::rtu::*;
 const MAX_FRAME_LEN: usize = 256;
 
 /// An extracted RTU PDU frame.
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct DecodedFrame<'a> {
     pub slave: SlaveId,
     pub pdu: &'a [u8],
 }
 
 /// The location of all bytes that belong to the frame.
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct FrameLocation {
     /// The index where the frame starts

src/codec/tcp/mod.rs

@@ -11,6 +11,7 @@ pub use crate::frame::tcp::*;
 const MAX_FRAME_LEN: usize = 256;
 
 /// An extracted TCP PDU frame.
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct DecodedFrame<'a> {
     pub transaction_id: TransactionId,
@@ -19,6 +20,7 @@ pub struct DecodedFrame<'a> {
 }
 
 /// The location of all bytes that belong to the frame.
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct FrameLocation {
     /// The index where the frame starts

src/error.rs

@@ -48,3 +48,30 @@ impl fmt::Display for Error {
         }
     }
 }
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Error {
+    fn format(&self, f: defmt::Formatter) {
+        match self {
+            Self::CoilValue(v) => defmt::write!(f, "Invalid coil value: {}", v),
+            Self::BufferSize => defmt::write!(f, "Invalid buffer size"),
+            Self::FnCode(fn_code) => defmt::write!(f, "Invalid function code: {=u8:#04x}", fn_code),
+            Self::ExceptionCode(code) => defmt::write!(f, "Invalid exception code: {=u8:#04x}", code),
+            Self::ExceptionFnCode(code) => {
+                defmt::write!(f, "Invalid exception function code: {=u8:#04x}", code)
+            }
+            Self::Crc(expected, actual) => defmt::write!(f,
+                "Invalid CRC: expected = {=u16:#06x}, actual = {=u16:#06x}",
+                expected, actual
+            ),
+            Self::ByteCount(cnt) => defmt::write!(f, "Invalid byte count: {}", cnt),
+            Self::LengthMismatch(length_field, pdu_len) => defmt::write!(f,
+                "Length Mismatch: Length Field: {}, PDU Len + 1: {}",
+                length_field, pdu_len
+            ),
+            Self::ProtocolNotModbus(protocol_id) => {
+                defmt::write!(f, "Protocol not Modbus(0), recieved {} instead", protocol_id)
+            }
+        }
+    }
+}

src/frame/coils.rs

@@ -2,6 +2,7 @@ use super::*;
 use crate::error::*;
 
 /// Packed coils
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct Coils<'c> {
     pub(crate) data: RawData<'c>,
@@ -60,6 +61,7 @@ impl<'c> Coils<'c> {
 
 /// Coils iterator.
 // TODO: crate an generic iterator
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct CoilsIter<'c> {
     cnt: usize,

src/frame/data.rs

@@ -2,6 +2,7 @@ use super::*;
 use crate::error::*;
 
 /// Modbus data (u16 values)
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct Data<'d> {
     pub(crate) data: RawData<'d>,
@@ -57,6 +58,7 @@ impl<'d> Data<'d> {
 
 /// Data iterator
 // TODO: crate a generic iterator
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DataIter<'d> {
     cnt: usize,

src/frame/mod.rs

@@ -11,6 +11,7 @@ use byteorder::{BigEndian, ByteOrder};
 /// A Modbus function code.
 ///
 /// It is represented by an unsigned 8 bit integer.
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum FunctionCode {
     /// Modbus Function Code: `01` (`0x01`).
@@ -157,6 +158,7 @@ pub(crate) type Quantity = u16;
 type RawData<'r> = &'r [u8];
 
 /// A request represents a message from the client (master) to the server (slave).
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Request<'r> {
     ReadCoils(Address, Quantity),
@@ -191,17 +193,20 @@ pub enum Request<'r> {
 }
 
 /// A server (slave) exception response.
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct ExceptionResponse {
     pub function: FunctionCode,
     pub exception: Exception,
 }
 
 /// Represents a message from the client (slave) to the server (master).
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct RequestPdu<'r>(pub Request<'r>);
 
 /// Represents a message from the server (slave) to the client (master).
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct ResponsePdu<'r>(pub Result<Response<'r>, ExceptionResponse>);
 
@@ -213,6 +218,7 @@ type EventCount = u16;
 type MessageCount = u16;
 
 /// The response data of a successfull request.
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Response<'r> {
     ReadCoils(Coils<'r>),
@@ -305,6 +311,7 @@ impl<'r> From<Response<'r>> for FunctionCode {
 }
 
 /// A server (slave) exception.
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Exception {
     IllegalFunction = 0x01,
@@ -318,9 +325,9 @@ pub enum Exception {
     GatewayTargetDevice = 0x0B,
 }
 
-impl fmt::Display for Exception {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let desc = match *self {
+impl Exception{
+    fn get_name(&self) -> &'static str {
+        match *self {
             Self::IllegalFunction => "Illegal function",
             Self::IllegalDataAddress => "Illegal data address",
             Self::IllegalDataValue => "Illegal data value",
@@ -330,11 +337,20 @@ impl fmt::Display for Exception {
             Self::MemoryParityError => "Memory parity error",
             Self::GatewayPathUnavailable => "Gateway path unavailable",
             Self::GatewayTargetDevice => "Gateway target device failed to respond",
-        };
-        write!(f, "{desc}")
+        }
     }
 }
 
+impl fmt::Display for Exception {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.get_name()) }
+}
+
+#[cfg(feature = "defmt")]
+impl defmt::Format for Exception {
+    fn format(&self, fmt: defmt::Formatter) { defmt::write!(fmt, "{}", self.get_name()) }
+}
+
+
 impl Request<'_> {
     /// Number of bytes required for a serialized PDU frame.
     #[must_use]

src/frame/rtu.rs

@@ -4,19 +4,22 @@ use super::*;
 pub type SlaveId = u8;
 
 /// RTU header
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct Header {
     pub slave: SlaveId,
 }
 
 /// RTU Request ADU
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct RequestAdu<'r> {
     pub hdr: Header,
     pub pdu: RequestPdu<'r>,
 }
 
 /// RTU Response ADU
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct ResponseAdu<'r> {
     pub hdr: Header,

src/frame/tcp.rs

@@ -3,18 +3,21 @@ use super::*;
 pub type TransactionId = u16;
 pub type UnitId = u8;
 
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct Header {
     pub transaction_id: TransactionId,
     pub unit_id: UnitId,
 }
 
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct RequestAdu<'r> {
     pub hdr: Header,
     pub pdu: RequestPdu<'r>,
 }
 
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct ResponseAdu<'r> {
     pub hdr: Header,