From d30a261e7418b7248895e70a9a83d46d8cf4b3ee Mon Sep 17 00:00:00 2001
From: Tobias Maier <me@maiertobi.de>
Date: Fri, 16 Jan 2026 22:17:13 +0100
Subject: [PATCH] Add better error logging

---
 src/message.rs      | 43 +++++++++++++++++++++++++++++++++++++------
 src/transmission.rs | 10 ++++++++--
 2 files changed, 45 insertions(+), 8 deletions(-)

diff --git a/src/message.rs b/src/message.rs
index ef85a89..5df011e 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -1,4 +1,4 @@
-use log::warn;
+use log::{warn, error};
 
 extern crate alloc;
 
@@ -118,7 +118,13 @@ impl Protocol300Message {
     /// # Errors
     /// Returns an error if the data vec is longer than u8. This is also against the spec of Protocol 300, so it's safe to panic
     pub fn try_new_write_message(data_address: u16, data: &[u8]) -> Result<Self, MessageCreationError>{
-        let data_length: u8 = data.len().try_into()?;
+        let data_length: u8 = match data.len().try_into() {
+            Ok(len) => len,
+            Err(e) => {
+                error!("Failed to create write message: data length {} exceeds maximum u8 value (255) for address 0x{:04X}", data.len(), data_address);
+                return Err(MessageCreationError::DataTooLong(e));
+            }
+        };
         let telegram_length: u8 = 5 + data_length;
         let message_identifier = MessageIdentifier::Request;
         let function_code = FunctionCode::VirtualWRITE;
@@ -150,20 +156,44 @@ impl Protocol300Message {
     /// - Checksum mismatch
     pub fn try_from_bytes(bytes: &[u8]) -> Result<Self, MessageDecodingError> {
         if bytes.len() < 8 {
+            error!("Failed to decode message: byte vector too short (length: {}, minimum required: 8)", bytes.len());
             return Err(MessageDecodingError::VecTooShort)
         }
         
         if bytes[0] != 0x41 {
+            error!("Failed to decode message: invalid telegram start byte 0x{:02X}, expected 0x41", bytes[0]);
             return Err(MessageDecodingError::InvalidTelegramStart(bytes[0]));
         }
 
         let telegram_length: u8 = bytes[1];
-        if u8::try_from(bytes.len())? != telegram_length + 3 {
+        let actual_length = match u8::try_from(bytes.len()) {
+            Ok(len) => len,
+            Err(e) => {
+                error!("Failed to decode message: byte vector length conversion error");
+                return Err(MessageDecodingError::NoLength(e));
+            }
+        };
+        
+        if actual_length != telegram_length + 3 {
+            error!("Failed to decode message: length mismatch - advertised telegram length: {}, actual length: {}, expected: {}", telegram_length, actual_length, telegram_length + 3);
             return Err(MessageDecodingError::LengthMismatch());
         }
 
-        let message_identifier = MessageIdentifier::try_from(bytes[2])?;
-        let function_code = FunctionCode::try_from(bytes[3])?;
+        let message_identifier = match MessageIdentifier::try_from(bytes[2]) {
+            Ok(id) => id,
+            Err(e) => {
+                error!("Failed to decode message: invalid message identifier byte 0x{:02X}", bytes[2]);
+                return Err(MessageDecodingError::InvalidMessageIdentifier(e));
+            }
+        };
+        
+        let function_code = match FunctionCode::try_from(bytes[3]) {
+            Ok(fc) => fc,
+            Err(e) => {
+                error!("Failed to decode message: invalid function code byte 0x{:02X}", bytes[3]);
+                return Err(MessageDecodingError::InvalidFunctionCode(e));
+            }
+        };
         let data_address = (u16::from(bytes[4]) << 8) | u16::from(bytes[5]);
 
         let data_length = bytes[6];
@@ -193,6 +223,7 @@ impl Protocol300Message {
         
         // Fail if the checksums do not match
         if checksum != checksum_calculated {
+            error!("Failed to decode message: checksum mismatch - received: 0x{checksum:02X}, calculated: 0x{checksum_calculated:02X}, address: 0x{data_address:04X}, message_id: {message_identifier}, function: {function_code}");
             return Err(MessageDecodingError::Checksum)
         }
 
@@ -516,4 +547,4 @@ mod tests {
     }
 
 
-}
\ No newline at end of file
+}
diff --git a/src/transmission.rs b/src/transmission.rs
index 4233039..7d652d0 100644
--- a/src/transmission.rs
+++ b/src/transmission.rs
@@ -1,5 +1,6 @@
 use crate::{Protocol300Message, message};
 use thiserror::Error;
+use log::error;
 extern crate alloc;
 
 use alloc::vec;
@@ -34,7 +35,12 @@ impl Protocol300Transmission {
             [0x15] => Ok(Self::Nack),
             [0x16, 0x00, 0x00] => Ok(Self::Init),
             [0x41, ..] => Ok(Self::Message(Protocol300Message::try_from_bytes(bytes)?)),
-            _ => Err(FromBytesError::InvalidByte),
+            _ => {
+                error!("Failed to parse Protocol300 transmission: invalid byte sequence (length: {}, first byte: 0x{:02X?})", 
+                       bytes.len(), 
+                       bytes.first().unwrap_or(&0x00));
+                Err(FromBytesError::InvalidByte)
+            },
         }
     }
 
@@ -143,4 +149,4 @@ mod tests {
         };
         assert_eq!(Protocol300Transmission::Message(message).to_bytes(), &[0x41, 0x09, 0x01, 0x01, 0x55, 0x25, 0x04, 0x07, 0x01, 0x27, 0x11, 0xC9]);
     }
-}
\ No newline at end of file
+}