From 6e66719c2dae790df299e2df366282b90f346e84 Mon Sep 17 00:00:00 2001
From: Michael Debertol <michael.debertol@gmail.com>
Date: Sat, 28 Feb 2026 16:47:25 +0100
Subject: [PATCH 01/15] feat: implement new macro for serializing/deserializing
 can messages

This does not modify the behavior yet, but should better support serializing variable length values.
---
 .../liquidcan_rust_macros/Cargo.toml          |   6 +-
 .../liquidcan_rust_macros_derive/Cargo.toml   |   3 +-
 .../liquidcan_rust_macros_derive/src/lib.rs   | 247 ++++++++++--
 .../liquidcan_rust_macros/src/byte_codec.rs   |  41 ++
 .../liquidcan_rust_macros/src/lib.rs          |   5 +-
 .../liquidcan_rust_macros/src/padded_enum.rs  | 350 ------------------
 .../tests/test_byte_codec.rs                  | 200 ++++++++++
 liquidcan_rust/src/can_message.rs             |  41 +-
 liquidcan_rust/src/message_conversion.rs      |  22 +-
 9 files changed, 475 insertions(+), 440 deletions(-)
 create mode 100644 liquidcan_rust/liquidcan_rust_macros/src/byte_codec.rs
 delete mode 100644 liquidcan_rust/liquidcan_rust_macros/src/padded_enum.rs
 create mode 100644 liquidcan_rust/liquidcan_rust_macros/tests/test_byte_codec.rs

diff --git a/liquidcan_rust/liquidcan_rust_macros/Cargo.toml b/liquidcan_rust/liquidcan_rust_macros/Cargo.toml
index 2bb0040..c5c748e 100644
--- a/liquidcan_rust/liquidcan_rust_macros/Cargo.toml
+++ b/liquidcan_rust/liquidcan_rust_macros/Cargo.toml
@@ -4,6 +4,6 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-paste = "1.0.15"
-zerocopy = "0.8.28"
-zerocopy-derive = "0.8.28"
+liquidcan_rust_macros_derive = { path = "./liquidcan_rust_macros_derive", version = "0.1.0" }
+thiserror = "2.0"
+zerocopy = { version = "0.8", features = ["derive"] }
\ No newline at end of file
diff --git a/liquidcan_rust/liquidcan_rust_macros/liquidcan_rust_macros_derive/Cargo.toml b/liquidcan_rust/liquidcan_rust_macros/liquidcan_rust_macros_derive/Cargo.toml
index 4c76c4b..7193636 100644
--- a/liquidcan_rust/liquidcan_rust_macros/liquidcan_rust_macros_derive/Cargo.toml
+++ b/liquidcan_rust/liquidcan_rust_macros/liquidcan_rust_macros_derive/Cargo.toml
@@ -8,4 +8,5 @@ proc-macro = true
 
 [dependencies]
 syn = "2.0.110"
-quote = "1.0.42"
\ No newline at end of file
+quote = "1.0.42"
+proc-macro2 = "1.0"
\ No newline at end of file
diff --git a/liquidcan_rust/liquidcan_rust_macros/liquidcan_rust_macros_derive/src/lib.rs b/liquidcan_rust/liquidcan_rust_macros/liquidcan_rust_macros_derive/src/lib.rs
index 016e3b0..5653107 100644
--- a/liquidcan_rust/liquidcan_rust_macros/liquidcan_rust_macros_derive/src/lib.rs
+++ b/liquidcan_rust/liquidcan_rust_macros/liquidcan_rust_macros_derive/src/lib.rs
@@ -1,51 +1,224 @@
 use proc_macro::TokenStream;
-use quote::quote;
-use syn::Attribute;
+use quote::{format_ident, quote};
+use syn::{
+    Data, DeriveInput, Fields, Variant, parse_macro_input, punctuated::Punctuated, token::Comma,
+};
 
-#[proc_macro_derive(EnumDiscriminate)]
-pub fn enum_discriminate_derive(input: TokenStream) -> TokenStream {
-    // Construct a representation of Rust code as a syntax tree
-    // that we can manipulate.
-    let ast = syn::parse(input).unwrap();
+#[proc_macro_derive(ByteCodec)]
+pub fn derive_byte_codec(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let type_name = &input.ident;
 
-    // Build the trait implementation.
-    impl_enum_discriminate_derive(&ast)
+    let expanded = match &input.data {
+        Data::Enum(data_enum) => {
+            let variants = &data_enum.variants;
+            let serialize_impl = build_serialize(type_name, variants);
+            let deserialize_impl = build_deserialize(type_name, variants);
+
+            quote! {
+                impl liquidcan_rust_macros::byte_codec::ByteCodec for #type_name {
+                    #serialize_impl
+                    #deserialize_impl
+                }
+            }
+        }
+        Data::Struct(data_struct) => {
+            let serialize_impl = build_struct_serialize(type_name, &data_struct.fields);
+            let deserialize_impl = build_struct_deserialize(type_name, &data_struct.fields);
+
+            quote! {
+                impl liquidcan_rust_macros::byte_codec::ByteCodec for #type_name {
+                    #serialize_impl
+                    #deserialize_impl
+                }
+            }
+        }
+        Data::Union(_) => panic!("ByteCodec cannot be derived for unions"),
+    };
+
+    TokenStream::from(expanded)
 }
 
-fn has_repr_u8(attrs: &[Attribute]) -> bool {
-    let mut is_u8 = false;
-    for attr in attrs {
-        if attr.path().is_ident("repr") {
-            attr.parse_nested_meta(|meta| {
-                if meta.path.is_ident("u8") {
-                    is_u8 = true;
+fn build_serialize(
+    enum_name: &syn::Ident,
+    variants: &Punctuated<Variant, Comma>,
+) -> proc_macro2::TokenStream {
+    let match_arms = variants.iter().map(|variant| {
+        let variant_name = &variant.ident;
+        let (_, variant_discriminant) = variant
+            .discriminant
+            .as_ref()
+            .expect("Must explicitly specify discriminant");
+
+        match &variant.fields {
+            Fields::Named(fields) => {
+                let field_names: Vec<_> = fields.named.iter().map(|f| &f.ident).collect();
+
+                quote! {
+                    #enum_name::#variant_name { #(#field_names),* } => {
+                        out.push(#variant_discriminant);
+                        #( #field_names.serialize(out); )*
+                    }
+                }
+            }
+            Fields::Unnamed(fields) => {
+                // Generate dummy identifiers for the tuple fields (e.g., f0, f1, f2)
+                let field_idents: Vec<_> = (0..fields.unnamed.len())
+                    .map(|i| format_ident!("f{}", i))
+                    .collect();
+
+                quote! {
+                    #enum_name::#variant_name( #(#field_idents),* ) => {
+                        out.push(#variant_discriminant);
+                        #( #field_idents.serialize(out); )*
+                    }
                 }
-                Ok(())
-            })
-            .unwrap()
+            }
+            Fields::Unit => {
+                quote! {
+                    #enum_name::#variant_name => {
+                        out.push(#variant_discriminant);
+                    }
+                }
+            }
         }
-    }
-    is_u8
+    });
+
+    let expanded = quote! { fn serialize(&self, out: &mut Vec<u8>) {
+        match self {
+            #(#match_arms)*
+        }
+    }};
+
+    return expanded;
+}
+
+fn build_deserialize(
+    enum_name: &syn::Ident,
+    variants: &Punctuated<Variant, Comma>,
+) -> proc_macro2::TokenStream {
+    let match_arms = variants.iter().map(|variant| {
+        let variant_name = &variant.ident;
+        let (_, variant_discriminant) = variant
+            .discriminant
+            .as_ref()
+            .expect("Must explicitly specify discriminant");
+
+        match &variant.fields {
+            Fields::Named(fields) => {
+                let field_names: Vec<_> = fields.named.iter().map(|f| &f.ident).collect();
+
+                quote! {
+                    #variant_discriminant => {
+                        #(
+                            let (#field_names, input) = liquidcan_rust_macros::byte_codec::ByteCodec::deserialize(input)?;
+                        )*
+                        Ok((#enum_name::#variant_name { #( #field_names ),* }, input))
+                    }
+                }
+            }
+            Fields::Unnamed(fields) => {
+                let field_idents: Vec<_> = (0..fields.unnamed.len())
+                    .map(|i| format_ident!("f{}", i))
+                    .collect();
+
+                quote! {
+                    #variant_discriminant => {
+                        #(
+                            let (#field_idents, input) = liquidcan_rust_macros::byte_codec::ByteCodec::deserialize(input)?;
+                        )*
+                        Ok((#enum_name::#variant_name( #( #field_idents ),* ), input))
+                    }
+                }
+            }
+            Fields::Unit => {
+                quote! {
+                    #variant_discriminant => Ok((#enum_name::#variant_name, input))
+                }
+            }
+        }
+    });
+
+    let expanded = quote! { fn deserialize(input: &[u8]) -> Result<(Self, &[u8]), liquidcan_rust_macros::byte_codec::DeserializationError> {
+        let (discriminant, input) = input
+            .split_first()
+            .ok_or(liquidcan_rust_macros::byte_codec::DeserializationError::NotEnoughData)?;
+
+        match discriminant {
+            #(#match_arms,)*
+            _ => Err(liquidcan_rust_macros::byte_codec::DeserializationError::InvalidDiscriminant(*discriminant)),
+        }
+    }};
+
+    return expanded;
 }
 
-fn impl_enum_discriminate_derive(ast: &syn::DeriveInput) -> TokenStream {
-    let name = &ast.ident;
-    if !has_repr_u8(&ast.attrs) {
-        panic!("EnumDiscriminate can only be derived for enums which have the u8 repr");
+fn build_struct_serialize(type_name: &syn::Ident, fields: &Fields) -> proc_macro2::TokenStream {
+    match fields {
+        Fields::Named(fields) => {
+            let field_names: Vec<_> = fields.named.iter().map(|f| &f.ident).collect();
+            quote! {
+                fn serialize(&self, out: &mut Vec<u8>) {
+                    let #type_name { #( #field_names ),* } = self;
+                    #( #field_names.serialize(out); )*
+                }
+            }
+        }
+        Fields::Unnamed(fields) => {
+            let field_idents: Vec<_> = (0..fields.unnamed.len())
+                .map(|i| format_ident!("f{}", i))
+                .collect();
+
+            quote! {
+                fn serialize(&self, out: &mut Vec<u8>) {
+                    let #type_name( #( #field_idents ),* ) = self;
+                    #( #field_idents.serialize(out); )*
+                }
+            }
+        }
+        Fields::Unit => {
+            quote! {
+                fn serialize(&self, _out: &mut Vec<u8>) {
+                }
+            }
+        }
     }
-    let generated = quote! {
-        impl #name {
-            pub const fn discriminant(&self) -> u8 {
-                // SAFETY: Because we require the enum to be marked as `repr(u8)`, its layout is a `repr(C)` `union`
-                // between `repr(C)` structs, each of which has the `u8` discriminant as its first
-                // field, so we can read the discriminant without offsetting the pointer.
-                unsafe {
-                    let ptr = self as *const Self;
-                    let discriminant_ptr = ptr.cast::<u8>();
-                    *discriminant_ptr
+}
+
+fn build_struct_deserialize(type_name: &syn::Ident, fields: &Fields) -> proc_macro2::TokenStream {
+    match fields {
+        Fields::Named(fields) => {
+            let field_names: Vec<_> = fields.named.iter().map(|f| &f.ident).collect();
+
+            quote! {
+                fn deserialize(input: &[u8]) -> Result<(Self, &[u8]), liquidcan_rust_macros::byte_codec::DeserializationError> {
+                    #(
+                        let (#field_names, input) = liquidcan_rust_macros::byte_codec::ByteCodec::deserialize(input)?;
+                    )*
+                    Ok((#type_name { #( #field_names ),* }, input))
                 }
             }
         }
-    };
-    generated.into()
+        Fields::Unnamed(fields) => {
+            let field_idents: Vec<_> = (0..fields.unnamed.len())
+                .map(|i| format_ident!("f{}", i))
+                .collect();
+
+            quote! {
+                fn deserialize(input: &[u8]) -> Result<(Self, &[u8]), liquidcan_rust_macros::byte_codec::DeserializationError> {
+                    #(
+                        let (#field_idents, input) = liquidcan_rust_macros::byte_codec::ByteCodec::deserialize(input)?;
+                    )*
+                    Ok((#type_name( #( #field_idents ),* ), input))
+                }
+            }
+        }
+        Fields::Unit => {
+            quote! {
+                fn deserialize(input: &[u8]) -> Result<(Self, &[u8]), liquidcan_rust_macros::byte_codec::DeserializationError> {
+                    Ok((#type_name, input))
+                }
+            }
+        }
+    }
 }
diff --git a/liquidcan_rust/liquidcan_rust_macros/src/byte_codec.rs b/liquidcan_rust/liquidcan_rust_macros/src/byte_codec.rs
new file mode 100644
index 0000000..e8c7968
--- /dev/null
+++ b/liquidcan_rust/liquidcan_rust_macros/src/byte_codec.rs
@@ -0,0 +1,41 @@
+pub use liquidcan_rust_macros_derive::ByteCodec;
+use thiserror::Error;
+use zerocopy::{Immutable, IntoBytes, TryFromBytes};
+
+pub trait ByteCodec {
+    fn serialize(&self, out: &mut Vec<u8>);
+    fn deserialize(input: &[u8]) -> Result<(Self, &[u8]), DeserializationError>
+    where
+        Self: Sized;
+}
+
+impl<T> ByteCodec for T
+where
+    T: TryFromBytes + IntoBytes + Immutable + Sized,
+{
+    fn serialize(&self, out: &mut Vec<u8>) {
+        out.extend_from_slice(self.as_bytes());
+    }
+
+    fn deserialize(input: &[u8]) -> Result<(Self, &[u8]), DeserializationError> {
+        let size = core::mem::size_of::<T>();
+        if input.len() < size {
+            return Err(DeserializationError::NotEnoughData);
+        }
+
+        T::try_read_from_prefix(input)
+            .map_err(|err| DeserializationError::InvalidData(format!("{err:?}")))
+    }
+}
+
+
+#[non_exhaustive]
+#[derive(Debug, Error, PartialEq, Eq)]
+pub enum DeserializationError {
+    #[error("invalid enum discriminant: {0}")]
+    InvalidDiscriminant(u8),
+    #[error("not enough input data")]
+    NotEnoughData,
+    #[error("input bytes are not a valid value for target type")]
+    InvalidData(String),
+}
diff --git a/liquidcan_rust/liquidcan_rust_macros/src/lib.rs b/liquidcan_rust/liquidcan_rust_macros/src/lib.rs
index b2e5b99..f7deb87 100644
--- a/liquidcan_rust/liquidcan_rust_macros/src/lib.rs
+++ b/liquidcan_rust/liquidcan_rust_macros/src/lib.rs
@@ -1,4 +1 @@
-#[doc(hidden)]
-pub use paste::paste;
-
-mod padded_enum;
+pub mod byte_codec;
diff --git a/liquidcan_rust/liquidcan_rust_macros/src/padded_enum.rs b/liquidcan_rust/liquidcan_rust_macros/src/padded_enum.rs
deleted file mode 100644
index 21a6c2c..0000000
--- a/liquidcan_rust/liquidcan_rust_macros/src/padded_enum.rs
+++ /dev/null
@@ -1,350 +0,0 @@
-/// Generates a padded, `zerocopy`-safe version of an enum.
-///
-/// # Arguments
-/// * `(size = N)` - A compile-time assertion that the generated enum is exactly N bytes.
-/// * `#[pad(N)]` - An attribute placed on each variant to add N bytes of explicit zero-padding.
-///
-/// # Example
-/// ```rust
-/// use zerocopy::{IntoBytes, TryFromBytes, Immutable, KnownLayout};
-/// use liquidcan_rust_macros::padded_enum;
-///
-/// padded_enum! {
-///     (size = 5) // Mandatory size check. All enum variants must take 5 bytes.
-///     #[derive(Debug, Clone, Copy, PartialEq)]
-///     pub enum Command {
-///         // Variant 1: Tag(1) + u32(4) + Pad(0) = 5 bytes
-///         #[pad(0)]
-///         Move{val: u32},
-///
-///         // Variant 2: Tag(1) + Pad(4) = 5 bytes
-///         #[pad(4)]
-///         Stop
-///     }
-/// }
-///
-/// // Usage
-/// let cmd = Command::Move { val: 42 };
-/// let mut buffer = [0u8; 5];
-/// let bytes = cmd.to_bytes(&mut buffer);
-/// let cmd = Command::from_bytes(bytes).unwrap();
-/// ```
-#[macro_export]
-macro_rules! padded_enum {
-    (
-        (size = $size:expr)
-        $(#[$meta:meta])*
-        $vis:vis enum $Original:ident {
-            $(
-                #[pad($pad:expr)]
-                $Variant:ident $( { $( $field_name:ident : $field_type:ty ),* $(,)?} )? $( = $disc:expr )?
-            ),* $(,)?
-        }
-    ) => {
-        // ---------------------------------------------------------
-        // 1. The Original Ergonomic Enum
-        // ---------------------------------------------------------
-        $(#[$meta])*
-        $vis enum $Original {
-            $(
-                $Variant $( { $($field_name: $field_type),* } )?  $( = $disc )?,
-            )*
-        }
-
-        // We use the `paste` crate to concatenate names (Original + Padded)
-        $crate::paste! {
-
-            // ---------------------------------------------------------
-            // 2. Internal Packed Structs
-            // ---------------------------------------------------------
-            // These wrap the data to force alignment to 1, preventing
-            // the compiler from inserting uninitialized padding bytes
-            // between the Enum Tag and the Variant Data.
-            $(
-                #[repr(C, packed)]
-                #[derive(
-                    zerocopy_derive::IntoBytes,
-                    zerocopy_derive::TryFromBytes,
-                    zerocopy_derive::Immutable,
-                    zerocopy_derive::KnownLayout
-                )]
-                #[allow(non_camel_case_types)]
-                $vis struct [<$Original Padded _ $Variant _Body>] {
-                    $($( pub $field_name: $field_type, )*)?
-                    pub _pad: [u8; $pad],
-                }
-            )*
-
-            // ---------------------------------------------------------
-            // 3. The Padded (Wire-Format) Enum
-            // ---------------------------------------------------------
-            #[repr(u8)]
-            #[derive(
-                zerocopy_derive::IntoBytes,
-                zerocopy_derive::TryFromBytes,
-                zerocopy_derive::Immutable,
-                zerocopy_derive::KnownLayout
-            )]
-            $vis enum [<$Original Padded>] {
-                $(
-                    $Variant( [<$Original Padded _ $Variant _Body>] ) $( = $disc )?,
-                )*
-            }
-
-            // ---------------------------------------------------------
-            // 4. Direct conversions between Original and bytes
-            // ---------------------------------------------------------
-            impl $Original {
-                /// Serializes the enum to a vector of bytes, omitting the padding.
-                #[allow(unused)]
-                pub fn to_bytes(self, buf: & mut [u8; $size]) -> &[u8] {
-                    match self {
-                        $(
-                            $Original::$Variant $( { $($field_name),* } )? => {
-                                // Construct the padded body struct
-                                let padded_body = [<$Original Padded _ $Variant _Body>] {
-                                    $($( $field_name: $field_name.clone(), )*)?
-                                    _pad: [0u8; $pad],
-                                };
-                                let padded_enum = [<$Original Padded>]::$Variant(padded_body);
-                                let bytes = ::zerocopy::IntoBytes::as_bytes(&padded_enum);
-                                buf.copy_from_slice(bytes);
-                                &buf[0..(bytes.len() - $pad)]
-                            }
-                        )*
-                    }
-                }
-
-                /// Deserializes from a byte slice, padding with zeros if necessary.
-                #[allow(unused)]
-                pub fn from_bytes(bytes: &[u8]) -> Result<Self, ::std::string::String> {
-                    let mut buf = [0u8; $size];
-                    let len = ::std::cmp::min(bytes.len(), $size);
-                    buf[0..len].copy_from_slice(&bytes[0..len]);
-
-                    let padded = <[<$Original Padded>] as ::zerocopy::TryFromBytes>::try_read_from_bytes(&buf)
-                        .map_err(|e| ::std::format!("{:?}", e))?;
-                    Ok(padded.into())
-                }
-            }
-
-            // ---------------------------------------------------------
-            // 5. Conversion: Original -> Padded
-            // ---------------------------------------------------------
-            impl From<$Original> for [<$Original Padded>] {
-                fn from(orig: $Original) -> Self {
-                    match orig {
-                        $(
-                            $Original::$Variant $( { $($field_name),* } )? => {
-                                [<$Original Padded>]::$Variant(
-                                    [<$Original Padded _ $Variant _Body>] {
-                                        $($( $field_name, )*)?
-                                        _pad: [0u8; $pad]
-                                    }
-                                )
-                            }
-                        )*
-                    }
-                }
-            }
-
-            // ---------------------------------------------------------
-            // 6. Conversion: Padded -> Original
-            // ---------------------------------------------------------
-            impl From<[<$Original Padded>]> for $Original {
-                fn from(padded: [<$Original Padded>]) -> Self {
-                    match padded {
-                        $(
-                            #[allow(unused_variables)]
-                            [<$Original Padded>]::$Variant(body) => {
-                                $Original::$Variant $( { $( $field_name: body.$field_name ),* } )?
-                            }
-                        )*
-                    }
-                }
-            }
-
-            // ---------------------------------------------------------
-            // 7. Size Check (Type Mismatch Trick)
-            // ---------------------------------------------------------
-            // If the size doesn't match, this triggers a compiler error:
-            // "Expected array of size X, found array of size Y"
-            const _: [(); $size] = [(); std::mem::size_of::<[<$Original Padded>]>()];
-        }
-    };
-}
-
-// ---------------------------------------------------------
-// Unit Tests
-// ---------------------------------------------------------
-#[cfg(test)]
-mod tests {
-    use zerocopy::{IntoBytes, TryFromBytes};
-
-    // Define a test enum using the macro
-    padded_enum! {
-        (size = 5) // Tag(1) + MaxPayload(4)
-
-        #[derive(Debug, Clone, Copy, PartialEq)]
-        #[repr(u8)]
-        pub enum MyProto {
-            // 1 + 4 + 0 = 5
-            #[pad(0)]
-            Move{dist: u32,},
-
-            // 1 + 1 + 3 = 5
-            #[pad(3)]
-            Jump{height: u8},
-
-            // 1 + 0 + 4 = 5
-            #[pad(4)]
-            Stop
-        }
-    }
-
-    #[test]
-    fn test_layout_size() {
-        assert_eq!(std::mem::size_of::<MyProtoPadded>(), 5);
-    }
-
-    #[test]
-    fn test_move_variant() {
-        let original = MyProto::Move { dist: 0xAABBCCDD };
-        let padded: MyProtoPadded = original.into();
-
-        // Check bytes: Tag (0) + u32 (DD CC BB AA) in little endian
-        let bytes = padded.as_bytes();
-        // Note: Tag values depend on declaration order. Move=0
-        assert_eq!(bytes[0], 0);
-        assert_eq!(&bytes[1..5], &[0xDD, 0xCC, 0xBB, 0xAA]);
-
-        let padded_back: MyProtoPadded = MyProtoPadded::try_read_from_bytes(bytes).unwrap();
-        // Round trip
-        let back: MyProto = padded_back.into();
-        assert_eq!(original, back);
-    }
-
-    #[test]
-    fn test_jump_variant_padding() {
-        let original = MyProto::Jump { height: 0xFF };
-        let padded: MyProtoPadded = original.into();
-
-        let bytes = padded.as_bytes();
-        // Tag=1, Data=FF, Pad=00 00 00
-        assert_eq!(bytes[0], 1);
-        assert_eq!(bytes[1], 0xFF);
-        assert_eq!(bytes[2], 0x00); // Pad must be zero
-        assert_eq!(bytes[3], 0x00);
-        assert_eq!(bytes[4], 0x00);
-
-        // Round trip
-        let back: MyProto = padded.into();
-        assert_eq!(original, back);
-    }
-
-    #[test]
-    fn test_stop_variant_padding() {
-        let original = MyProto::Stop;
-        let padded: MyProtoPadded = original.into();
-
-        let bytes = padded.as_bytes();
-        // Tag=2, Pad=00 00 00 00
-        assert_eq!(bytes[0], 2);
-        assert_eq!(bytes[1..5], [0, 0, 0, 0]);
-
-        // Round trip
-        let back: MyProto = padded.into();
-        assert_eq!(original, back);
-    }
-
-    // Test enum with discriminants set via constants
-    const CMD_PING: u8 = 10;
-    const CMD_PONG: u8 = 20;
-    const CMD_DATA: u8 = 30;
-
-    padded_enum! {
-        (size = 5)
-
-        #[derive(Debug, Clone, Copy, PartialEq)]
-        #[repr(u8)]
-        pub enum ConstDiscriminant {
-            #[pad(4)]
-            Ping = CMD_PING,
-
-            #[pad(4)]
-            Pong = CMD_PONG,
-
-            #[pad(0)]
-            Data { value: u32 } = CMD_DATA,
-        }
-    }
-
-    #[test]
-    fn test_constant_discriminants() {
-        // Verify discriminants are set correctly via constants
-        let ping = ConstDiscriminant::Ping;
-        let padded: ConstDiscriminantPadded = ping.into();
-        let bytes = padded.as_bytes();
-        assert_eq!(bytes[0], CMD_PING);
-
-        let pong = ConstDiscriminant::Pong;
-        let padded: ConstDiscriminantPadded = pong.into();
-        let bytes = padded.as_bytes();
-        assert_eq!(bytes[0], CMD_PONG);
-
-        let data = ConstDiscriminant::Data { value: 0x12345678 };
-        let padded: ConstDiscriminantPadded = data.into();
-        let bytes = padded.as_bytes();
-        assert_eq!(bytes[0], CMD_DATA);
-        assert_eq!(&bytes[1..5], &[0x78, 0x56, 0x34, 0x12]); // little endian
-    }
-
-    #[test]
-    fn test_constant_discriminants_round_trip() {
-        let original = ConstDiscriminant::Data { value: 0xDEADBEEF };
-        let padded: ConstDiscriminantPadded = original.into();
-        let bytes = padded.as_bytes();
-
-        let padded_back = ConstDiscriminantPadded::try_read_from_bytes(bytes).unwrap();
-        let back: ConstDiscriminant = padded_back.into();
-        assert_eq!(original, back);
-    }
-
-    #[test]
-    fn test_to_from_bytes_for_original() {
-        let mut buffer = [0u8; 5];
-        let original = MyProto::Move { dist: 0xA1B2C3D4 };
-        let bytes = original.to_bytes(&mut buffer);
-        // Tag(0) + dist(4) = 5. padding is 0.
-        assert_eq!(bytes.len(), 5);
-        assert_eq!(bytes[0], 0);
-        assert_eq!(&bytes[1..5], &[0xD4, 0xC3, 0xB2, 0xA1]);
-
-        let recovered = MyProto::from_bytes(bytes).unwrap();
-        assert_eq!(original, recovered);
-
-        // Test padding logic
-        let jump = MyProto::Jump { height: 0x77 };
-        let bytes_jump = jump.to_bytes(&mut buffer);
-        // Tag(1) + height(1) + pad(3) = 5.
-        // Stripped bytes = 5 - 3 = 2.
-        assert_eq!(bytes_jump.len(), 2);
-        assert_eq!(bytes_jump, vec![1, 0x77]);
-
-        let recovered_jump = MyProto::from_bytes(bytes_jump).unwrap();
-        assert_eq!(jump, recovered_jump);
-
-        // Test undersized input
-        let incomplete = vec![1, 0x77]; // implicit padding
-        let recovered = MyProto::from_bytes(&incomplete).unwrap();
-        assert_eq!(jump, recovered);
-
-        // Test empty input (should be padded with 0 -> Tag=0 -> Move{val:0})
-        let empty: Vec<u8> = vec![];
-        let recovered_empty = MyProto::from_bytes(&empty).unwrap();
-        match recovered_empty {
-            MyProto::Move { dist } => assert_eq!(dist, 0),
-            _ => panic!("Expected Move(0)"),
-        }
-    }
-}
diff --git a/liquidcan_rust/liquidcan_rust_macros/tests/test_byte_codec.rs b/liquidcan_rust/liquidcan_rust_macros/tests/test_byte_codec.rs
new file mode 100644
index 0000000..3dc87a2
--- /dev/null
+++ b/liquidcan_rust/liquidcan_rust_macros/tests/test_byte_codec.rs
@@ -0,0 +1,200 @@
+use liquidcan_rust_macros::byte_codec::{ByteCodec, DeserializationError};
+use zerocopy::{Immutable, IntoBytes, TryFromBytes};
+
+#[repr(C)]
+#[derive(TryFromBytes, IntoBytes, Immutable, Clone, Copy, Debug, PartialEq, Eq)]
+struct CanFramePayload {
+	arbitration_id: u16,
+	data: u16,
+}
+
+#[repr(u8)]
+#[derive(ByteCodec, Debug, PartialEq, Eq)]
+enum CanMessage {
+	Heartbeat = 0x01,
+	Frame(CanFramePayload) = 0x02,
+	Command { cmd: u16, value: u16 } = 0x03,
+	Empty = 0x04,
+}
+
+#[repr(u8)]
+#[derive(TryFromBytes, IntoBytes, Immutable, Clone, Copy, Debug, PartialEq, Eq)]
+enum CheckedByte {
+	A = 0x11,
+	B = 0x22,
+}
+
+#[derive(ByteCodec, Debug, PartialEq, Eq)]
+struct NamedPacket {
+	port: u16,
+	payload: CanFramePayload,
+}
+
+#[derive(ByteCodec, Debug, PartialEq, Eq)]
+struct TuplePacket(u16, CanFramePayload);
+
+#[derive(ByteCodec, Debug, PartialEq, Eq)]
+struct Marker;
+
+#[test]
+fn serializes_to_variable_lengths() {
+	let mut heartbeat = Vec::new();
+	CanMessage::Heartbeat.serialize(&mut heartbeat);
+
+	let mut frame = Vec::new();
+	CanMessage::Frame(CanFramePayload {
+		arbitration_id: 0x1234,
+		data: 0xABCD,
+	})
+	.serialize(&mut frame);
+
+	let mut command = Vec::new();
+	CanMessage::Command {
+		cmd: 0x0102,
+		value: 0x0304,
+	}
+	.serialize(&mut command);
+
+	assert_eq!(heartbeat.len(), 1);
+	assert_eq!(frame.len(), 1 + core::mem::size_of::<CanFramePayload>());
+	assert_eq!(command.len(), 1 + core::mem::size_of::<u16>() * 2);
+}
+
+#[test]
+fn roundtrips_all_variant_shapes() {
+	let original = [
+		CanMessage::Heartbeat,
+		CanMessage::Frame(CanFramePayload {
+			arbitration_id: 0x0001,
+			data: 0xCAFE,
+		}),
+		CanMessage::Command {
+			cmd: 0xBEEF,
+			value: 0x2222,
+		},
+		CanMessage::Empty,
+	];
+
+	for value in original {
+		let mut bytes = Vec::new();
+		value.serialize(&mut bytes);
+
+		let (decoded, rest) = CanMessage::deserialize(&bytes).expect("deserialize should succeed");
+		assert_eq!(decoded, value);
+		assert!(rest.is_empty());
+	}
+}
+
+#[test]
+fn fails_for_invalid_discriminant() {
+	let err = CanMessage::deserialize(&[0xFF]).expect_err("expected invalid discriminant");
+	assert!(matches!(
+		err,
+		DeserializationError::InvalidDiscriminant(0xFF)
+	));
+}
+
+#[test]
+fn fails_on_empty_input() {
+	let err = CanMessage::deserialize(&[]).expect_err("expected not enough data");
+	assert!(matches!(err, DeserializationError::NotEnoughData));
+}
+
+#[test]
+fn fails_when_variant_payload_is_truncated() {
+	let err = CanMessage::deserialize(&[0x03, 0xAA]).expect_err("expected not enough data");
+	assert!(matches!(err, DeserializationError::NotEnoughData));
+}
+
+#[test]
+fn zerocopy_base_case_roundtrip() {
+	let payload = CanFramePayload {
+		arbitration_id: 0x1357,
+		data: 0x2468,
+	};
+
+	let mut bytes = Vec::new();
+	payload.serialize(&mut bytes);
+	assert_eq!(bytes.len(), core::mem::size_of::<CanFramePayload>());
+
+	let (decoded, rest) = CanFramePayload::deserialize(&bytes).expect("deserialize should succeed");
+	assert_eq!(decoded, payload);
+	assert!(rest.is_empty());
+}
+
+#[test]
+fn zerocopy_base_case_reports_invalid_data() {
+	let err = CheckedByte::deserialize(&[0xFF]).expect_err("expected invalid data");
+	assert!(matches!(err, DeserializationError::InvalidData(_)));
+}
+
+#[test]
+fn zerocopy_checked_enum_roundtrip() {
+	let mut bytes = Vec::new();
+	CheckedByte::A.serialize(&mut bytes);
+
+	let (decoded, rest) = CheckedByte::deserialize(&bytes).expect("deserialize should succeed");
+	assert_eq!(decoded, CheckedByte::A);
+	assert!(rest.is_empty());
+
+	let mut bytes_b = Vec::new();
+	CheckedByte::B.serialize(&mut bytes_b);
+	let (decoded_b, rest_b) = CheckedByte::deserialize(&bytes_b).expect("deserialize should succeed");
+	assert_eq!(decoded_b, CheckedByte::B);
+	assert!(rest_b.is_empty());
+}
+
+#[test]
+fn struct_named_roundtrip() {
+	let packet = NamedPacket {
+		port: 0x55AA,
+		payload: CanFramePayload {
+			arbitration_id: 0x1234,
+			data: 0x5678,
+		},
+	};
+
+	let mut bytes = Vec::new();
+	packet.serialize(&mut bytes);
+
+	let (decoded, rest) = NamedPacket::deserialize(&bytes).expect("deserialize should succeed");
+	assert_eq!(decoded, packet);
+	assert!(rest.is_empty());
+}
+
+#[test]
+fn struct_tuple_roundtrip() {
+	let packet = TuplePacket(
+		0x0A0B,
+		CanFramePayload {
+			arbitration_id: 0x0C0D,
+			data: 0x0E0F,
+		},
+	);
+
+	let mut bytes = Vec::new();
+	packet.serialize(&mut bytes);
+
+	let (decoded, rest) = TuplePacket::deserialize(&bytes).expect("deserialize should succeed");
+	assert_eq!(decoded, packet);
+	assert!(rest.is_empty());
+}
+
+#[test]
+fn struct_unit_roundtrip_preserves_remaining_bytes() {
+	let marker = Marker;
+	let mut bytes = Vec::new();
+	marker.serialize(&mut bytes);
+	assert!(bytes.is_empty());
+
+	let input = [0xAA, 0xBB];
+	let (decoded, rest) = Marker::deserialize(&input).expect("deserialize should succeed");
+	assert_eq!(decoded, Marker);
+	assert_eq!(rest, &input);
+}
+
+#[test]
+fn struct_deserialize_truncated_field_fails() {
+	let err = NamedPacket::deserialize(&[0x01]).expect_err("expected not enough data");
+	assert!(matches!(err, DeserializationError::NotEnoughData));
+}
diff --git a/liquidcan_rust/src/can_message.rs b/liquidcan_rust/src/can_message.rs
index 318b635..d677194 100644
--- a/liquidcan_rust/src/can_message.rs
+++ b/liquidcan_rust/src/can_message.rs
@@ -1,101 +1,76 @@
-use crate::payloads;
-use liquidcan_rust_macros::padded_enum;
-use liquidcan_rust_macros_derive::EnumDiscriminate;
-
-padded_enum! {
+use liquidcan_rust_macros::byte_codec::ByteCodec;
 
-(size = 64)
+use crate::payloads;
 
-#[derive(Debug, EnumDiscriminate, PartialEq, Clone)]
+#[derive(Debug, ByteCodec, PartialEq, Clone)]
 #[repr(u8)]
 pub enum CanMessage {
     // Node Discovery and Information
-    #[pad(63)]
     NodeInfoReq = 0, // NO payload
-    #[pad(0)]
     NodeInfoAnnouncement {
         payload: payloads::NodeInfoResPayload,
     } = 1,
 
     // Status Messages
-    #[pad(0)]
     InfoStatus {
-        payload: payloads::StatusPayload
+        payload: payloads::StatusPayload,
     } = 10,
-    #[pad(0)]
     WarningStatus {
-        payload: payloads::StatusPayload
+        payload: payloads::StatusPayload,
     } = 11,
-    #[pad(0)]
     ErrorStatus {
-       payload: payloads::StatusPayload
+        payload: payloads::StatusPayload,
     } = 12,
 
     // Field Registration
-    #[pad(0)]
     TelemetryValueRegistration {
         payload: payloads::FieldRegistrationPayload,
     } = 20,
-    #[pad(0)]
     ParameterRegistration {
         payload: payloads::FieldRegistrationPayload,
     } = 21,
 
     // Telemetry Group Management
-    #[pad(0)]
     TelemetryGroupDefinition {
         payload: payloads::TelemetryGroupDefinitionPayload,
     } = 30,
-    #[pad(0)]
     TelemetryGroupUpdate {
         payload: payloads::TelemetryGroupUpdatePayload,
     } = 31,
 
     // Heartbeat
-    #[pad(59)]
     HeartbeatReq {
-        payload: payloads::HeartbeatPayload
+        payload: payloads::HeartbeatPayload,
     } = 40,
-    #[pad(59)]
     HeartbeatRes {
-        payload: payloads::HeartbeatPayload
+        payload: payloads::HeartbeatPayload,
     } = 41,
 
     // Parameter Management
-    #[pad(1)]
     ParameterSetReq {
         payload: payloads::ParameterSetReqPayload,
     } = 50,
-    #[pad(0)]
     ParameterSetConfirmation {
         payload: payloads::ParameterSetConfirmationPayload,
     } = 51,
-    #[pad(61)]
     ParameterSetLockReq {
         payload: payloads::ParameterSetLockPayload,
     } = 52,
-    #[pad(61)]
     ParameterSetLockConfirmation {
         payload: payloads::ParameterSetLockPayload,
     } = 53,
 
     // Field Access
-    #[pad(62)]
     FieldGetReq {
         payload: payloads::FieldGetReqPayload,
     } = 60,
-    #[pad(0)]
     FieldGetRes {
         payload: payloads::FieldGetResPayload,
     } = 61,
-    #[pad(2)]
     FieldIDLookupReq {
         payload: payloads::FieldIDLookupReqPayload,
     } = 62,
-    #[pad(61)]
     FieldIDLookupRes {
         payload: payloads::FieldIDLookupResPayload,
     } = 63,
 }
-
-}
diff --git a/liquidcan_rust/src/message_conversion.rs b/liquidcan_rust/src/message_conversion.rs
index 6c1e368..18beb2b 100644
--- a/liquidcan_rust/src/message_conversion.rs
+++ b/liquidcan_rust/src/message_conversion.rs
@@ -1,27 +1,25 @@
 use crate::CanMessageFrame;
-use crate::can_message::{CanMessage, CanMessagePadded};
-use anyhow::anyhow;
-use zerocopy::{FromZeros, IntoBytes, TryFromBytes};
+use crate::can_message::CanMessage;
+use liquidcan_rust_macros::byte_codec::ByteCodec;
+use zerocopy::{FromZeros, IntoBytes};
 
 impl TryFrom<CanMessageFrame> for CanMessage {
     type Error = anyhow::Error;
 
     fn try_from(frame: CanMessageFrame) -> Result<Self, Self::Error> {
         let frame_data = frame.as_bytes();
-        let padded_msg = CanMessagePadded::try_read_from_bytes(frame_data)
-            .map_err(|e| anyhow!("Failed to convert message: {}", e))?;
-        let msg: CanMessage = padded_msg.into();
-        Ok(msg)
+        let (message, _) = CanMessage::deserialize(frame_data)?;
+        Ok(message)
     }
 }
 
 impl From<CanMessage> for CanMessageFrame {
     fn from(msg: CanMessage) -> Self {
         let mut msg_frame = CanMessageFrame::new_zeroed();
-        let discriminant = msg.discriminant();
-        let padded_msg: CanMessagePadded = msg.into();
-        // The first byte is the discriminant, which is set separately.
-        let bytes: &[u8] = &padded_msg.as_bytes()[1..];
+        let mut buf = Vec::with_capacity(64);
+        msg.serialize(&mut buf);
+        let discriminant = buf[0];
+        let bytes = &buf[1..];
         msg_frame.data[..bytes.len()].copy_from_slice(bytes);
         msg_frame.message_type = discriminant;
         msg_frame
@@ -226,7 +224,7 @@ mod tests {
         assert!(result.is_err(), "Expected error for invalid message type");
         let err_msg = result.unwrap_err().to_string();
         assert!(
-            err_msg.contains("Failed to convert message"),
+            err_msg.contains("invalid enum discriminant"),
             "Error message should mention conversion failure: {}",
             err_msg
         );

From a872508c5ff4a95ed5800fd7f241414790b74fbd Mon Sep 17 00:00:00 2001
From: Michael Debertol <michael.debertol@gmail.com>
Date: Wed, 4 Mar 2026 01:18:19 +0100
Subject: [PATCH 02/15] add variable length encoding based on data types

- add various data types used in the can protocol
- add conversion to/from socketcan structs
---
 liquidcan_rust/Cargo.toml                |   1 +
 liquidcan_rust/src/can_data.rs           | 356 +++++++++++++++++++++++
 liquidcan_rust/src/lib.rs                |   2 +-
 liquidcan_rust/src/message_conversion.rs | 135 ++++++---
 liquidcan_rust/src/payloads.rs           | 103 +++----
 liquidcan_rust/src/raw_can_message.rs    |  12 -
 6 files changed, 480 insertions(+), 129 deletions(-)
 create mode 100644 liquidcan_rust/src/can_data.rs

diff --git a/liquidcan_rust/Cargo.toml b/liquidcan_rust/Cargo.toml
index ac8d7d2..de340ef 100644
--- a/liquidcan_rust/Cargo.toml
+++ b/liquidcan_rust/Cargo.toml
@@ -11,3 +11,4 @@ zerocopy = "0.8.27"
 zerocopy-derive = "0.8.27"
 liquidcan_rust_macros = { path = "liquidcan_rust_macros" }
 liquidcan_rust_macros_derive = { path = "liquidcan_rust_macros/liquidcan_rust_macros_derive" }
+socketcan = "3.5.0"
diff --git a/liquidcan_rust/src/can_data.rs b/liquidcan_rust/src/can_data.rs
new file mode 100644
index 0000000..934ee2c
--- /dev/null
+++ b/liquidcan_rust/src/can_data.rs
@@ -0,0 +1,356 @@
+use liquidcan_rust_macros::byte_codec::{ByteCodec, DeserializationError};
+use modular_bitfield::Specifier;
+use zerocopy_derive::{Immutable, IntoBytes, TryFromBytes};
+
+#[derive(Specifier, Debug, Copy, Clone, PartialEq, Eq, Immutable, TryFromBytes, IntoBytes)]
+#[repr(u8)]
+pub enum CanDataType {
+    Float32 = 0,
+    Int32 = 1,
+    Int16 = 2,
+    Int8 = 3,
+    UInt32 = 4,
+    UInt16 = 5,
+    UInt8 = 6,
+    Boolean = 7,
+}
+
+impl CanDataType {
+    pub fn get_size(&self) -> usize {
+        match self {
+            CanDataType::Float32 => 4,
+            CanDataType::Int32 => 4,
+            CanDataType::Int16 => 2,
+            CanDataType::Int8 => 1,
+            CanDataType::UInt32 => 4,
+            CanDataType::UInt16 => 2,
+            CanDataType::UInt8 => 1,
+            CanDataType::Boolean => 1,
+        }
+    }
+}
+
+#[repr(u8)]
+#[derive(Debug, Clone, PartialEq)]
+pub enum CanDataValue {
+    Float32(f32) = 0,
+    Int32(i32) = 1,
+    Int16(i16) = 2,
+    Int8(i8) = 3,
+    UInt32(u32) = 4,
+    UInt16(u16) = 5,
+    UInt8(u8) = 6,
+    Boolean(bool) = 7,
+    Raw(Vec<u8>) = u8::MAX,
+}
+
+impl CanDataValue {
+    pub fn convert_from_slice(
+        data: &[u8],
+        data_type: CanDataType,
+    ) -> Result<Self, DeserializationError> {
+        if data.len() != data_type.get_size() {
+            return Err(DeserializationError::InvalidData(format!(
+                "Data length {} does not match expected length {} for type {:?}",
+                data.len(),
+                data_type.get_size(),
+                data_type
+            )));
+        }
+
+        match data_type {
+            CanDataType::Float32 => {
+                let mut arr = [0u8; 4];
+                arr.copy_from_slice(data);
+                Ok(CanDataValue::Float32(f32::from_le_bytes(arr)))
+            }
+            CanDataType::Int32 => {
+                let mut arr = [0u8; 4];
+                arr.copy_from_slice(data);
+                Ok(CanDataValue::Int32(i32::from_le_bytes(arr)))
+            }
+            CanDataType::Int16 => {
+                let mut arr = [0u8; 2];
+                arr.copy_from_slice(data);
+                Ok(CanDataValue::Int16(i16::from_le_bytes(arr)))
+            }
+            CanDataType::Int8 => Ok(CanDataValue::Int8(data[0] as i8)),
+            CanDataType::UInt32 => {
+                let mut arr = [0u8; 4];
+                arr.copy_from_slice(data);
+                Ok(CanDataValue::UInt32(u32::from_le_bytes(arr)))
+            }
+            CanDataType::UInt16 => {
+                let mut arr = [0u8; 2];
+                arr.copy_from_slice(data);
+                Ok(CanDataValue::UInt16(u16::from_le_bytes(arr)))
+            }
+            CanDataType::UInt8 => Ok(CanDataValue::UInt8(data[0])),
+            CanDataType::Boolean => Ok(CanDataValue::Boolean(data[0] != 0)),
+        }
+    }
+
+    /// Convert a Raw CanDataValue into a strongly-typed CanDataValue based on the provided CanDataType.
+    ///
+    /// Since the data type is not known at the time of deserialization, we initially deserialize into a Raw variant containing the raw bytes.
+    pub fn convert_from_raw(
+        &self,
+        data_type: CanDataType,
+    ) -> Result<CanDataValue, DeserializationError> {
+        let Self::Raw(raw_data) = self else {
+            return Err(DeserializationError::InvalidData(
+                "CanDataValue is not a Raw variant".to_string(),
+            ));
+        };
+
+        CanDataValue::convert_from_slice(raw_data, data_type)
+    }
+}
+
+impl ByteCodec for CanDataValue {
+    fn serialize(&self, out: &mut Vec<u8>) {
+        // don't include the tag in the serialized data, as message type must be known at deserialization time
+        match self {
+            CanDataValue::Float32(v) => {
+                out.extend_from_slice(&v.to_le_bytes());
+            }
+            CanDataValue::Int32(v) => {
+                out.extend_from_slice(&v.to_le_bytes());
+            }
+            CanDataValue::Int16(v) => {
+                out.extend_from_slice(&v.to_le_bytes());
+            }
+            CanDataValue::Int8(v) => {
+                out.push(*v as u8);
+            }
+            CanDataValue::UInt32(v) => {
+                out.extend_from_slice(&v.to_le_bytes());
+            }
+            CanDataValue::UInt16(v) => {
+                out.extend_from_slice(&v.to_le_bytes());
+            }
+            CanDataValue::UInt8(v) => {
+                out.push(*v);
+            }
+            CanDataValue::Boolean(v) => {
+                out.push(*v as u8);
+            }
+            CanDataValue::Raw(data) => {
+                out.extend_from_slice(&data);
+            }
+        }
+    }
+
+    fn deserialize(input: &[u8]) -> Result<(Self, &[u8]), DeserializationError> {
+        if input.is_empty() {
+            return Err(DeserializationError::InvalidData("Empty input".to_string()));
+        }
+
+        // Deserialization of CanDataValue requires external knowledge of the expected data type,
+        // so we can't determine the variant from the input data alone.
+        // Return the raw bytes and let the caller interpret them based on the expected data type.
+        Ok((CanDataValue::Raw(input.to_vec()), &[]))
+    }
+}
+
+/// Custom string type for CAN messages, fixed size of N bytes,
+/// null terminated (i.e. at most N-1 non-null bytes), ascii-only.
+#[derive(Debug, Clone)]
+pub struct CanString<const N: usize> {
+    data: [u8; N],
+}
+
+impl<const N: usize> From<[u8; N]> for CanString<N> {
+    fn from(data: [u8; N]) -> Self {
+        // Ensure the string is null-terminated
+        assert!(
+            data.iter().position(|&b| b == 0).is_some(),
+            "CanString must be null-terminated."
+        );
+        // Ensure all characters are ASCII
+        assert!(
+            data.iter().all(|&b| b.is_ascii()),
+            "CanString must contain only ASCII characters."
+        );
+        CanString { data }
+    }
+}
+
+impl<const N: usize> From<&str> for CanString<N> {
+    fn from(s: &str) -> Self {
+        let bytes = s.as_bytes();
+        assert!(bytes.len() < N, "String too long for CanString<{}>", N);
+
+        let mut data = [0u8; N];
+        data[..bytes.len()].copy_from_slice(bytes);
+
+        data.into()
+    }
+}
+
+impl<const N: usize> PartialEq for CanString<N> {
+    fn eq(&self, other: &Self) -> bool {
+        let self_len = self.data.iter().position(|&b| b == 0).unwrap();
+        let other_len = other.data.iter().position(|&b| b == 0).unwrap();
+        self_len == other_len && self.data[..self_len] == other.data[..other_len]
+    }
+}
+
+impl<const N: usize> ByteCodec for CanString<N> {
+    fn serialize(&self, out: &mut Vec<u8>) {
+        // Write bytes up to the null terminator
+        let length = self
+            .data
+            .iter()
+            .position(|&b| b == 0)
+            .expect("CanString must be null-terminated.");
+        out.extend_from_slice(&self.data[..length]);
+
+        out.push(0); // Null terminator
+    }
+
+    fn deserialize(input: &[u8]) -> Result<(Self, &[u8]), DeserializationError> {
+        if let Some(pos) = input.iter().position(|&b| b == 0) {
+            if pos < N {
+                let mut data = [0u8; N];
+                data[..pos].copy_from_slice(&input[..pos]);
+
+                Ok((data.into(), &input[pos + 1..]))
+            } else {
+                Err(DeserializationError::InvalidData(format!(
+                    "CanString exceeds maximum length of {}",
+                    N
+                )))
+            }
+        } else {
+            Err(DeserializationError::InvalidData(
+                "CanString is not null-terminated".to_string(),
+            ))
+        }
+    }
+}
+
+/// Represents a packed set of CAN data values.
+/// The raw byte form must fit into N bytes.
+#[derive(Clone, Debug, PartialEq)]
+pub struct PackedCanDataValues<const N: usize> {
+    data: Vec<u8>,
+}
+
+impl<const N: usize> PackedCanDataValues<N> {
+    /// Unpack the raw byte data into a vector of CanDataValue based on the provided data types.
+    /// The caller must ensure that the order and types of the data match what was originally packed.
+    pub fn unpack(&self, data_types: &[CanDataType]) -> Result<Vec<CanDataValue>, DeserializationError> {
+        let mut values = Vec::new();
+        let mut offset = 0;
+
+        for &data_type in data_types {
+            let size = data_type.get_size();
+            if offset + size > N {
+                return Err(DeserializationError::InvalidData(format!(
+                    "Not enough data to unpack CanDataValue of type {:?}",
+                    data_type
+                )));
+            }
+
+            let slice = &self.data[offset..offset + size];
+            let value = CanDataValue::convert_from_slice(slice, data_type)?;
+            values.push(value);
+            offset += size;
+        }
+
+        Ok(values)
+    }
+}
+
+impl<const N: usize> TryFrom<&[CanDataValue]> for PackedCanDataValues<N> {
+    type Error = String;
+
+    fn try_from(values: &[CanDataValue]) -> Result<Self, Self::Error> {
+        let mut data = Vec::new();
+        for value in values {
+            value.serialize(&mut data);
+        }
+        if data.len() > N {
+            return Err(format!(
+                "Packed data length {} exceeds maximum of {}",
+                data.len(),
+                N
+            ));
+        }
+        Ok(PackedCanDataValues { data })
+    }
+}
+
+impl<const N: usize> ByteCodec for PackedCanDataValues<N> {
+    fn serialize(&self, out: &mut Vec<u8>) {
+        out.extend_from_slice(&self.data);
+    }
+
+    fn deserialize(input: &[u8]) -> Result<(Self, &[u8]), DeserializationError> {
+        let len = input.len().min(N);
+        let data = input[..len].to_vec();
+        Ok((PackedCanDataValues { data }, &input[len..]))
+    }
+}
+
+
+
+/// Up to N bytes that do not include a null byte.
+#[derive(Debug, Clone)]
+pub struct NonNullCanBytes<const N: usize> {
+    data: [u8; N],
+}
+
+impl<const N: usize> TryFrom<&[u8]> for NonNullCanBytes<N> {
+    type Error = String;
+
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
+        if value.len() > N {
+            return Err(format!(
+                "Input data length {} exceeds maximum of {}",
+                value.len(),
+                N
+            ));
+        }
+        if value.iter().any(|&b| b == 0) {
+            return Err("Input data contains null byte".to_string());
+        }
+        let mut data = [0u8; N];
+        data[..value.len()].copy_from_slice(value);
+        Ok(NonNullCanBytes { data })
+    }
+}
+
+impl<'a, const N: usize> From<&'a NonNullCanBytes<N>> for &'a [u8] {
+    fn from(value: &'a NonNullCanBytes<N>) -> Self {
+        let len = value.data.iter().position(|&b| b == 0).unwrap_or(N);
+        &value.data[..len]
+    }
+}
+
+impl<const N: usize> ByteCodec for NonNullCanBytes<N> {
+    fn serialize(&self, out: &mut Vec<u8>) {
+        let len = self.data.iter().position(|&b| b == 0).unwrap_or(N);
+        out.extend_from_slice(&self.data[..len]);
+    }
+
+    fn deserialize(input: &[u8]) -> Result<(Self, &[u8]), DeserializationError> {
+        let len = input
+            .iter()
+            .position(|&b| b == 0)
+            .unwrap_or(input.len())
+            .min(N);
+        let mut data = [0u8; N];
+        data[..len].copy_from_slice(&input[..len]);
+        Ok((NonNullCanBytes { data }, &input[len..]))
+    }
+}
+
+impl<const N: usize> PartialEq for NonNullCanBytes<N> {
+    fn eq(&self, other: &Self) -> bool {
+        let self_len = self.data.iter().position(|&b| b == 0).unwrap_or(N);
+        let other_len = other.data.iter().position(|&b| b == 0).unwrap_or(N);
+        self_len == other_len && self.data[..self_len] == other.data[..other_len]
+    }
+}
diff --git a/liquidcan_rust/src/lib.rs b/liquidcan_rust/src/lib.rs
index 66b6774..f103c94 100644
--- a/liquidcan_rust/src/lib.rs
+++ b/liquidcan_rust/src/lib.rs
@@ -2,7 +2,7 @@ pub mod can_message;
 pub mod message_conversion;
 pub mod payloads;
 pub mod raw_can_message;
+mod can_data;
 
 pub use can_message::CanMessage;
-pub use raw_can_message::CanMessageFrame;
 pub use raw_can_message::CanMessageId;
diff --git a/liquidcan_rust/src/message_conversion.rs b/liquidcan_rust/src/message_conversion.rs
index 18beb2b..3aff97f 100644
--- a/liquidcan_rust/src/message_conversion.rs
+++ b/liquidcan_rust/src/message_conversion.rs
@@ -1,46 +1,64 @@
-use crate::CanMessageFrame;
 use crate::can_message::CanMessage;
 use liquidcan_rust_macros::byte_codec::ByteCodec;
-use zerocopy::{FromZeros, IntoBytes};
+use socketcan::EmbeddedFrame;
 
-impl TryFrom<CanMessageFrame> for CanMessage {
+impl TryFrom<socketcan::CanFdFrame> for CanMessage {
     type Error = anyhow::Error;
 
-    fn try_from(frame: CanMessageFrame) -> Result<Self, Self::Error> {
-        let frame_data = frame.as_bytes();
+    fn try_from(frame: socketcan::CanFdFrame) -> Result<Self, Self::Error> {
+        let frame_data = frame.data();
         let (message, _) = CanMessage::deserialize(frame_data)?;
         Ok(message)
     }
 }
 
-impl From<CanMessage> for CanMessageFrame {
+impl From<CanMessage> for socketcan::CanFdFrame {
     fn from(msg: CanMessage) -> Self {
-        let mut msg_frame = CanMessageFrame::new_zeroed();
         let mut buf = Vec::with_capacity(64);
         msg.serialize(&mut buf);
-        let discriminant = buf[0];
-        let bytes = &buf[1..];
-        msg_frame.data[..bytes.len()].copy_from_slice(bytes);
-        msg_frame.message_type = discriminant;
-        msg_frame
+
+        // ID needs to be set at a later point
+        let id = socketcan::StandardId::ZERO;
+
+        socketcan::CanFdFrame::new(id, &buf).unwrap()
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::CanMessageFrame;
     use crate::can_message::CanMessage;
     use crate::payloads;
-    use zerocopy::FromZeros;
+    use socketcan::EmbeddedFrame;
 
     fn test_round_trip(msg: CanMessage) {
-        let can_data: CanMessageFrame = msg.clone().into();
+        let can_data: socketcan::CanFdFrame = msg.clone().into();
         let msg_back: CanMessage = can_data
             .try_into()
             .expect("Failed to convert back to Command");
         assert_eq!(msg, msg_back);
     }
 
+    fn test_round_trip_lossy(msg: CanMessage) {
+        let can_data: socketcan::CanFdFrame = msg.into();
+        let msg_back: CanMessage = can_data
+            .try_into()
+            .expect("Failed to convert back to Command");
+
+        // For payloads where type metadata is absent, decode is intentionally lossy.
+        // Assert canonical wire round-tripping instead of strict AST equality.
+        let can_data_back: socketcan::CanFdFrame = msg_back.clone().into();
+        assert_eq!(
+            can_data.data(),
+            can_data_back.data(),
+            "encoded bytes must be stable after one decode/encode cycle"
+        );
+
+        let msg_back_again: CanMessage = can_data_back
+            .try_into()
+            .expect("Failed to convert canonical bytes back to Command");
+        assert_eq!(msg_back, msg_back_again);
+    }
+
     #[test]
     fn test_node_info_req() {
         let msg = CanMessage::NodeInfoReq;
@@ -54,7 +72,7 @@ mod tests {
             par_count: 5,
             firmware_hash: 1234,
             liquid_hash: 5678,
-            device_name: [0xAA; 53],
+            device_name: "Test".into(),
         };
         let msg = CanMessage::NodeInfoAnnouncement { payload };
         test_round_trip(msg);
@@ -62,21 +80,27 @@ mod tests {
 
     #[test]
     fn test_info_status() {
-        let payload = payloads::StatusPayload { msg: [0xBB; 63] };
+        let payload = payloads::StatusPayload {
+            msg: "Info status message".into(),
+        };
         let msg = CanMessage::InfoStatus { payload };
         test_round_trip(msg);
     }
 
     #[test]
     fn test_warning_status() {
-        let payload = payloads::StatusPayload { msg: [0xCC; 63] };
+        let payload = payloads::StatusPayload {
+            msg: "Warning status message".into(),
+        };
         let msg = CanMessage::WarningStatus { payload };
         test_round_trip(msg);
     }
 
     #[test]
     fn test_error_status() {
-        let payload = payloads::StatusPayload { msg: [0xDD; 63] };
+        let payload = payloads::StatusPayload {
+            msg: "Error status message".into(),
+        };
         let msg = CanMessage::ErrorStatus { payload };
         test_round_trip(msg);
     }
@@ -86,7 +110,7 @@ mod tests {
         let payload = payloads::FieldRegistrationPayload {
             field_id: 5,
             field_type: payloads::CanDataType::UInt16,
-            field_name: [0xEE; 61],
+            field_name: "Telemetry Value Field".into(),
         };
         let msg = CanMessage::TelemetryValueRegistration { payload };
         test_round_trip(msg);
@@ -97,7 +121,7 @@ mod tests {
         let payload = payloads::FieldRegistrationPayload {
             field_id: 7,
             field_type: payloads::CanDataType::Boolean,
-            field_name: [0xFF; 61],
+            field_name: "Parameter Field".into(),
         };
         let msg = CanMessage::ParameterRegistration { payload };
         test_round_trip(msg);
@@ -107,7 +131,7 @@ mod tests {
     fn test_telemetry_group_definition() {
         let payload = payloads::TelemetryGroupDefinitionPayload {
             group_id: 3,
-            field_ids: [0xFA; 62],
+            field_ids: [0xFA; 62].as_slice().try_into().unwrap(),
         };
         let msg = CanMessage::TelemetryGroupDefinition { payload };
         test_round_trip(msg);
@@ -115,12 +139,17 @@ mod tests {
 
     #[test]
     fn test_telemetry_group_update() {
+        let data_values = [
+            payloads::CanDataValue::Int32(42),
+            payloads::CanDataValue::Float32(3.14),
+            payloads::CanDataValue::Boolean(true),
+        ];
         let payload = payloads::TelemetryGroupUpdatePayload {
             group_id: 4,
-            values: [0xFB; 62],
+            values: data_values.as_slice().try_into().unwrap(),
         };
         let msg = CanMessage::TelemetryGroupUpdate { payload };
-        test_round_trip(msg);
+        test_round_trip_lossy(msg);
     }
 
     #[test]
@@ -141,10 +170,10 @@ mod tests {
     fn test_parameter_set_req() {
         let payload = payloads::ParameterSetReqPayload {
             parameter_id: 10,
-            value: [0xAA; 61],
+            value: payloads::CanDataValue::Int32(67),
         };
         let msg = CanMessage::ParameterSetReq { payload };
-        test_round_trip(msg);
+        test_round_trip_lossy(msg);
     }
 
     #[test]
@@ -152,10 +181,10 @@ mod tests {
         let payload = payloads::ParameterSetConfirmationPayload {
             parameter_id: 11,
             status: payloads::ParameterSetStatus::Success,
-            value: [0xBB; 61],
+            value: payloads::CanDataValue::Float32(42.0),
         };
         let msg = CanMessage::ParameterSetConfirmation { payload };
-        test_round_trip(msg);
+        test_round_trip_lossy(msg);
     }
 
     #[test]
@@ -189,16 +218,16 @@ mod tests {
     fn test_field_get_res() {
         let payload = payloads::FieldGetResPayload {
             field_id: 21,
-            value: [0xCC; 62],
+            value: payloads::CanDataValue::Boolean(true),
         };
         let msg = CanMessage::FieldGetRes { payload };
-        test_round_trip(msg);
+        test_round_trip_lossy(msg);
     }
 
     #[test]
     fn test_field_id_lookup_req() {
         let payload = payloads::FieldIDLookupReqPayload {
-            field_name: [0xDD; 61],
+            field_name: "Test Field Name".into(),
         };
         let msg = CanMessage::FieldIDLookupReq { payload };
         test_round_trip(msg);
@@ -217,8 +246,7 @@ mod tests {
     #[test]
     fn test_invalid_message_type() {
         // Create a frame with an invalid message type (255 is not defined)
-        let mut frame = CanMessageFrame::new_zeroed();
-        frame.message_type = 255;
+        let frame = socketcan::CanFdFrame::new(socketcan::StandardId::ZERO, &[255]).unwrap();
 
         let result: Result<CanMessage, _> = frame.try_into();
         assert!(result.is_err(), "Expected error for invalid message type");
@@ -233,11 +261,16 @@ mod tests {
     #[test]
     fn test_invalid_can_data_type() {
         // Create a FieldRegistration with invalid CanDataType (255 is out of range)
-        let mut frame = CanMessageFrame::new_zeroed();
-        frame.message_type = 20; // TelemetryValueRegistration
-        frame.data[0] = 5; // field_id
-        frame.data[1] = 255; // Invalid CanDataType
-        // Rest is field_name
+        let frame = socketcan::CanFdFrame::new(
+            socketcan::StandardId::ZERO,
+            &[
+                20, // TelemetryValueRegistration
+                5,  // field_id
+                255, // Invalid CanDataType
+                    // Rest is field_name
+            ],
+        )
+        .unwrap();
 
         let result: Result<CanMessage, _> = frame.try_into();
         assert!(result.is_err(), "Expected error for invalid CanDataType");
@@ -246,10 +279,15 @@ mod tests {
     #[test]
     fn test_invalid_parameter_set_status() {
         // Create a ParameterSetConfirmation with invalid status
-        let mut frame = CanMessageFrame::new_zeroed();
-        frame.message_type = 51; // ParameterSetConfirmation
-        frame.data[0] = 10; // parameter_id
-        frame.data[1] = 255; // Invalid ParameterSetStatus
+        let frame = socketcan::CanFdFrame::new(
+            socketcan::StandardId::ZERO,
+            &[
+                51,  // ParameterSetConfirmation
+                10,  // parameter_id
+                255, // Invalid ParameterSetStatus
+            ],
+        )
+        .unwrap();
         // Rest is value
 
         let result: Result<CanMessage, _> = frame.try_into();
@@ -262,10 +300,15 @@ mod tests {
     #[test]
     fn test_invalid_parameter_lock_status() {
         // Create a ParameterSetLockReq with invalid lock status
-        let mut frame = CanMessageFrame::new_zeroed();
-        frame.message_type = 52; // ParameterSetLockReq
-        frame.data[0] = 12; // parameter_id
-        frame.data[1] = 255; // Invalid ParameterLockStatus
+        let frame = socketcan::CanFdFrame::new(
+            socketcan::StandardId::ZERO,
+            &[
+                52,  // ParameterSetLockReq
+                12,  // parameter_id
+                255, // Invalid ParameterLockStatus
+            ],
+        )
+        .unwrap();
 
         let result: Result<CanMessage, _> = frame.try_into();
         assert!(
diff --git a/liquidcan_rust/src/payloads.rs b/liquidcan_rust/src/payloads.rs
index c4e837f..199991c 100644
--- a/liquidcan_rust/src/payloads.rs
+++ b/liquidcan_rust/src/payloads.rs
@@ -1,18 +1,9 @@
-use modular_bitfield::{Specifier, private::static_assertions};
-use zerocopy_derive::{FromBytes, Immutable, IntoBytes, TryFromBytes};
+use liquidcan_rust_macros::byte_codec::ByteCodec;
+use modular_bitfield::Specifier;
+use zerocopy_derive::{Immutable, IntoBytes, TryFromBytes};
+
+pub use crate::can_data::{CanDataType, CanDataValue, CanString, NonNullCanBytes, PackedCanDataValues};
 
-#[derive(Specifier, Debug, Copy, Clone, PartialEq, Eq, Immutable, TryFromBytes, IntoBytes)]
-#[repr(u8)]
-pub enum CanDataType {
-    Float32 = 0,
-    Int32 = 1,
-    Int16 = 2,
-    Int8 = 3,
-    UInt32 = 4,
-    UInt16 = 5,
-    UInt8 = 6,
-    Boolean = 7,
-}
 
 #[derive(Specifier, Debug, Copy, Clone, PartialEq, Eq, Immutable, TryFromBytes, IntoBytes)]
 #[repr(u8)]
@@ -30,112 +21,84 @@ pub enum ParameterLockStatus {
     Locked = 1,
 }
 
-#[derive(Debug, Clone, FromBytes, IntoBytes, Immutable, PartialEq)]
-#[repr(C, packed)]
+#[derive(Debug, Clone, ByteCodec, PartialEq)]
 pub struct NodeInfoResPayload {
-    pub tel_count: u8,         // Number of telemetryValues on this node
-    pub par_count: u8,         // Number of parameters on this node
-    pub firmware_hash: u32,    // Hash of the firmware version
-    pub liquid_hash: u32,      // Hash of the LiquidCan protocol version
-    pub device_name: [u8; 53], // Human-readable device name
+    pub tel_count: u8,              // Number of telemetryValues on this node
+    pub par_count: u8,              // Number of parameters on this node
+    pub firmware_hash: u32,         // Hash of the firmware version
+    pub liquid_hash: u32,           // Hash of the LiquidCan protocol version
+    pub device_name: CanString<53>, // Human-readable device name
 }
 
-#[derive(Debug, Clone, FromBytes, IntoBytes, Immutable, PartialEq)]
-#[repr(C, packed)]
+#[derive(Debug, Clone, ByteCodec, PartialEq)]
 pub struct StatusPayload {
-    pub msg: [u8; 63], // Status message text
+    pub msg: CanString<63>, // Status message text
 }
 
-// Important: only derives TryFromBytes because enum CanDataType doesn't cover all possible enum variants for u8
-#[derive(Debug, Clone, TryFromBytes, IntoBytes, Immutable, PartialEq)]
-#[repr(C, packed)]
+#[derive(Debug, Clone, ByteCodec, PartialEq)]
 pub struct FieldRegistrationPayload {
-    pub field_id: u8,            // Unique identifier for this field
-    pub field_type: CanDataType, // Data type
-    pub field_name: [u8; 61],    // Human-readable field name
+    pub field_id: u8,              // Unique identifier for this field
+    pub field_type: CanDataType,   // Data type
+    pub field_name: CanString<61>, // Human-readable field name
 }
 
-#[derive(Debug, Clone, FromBytes, IntoBytes, Immutable, PartialEq)]
-#[repr(C, packed)]
+#[derive(Debug, Clone, ByteCodec, PartialEq)]
 pub struct TelemetryGroupDefinitionPayload {
     pub group_id: u8,        // Unique identifier for this group
-    pub field_ids: [u8; 62], // Array of field IDs in this group
+    pub field_ids: NonNullCanBytes<62>, // Array of field IDs in this group
 }
 
-#[derive(Debug, Clone, FromBytes, IntoBytes, Immutable, PartialEq)]
-#[repr(C, packed)]
+#[derive(Debug, Clone, ByteCodec, PartialEq)]
 pub struct TelemetryGroupUpdatePayload {
     pub group_id: u8,     // Group identifier
-    pub values: [u8; 62], // Packed values of all telemetry values in the group
+    pub values: PackedCanDataValues<62>, // Packed values of all telemetry values in the group
 }
 
-#[derive(Debug, Clone, FromBytes, IntoBytes, Immutable, PartialEq)]
-#[repr(C, packed)]
+#[derive(Debug, Clone, ByteCodec, PartialEq)]
 pub struct HeartbeatPayload {
     pub counter: u32, // Incrementing counter value
 }
 
-#[derive(Debug, Clone, FromBytes, IntoBytes, Immutable, PartialEq)]
-#[repr(C, packed)]
+#[derive(Debug, Clone, ByteCodec, PartialEq)]
 pub struct ParameterSetReqPayload {
     pub parameter_id: u8, // Parameter identifier
-    pub value: [u8; 61],  // New value (type depends on parameter)
+    pub value: CanDataValue,  // New value (type depends on parameter)
 }
 
 // Important: only derives TryFromBytes because enum ParameterSetStatus doesn't cover all possible enum variants for u8
-#[derive(Debug, Clone, TryFromBytes, IntoBytes, Immutable, PartialEq)]
-#[repr(C, packed)]
+#[derive(Debug, Clone, ByteCodec, PartialEq)]
 pub struct ParameterSetConfirmationPayload {
     pub parameter_id: u8,           // Parameter identifier
     pub status: ParameterSetStatus, // Status code
-    pub value: [u8; 61],            // Confirmed value after set operation
+    pub value: CanDataValue,        // Confirmed value after set operation
 }
 
-#[derive(Debug, Clone, FromBytes, IntoBytes, Immutable, PartialEq)]
-#[repr(C, packed)]
+#[derive(Debug, Clone, ByteCodec, PartialEq)]
 pub struct FieldGetReqPayload {
     pub field_id: u8, // Field identifier
 }
 
-#[derive(Debug, Clone, FromBytes, IntoBytes, Immutable, PartialEq)]
-#[repr(C, packed)]
+#[derive(Debug, Clone, ByteCodec, PartialEq)]
 pub struct FieldGetResPayload {
     pub field_id: u8,    // Field identifier
-    pub value: [u8; 62], // Field value
+    pub value: CanDataValue, // Field value
 }
 
-#[derive(Debug, Clone, FromBytes, IntoBytes, Immutable, PartialEq)]
-#[repr(C, packed)]
+#[derive(Debug, Clone, ByteCodec, PartialEq)]
 pub struct FieldIDLookupReqPayload {
-    pub field_name: [u8; 61], // Field name
+    pub field_name: CanString<61>, // Field name
 }
 
 // Important: only derives TryFromBytes because enum CanDataType doesn't cover all possible enum variants for u8
-#[derive(Debug, Clone, TryFromBytes, IntoBytes, Immutable, PartialEq)]
-#[repr(C, packed)]
+#[derive(Debug, Clone, ByteCodec, PartialEq)]
 pub struct FieldIDLookupResPayload {
     pub field_id: u8,            // Field ID
     pub field_type: CanDataType, // Field Datatype
 }
 
 // Important: only derives TryFromBytes because bool doesn't derive FromBytes
-#[derive(Debug, Clone, TryFromBytes, IntoBytes, Immutable, PartialEq)]
-#[repr(C, packed)]
+#[derive(Debug, Clone, ByteCodec, PartialEq)]
 pub struct ParameterSetLockPayload {
     pub parameter_id: u8,                    // Parameter identifier to lock
     pub parameter_lock: ParameterLockStatus, // Lock status (0=unlocked, 1=locked)
 }
-
-static_assertions::const_assert_eq!(size_of::<NodeInfoResPayload>(), 63);
-static_assertions::const_assert_eq!(size_of::<StatusPayload>(), 63);
-static_assertions::const_assert_eq!(size_of::<FieldRegistrationPayload>(), 63);
-static_assertions::const_assert_eq!(size_of::<TelemetryGroupDefinitionPayload>(), 63);
-static_assertions::const_assert_eq!(size_of::<TelemetryGroupUpdatePayload>(), 63);
-static_assertions::const_assert_eq!(size_of::<HeartbeatPayload>(), 4);
-static_assertions::const_assert_eq!(size_of::<ParameterSetReqPayload>(), 62);
-static_assertions::const_assert_eq!(size_of::<ParameterSetConfirmationPayload>(), 63);
-static_assertions::const_assert_eq!(size_of::<FieldGetReqPayload>(), 1);
-static_assertions::const_assert_eq!(size_of::<FieldGetResPayload>(), 63);
-static_assertions::const_assert_eq!(size_of::<FieldIDLookupReqPayload>(), 61);
-static_assertions::const_assert_eq!(size_of::<FieldIDLookupResPayload>(), 2);
-static_assertions::const_assert_eq!(size_of::<ParameterSetLockPayload>(), 2);
diff --git a/liquidcan_rust/src/raw_can_message.rs b/liquidcan_rust/src/raw_can_message.rs
index f183066..9eb15e3 100644
--- a/liquidcan_rust/src/raw_can_message.rs
+++ b/liquidcan_rust/src/raw_can_message.rs
@@ -1,8 +1,5 @@
 use modular_bitfield::prelude::B5;
-use modular_bitfield::private::static_assertions;
 use modular_bitfield::{Specifier, bitfield};
-use std::mem::size_of;
-use zerocopy_derive::{FromBytes, Immutable, IntoBytes, KnownLayout};
 
 #[derive(Specifier, Debug, PartialEq, Eq)]
 pub enum CanMessagePriority {
@@ -20,12 +17,3 @@ pub struct CanMessageId {
     #[skip]
     __: B5,
 }
-
-#[derive(Debug, IntoBytes, FromBytes, Immutable, KnownLayout)]
-#[repr(C, packed)]
-pub struct CanMessageFrame {
-    pub message_type: u8,
-    pub data: [u8; 63],
-}
-
-static_assertions::const_assert_eq!(size_of::<CanMessageFrame>(), 64);

From 402d0f5e3829cef757a3f05e2cff8c3ab3f084b4 Mon Sep 17 00:00:00 2001
From: Michael Debertol <michael.debertol@gmail.com>
Date: Wed, 4 Mar 2026 01:33:40 +0100
Subject: [PATCH 03/15] add MAX_SERIALIZED_SIZE to ByteCodec

---
 .../liquidcan_rust_macros_derive/src/lib.rs   | 82 ++++++++++++++++++-
 .../liquidcan_rust_macros/src/byte_codec.rs   |  5 +-
 liquidcan_rust/src/can_data.rs                |  8 ++
 liquidcan_rust/src/can_message.rs             |  2 +
 liquidcan_rust/src/payloads.rs                | 15 ++++
 5 files changed, 110 insertions(+), 2 deletions(-)

diff --git a/liquidcan_rust/liquidcan_rust_macros/liquidcan_rust_macros_derive/src/lib.rs b/liquidcan_rust/liquidcan_rust_macros/liquidcan_rust_macros_derive/src/lib.rs
index 5653107..6cc008b 100644
--- a/liquidcan_rust/liquidcan_rust_macros/liquidcan_rust_macros_derive/src/lib.rs
+++ b/liquidcan_rust/liquidcan_rust_macros/liquidcan_rust_macros_derive/src/lib.rs
@@ -1,7 +1,8 @@
 use proc_macro::TokenStream;
 use quote::{format_ident, quote};
 use syn::{
-    Data, DeriveInput, Fields, Variant, parse_macro_input, punctuated::Punctuated, token::Comma,
+    Data, DeriveInput, Fields, Type, Variant, parse_macro_input, punctuated::Punctuated,
+    token::Comma,
 };
 
 #[proc_macro_derive(ByteCodec)]
@@ -12,22 +13,26 @@ pub fn derive_byte_codec(input: TokenStream) -> TokenStream {
     let expanded = match &input.data {
         Data::Enum(data_enum) => {
             let variants = &data_enum.variants;
+            let max_size_impl = build_enum_max_serialized_size(variants);
             let serialize_impl = build_serialize(type_name, variants);
             let deserialize_impl = build_deserialize(type_name, variants);
 
             quote! {
                 impl liquidcan_rust_macros::byte_codec::ByteCodec for #type_name {
+                    #max_size_impl
                     #serialize_impl
                     #deserialize_impl
                 }
             }
         }
         Data::Struct(data_struct) => {
+            let max_size_impl = build_struct_max_serialized_size(&data_struct.fields);
             let serialize_impl = build_struct_serialize(type_name, &data_struct.fields);
             let deserialize_impl = build_struct_deserialize(type_name, &data_struct.fields);
 
             quote! {
                 impl liquidcan_rust_macros::byte_codec::ByteCodec for #type_name {
+                    #max_size_impl
                     #serialize_impl
                     #deserialize_impl
                 }
@@ -93,6 +98,81 @@ fn build_serialize(
     return expanded;
 }
 
+fn max_size_for_type(ty: &Type) -> proc_macro2::TokenStream {
+    quote! {
+        <#ty as liquidcan_rust_macros::byte_codec::ByteCodec>::MAX_SERIALIZED_SIZE
+    }
+}
+
+fn sum_max_sizes(types: Vec<&Type>) -> proc_macro2::TokenStream {
+    let field_sizes: Vec<_> = types.into_iter().map(max_size_for_type).collect();
+    quote! {
+        0usize #( + #field_sizes )*
+    }
+}
+
+fn build_struct_max_serialized_size(fields: &Fields) -> proc_macro2::TokenStream {
+    let payload_size = match fields {
+        Fields::Named(named) => {
+            let types: Vec<_> = named.named.iter().map(|f| &f.ty).collect();
+            sum_max_sizes(types)
+        }
+        Fields::Unnamed(unnamed) => {
+            let types: Vec<_> = unnamed.unnamed.iter().map(|f| &f.ty).collect();
+            sum_max_sizes(types)
+        }
+        Fields::Unit => quote! { 0usize },
+    };
+
+    quote! {
+        const MAX_SERIALIZED_SIZE: usize = #payload_size;
+    }
+}
+
+fn build_enum_max_serialized_size(
+    variants: &Punctuated<Variant, Comma>,
+) -> proc_macro2::TokenStream {
+    let variant_sizes: Vec<_> = variants
+        .iter()
+        .map(|variant| {
+            let payload_size = match &variant.fields {
+                Fields::Named(named) => {
+                    let types: Vec<_> = named.named.iter().map(|f| &f.ty).collect();
+                    sum_max_sizes(types)
+                }
+                Fields::Unnamed(unnamed) => {
+                    let types: Vec<_> = unnamed.unnamed.iter().map(|f| &f.ty).collect();
+                    sum_max_sizes(types)
+                }
+                Fields::Unit => quote! { 0usize },
+            };
+
+            quote! {
+                1usize + (#payload_size)
+            }
+        })
+        .collect();
+
+    let mut max_expr = variant_sizes
+        .first()
+        .cloned()
+        .expect("ByteCodec cannot be derived for enums without variants");
+
+    for size_expr in variant_sizes.iter().skip(1) {
+        max_expr = quote! {
+            {
+                let a = #max_expr;
+                let b = #size_expr;
+                if a > b { a } else { b }
+            }
+        };
+    }
+
+    quote! {
+        const MAX_SERIALIZED_SIZE: usize = #max_expr;
+    }
+}
+
 fn build_deserialize(
     enum_name: &syn::Ident,
     variants: &Punctuated<Variant, Comma>,
diff --git a/liquidcan_rust/liquidcan_rust_macros/src/byte_codec.rs b/liquidcan_rust/liquidcan_rust_macros/src/byte_codec.rs
index e8c7968..091c218 100644
--- a/liquidcan_rust/liquidcan_rust_macros/src/byte_codec.rs
+++ b/liquidcan_rust/liquidcan_rust_macros/src/byte_codec.rs
@@ -3,6 +3,7 @@ use thiserror::Error;
 use zerocopy::{Immutable, IntoBytes, TryFromBytes};
 
 pub trait ByteCodec {
+    const MAX_SERIALIZED_SIZE: usize;
     fn serialize(&self, out: &mut Vec<u8>);
     fn deserialize(input: &[u8]) -> Result<(Self, &[u8]), DeserializationError>
     where
@@ -13,12 +14,14 @@ impl<T> ByteCodec for T
 where
     T: TryFromBytes + IntoBytes + Immutable + Sized,
 {
+    const MAX_SERIALIZED_SIZE: usize = core::mem::size_of::<T>();
+
     fn serialize(&self, out: &mut Vec<u8>) {
         out.extend_from_slice(self.as_bytes());
     }
 
     fn deserialize(input: &[u8]) -> Result<(Self, &[u8]), DeserializationError> {
-        let size = core::mem::size_of::<T>();
+        let size = Self::MAX_SERIALIZED_SIZE;
         if input.len() < size {
             return Err(DeserializationError::NotEnoughData);
         }
diff --git a/liquidcan_rust/src/can_data.rs b/liquidcan_rust/src/can_data.rs
index 934ee2c..2ef2e98 100644
--- a/liquidcan_rust/src/can_data.rs
+++ b/liquidcan_rust/src/can_data.rs
@@ -108,6 +108,8 @@ impl CanDataValue {
 }
 
 impl ByteCodec for CanDataValue {
+    const MAX_SERIALIZED_SIZE: usize = 4;
+
     fn serialize(&self, out: &mut Vec<u8>) {
         // don't include the tag in the serialized data, as message type must be known at deserialization time
         match self {
@@ -197,6 +199,8 @@ impl<const N: usize> PartialEq for CanString<N> {
 }
 
 impl<const N: usize> ByteCodec for CanString<N> {
+    const MAX_SERIALIZED_SIZE: usize = N;
+
     fn serialize(&self, out: &mut Vec<u8>) {
         // Write bytes up to the null terminator
         let length = self
@@ -283,6 +287,8 @@ impl<const N: usize> TryFrom<&[CanDataValue]> for PackedCanDataValues<N> {
 }
 
 impl<const N: usize> ByteCodec for PackedCanDataValues<N> {
+    const MAX_SERIALIZED_SIZE: usize = N;
+
     fn serialize(&self, out: &mut Vec<u8>) {
         out.extend_from_slice(&self.data);
     }
@@ -330,6 +336,8 @@ impl<'a, const N: usize> From<&'a NonNullCanBytes<N>> for &'a [u8] {
 }
 
 impl<const N: usize> ByteCodec for NonNullCanBytes<N> {
+    const MAX_SERIALIZED_SIZE: usize = N;
+
     fn serialize(&self, out: &mut Vec<u8>) {
         let len = self.data.iter().position(|&b| b == 0).unwrap_or(N);
         out.extend_from_slice(&self.data[..len]);
diff --git a/liquidcan_rust/src/can_message.rs b/liquidcan_rust/src/can_message.rs
index d677194..70bb33e 100644
--- a/liquidcan_rust/src/can_message.rs
+++ b/liquidcan_rust/src/can_message.rs
@@ -74,3 +74,5 @@ pub enum CanMessage {
         payload: payloads::FieldIDLookupResPayload,
     } = 63,
 }
+
+static_assertions::const_assert_eq!(CanMessage::MAX_SERIALIZED_SIZE, 64);
diff --git a/liquidcan_rust/src/payloads.rs b/liquidcan_rust/src/payloads.rs
index 199991c..1947e53 100644
--- a/liquidcan_rust/src/payloads.rs
+++ b/liquidcan_rust/src/payloads.rs
@@ -102,3 +102,18 @@ pub struct ParameterSetLockPayload {
     pub parameter_id: u8,                    // Parameter identifier to lock
     pub parameter_lock: ParameterLockStatus, // Lock status (0=unlocked, 1=locked)
 }
+
+
+static_assertions::const_assert_eq!(NodeInfoResPayload::MAX_SERIALIZED_SIZE, 63);
+static_assertions::const_assert_eq!(StatusPayload::MAX_SERIALIZED_SIZE, 63);
+static_assertions::const_assert_eq!(FieldRegistrationPayload::MAX_SERIALIZED_SIZE, 63);
+static_assertions::const_assert_eq!(TelemetryGroupDefinitionPayload::MAX_SERIALIZED_SIZE, 63);
+static_assertions::const_assert_eq!(TelemetryGroupUpdatePayload::MAX_SERIALIZED_SIZE, 63);
+static_assertions::const_assert_eq!(HeartbeatPayload::MAX_SERIALIZED_SIZE, 4);
+static_assertions::const_assert_eq!(ParameterSetReqPayload::MAX_SERIALIZED_SIZE, 5);
+static_assertions::const_assert_eq!(ParameterSetConfirmationPayload::MAX_SERIALIZED_SIZE, 6);
+static_assertions::const_assert_eq!(FieldGetReqPayload::MAX_SERIALIZED_SIZE, 1);
+static_assertions::const_assert_eq!(FieldGetResPayload::MAX_SERIALIZED_SIZE, 5);
+static_assertions::const_assert_eq!(FieldIDLookupReqPayload::MAX_SERIALIZED_SIZE, 61);
+static_assertions::const_assert_eq!(FieldIDLookupResPayload::MAX_SERIALIZED_SIZE, 2);
+static_assertions::const_assert_eq!(ParameterSetLockPayload::MAX_SERIALIZED_SIZE, 2);

From 0b13a38cb14a6bebc5dac6849c71329344f97e5a Mon Sep 17 00:00:00 2001
From: Michael Debertol <michael.debertol@gmail.com>
Date: Wed, 4 Mar 2026 23:52:56 +0100
Subject: [PATCH 04/15] check for MAX_SERIALIZED_SIZE in generated code

---
 .../liquidcan_rust_macros_derive/src/lib.rs                 | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/liquidcan_rust/liquidcan_rust_macros/liquidcan_rust_macros_derive/src/lib.rs b/liquidcan_rust/liquidcan_rust_macros/liquidcan_rust_macros_derive/src/lib.rs
index 6cc008b..27a7c25 100644
--- a/liquidcan_rust/liquidcan_rust_macros/liquidcan_rust_macros_derive/src/lib.rs
+++ b/liquidcan_rust/liquidcan_rust_macros/liquidcan_rust_macros_derive/src/lib.rs
@@ -90,9 +90,11 @@ fn build_serialize(
     });
 
     let expanded = quote! { fn serialize(&self, out: &mut Vec<u8>) {
+        let out_len_before = out.len();
         match self {
             #(#match_arms)*
         }
+        assert!(out.len() - out_len_before <= Self::MAX_SERIALIZED_SIZE, "Serialized data exceeds MAX_SERIALIZED_SIZE");
     }};
 
     return expanded;
@@ -239,8 +241,10 @@ fn build_struct_serialize(type_name: &syn::Ident, fields: &Fields) -> proc_macro
             let field_names: Vec<_> = fields.named.iter().map(|f| &f.ident).collect();
             quote! {
                 fn serialize(&self, out: &mut Vec<u8>) {
+                    let out_len_before = out.len();
                     let #type_name { #( #field_names ),* } = self;
                     #( #field_names.serialize(out); )*
+                    assert!(out.len() - out_len_before <= Self::MAX_SERIALIZED_SIZE, "Serialized data exceeds MAX_SERIALIZED_SIZE");
                 }
             }
         }
@@ -251,8 +255,10 @@ fn build_struct_serialize(type_name: &syn::Ident, fields: &Fields) -> proc_macro
 
             quote! {
                 fn serialize(&self, out: &mut Vec<u8>) {
+                    let out_len_before = out.len();
                     let #type_name( #( #field_idents ),* ) = self;
                     #( #field_idents.serialize(out); )*
+                    assert!(out.len() - out_len_before <= Self::MAX_SERIALIZED_SIZE, "Serialized data exceeds MAX_SERIALIZED_SIZE");
                 }
             }
         }

From 1d1ade1c2ea99fea444556e1a640c7ac91078436 Mon Sep 17 00:00:00 2001
From: Michael Debertol <michael.debertol@gmail.com>
Date: Wed, 4 Mar 2026 23:53:28 +0100
Subject: [PATCH 05/15] add doc comments to ByteCodec trait

---
 .../liquidcan_rust_macros/src/byte_codec.rs        | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/liquidcan_rust/liquidcan_rust_macros/src/byte_codec.rs b/liquidcan_rust/liquidcan_rust_macros/src/byte_codec.rs
index 091c218..0cee2e3 100644
--- a/liquidcan_rust/liquidcan_rust_macros/src/byte_codec.rs
+++ b/liquidcan_rust/liquidcan_rust_macros/src/byte_codec.rs
@@ -2,9 +2,23 @@ pub use liquidcan_rust_macros_derive::ByteCodec;
 use thiserror::Error;
 use zerocopy::{Immutable, IntoBytes, TryFromBytes};
 
+/// A trait for types that can be serialized to and deserialized from bytes.
 pub trait ByteCodec {
+
+    /// The maximum number of bytes required to serialize this type.
     const MAX_SERIALIZED_SIZE: usize;
+
+    /// Serializes `self` into the provided output buffer.
+    /// 
+    /// The caller is responsible for ensuring that the buffer has enough capacity to hold the serialized data.
+    /// Implementations of this method must not write more than `MAX_SERIALIZED_SIZE` bytes to the output buffer.
     fn serialize(&self, out: &mut Vec<u8>);
+
+    /// Deserializes an instance of `Self` from the provided input bytes.
+    /// 
+    /// Returns a tuple containing the deserialized instance and a slice of the remaining input bytes after the deserialized data.
+    /// Thus, implementations must know how many bytes they consume from the input, in case the input contains more data than needed to deserialize an instance of `Self`.
+    /// The caller is responsible for ensuring that the input bytes contain enough data to deserialize an instance of `Self`.
     fn deserialize(input: &[u8]) -> Result<(Self, &[u8]), DeserializationError>
     where
         Self: Sized;

From aae411f94f38aa7fc57749f350db44f858321bad Mon Sep 17 00:00:00 2001
From: Michael Debertol <michael.debertol@gmail.com>
Date: Thu, 5 Mar 2026 01:11:53 +0100
Subject: [PATCH 06/15] update byte_codec comments

---
 .../liquidcan_rust_macros/src/byte_codec.rs   | 24 +++++++++++++++----
 1 file changed, 19 insertions(+), 5 deletions(-)

diff --git a/liquidcan_rust/liquidcan_rust_macros/src/byte_codec.rs b/liquidcan_rust/liquidcan_rust_macros/src/byte_codec.rs
index 0cee2e3..273c9ea 100644
--- a/liquidcan_rust/liquidcan_rust_macros/src/byte_codec.rs
+++ b/liquidcan_rust/liquidcan_rust_macros/src/byte_codec.rs
@@ -3,19 +3,34 @@ use thiserror::Error;
 use zerocopy::{Immutable, IntoBytes, TryFromBytes};
 
 /// A trait for types that can be serialized to and deserialized from bytes.
+///
+/// Serialization is variable-length: types only emit the bytes they actually
+/// need, which may be fewer than [`MAX_SERIALIZED_SIZE`](Self::MAX_SERIALIZED_SIZE).
+///
+/// # Variable-length field placement
+///
+/// Some types (e.g. `CanDataValue`, `PackedCanDataValues`, `NonNullCanBytes`)
+/// consume **all remaining input** during deserialization because they have no
+/// in-band length delimiter. Such types **must be the last field** in any
+/// struct that derives `ByteCodec`; placing them before other fields will
+/// cause deserialization to consume bytes that belong to subsequent fields,
+/// preventing a clean serialize-deserialize round-trip.
+///
+/// Types with an in-band delimiter (e.g. `CanString`, which is
+/// null-terminated) may safely appear at any position.
 pub trait ByteCodec {
-
-    /// The maximum number of bytes required to serialize this type.
+    /// The maximum number of bytes that [`serialize`](Self::serialize) will ever write.
+    /// The actual serialized size may be smaller.
     const MAX_SERIALIZED_SIZE: usize;
 
     /// Serializes `self` into the provided output buffer.
-    /// 
+    ///
     /// The caller is responsible for ensuring that the buffer has enough capacity to hold the serialized data.
     /// Implementations of this method must not write more than `MAX_SERIALIZED_SIZE` bytes to the output buffer.
     fn serialize(&self, out: &mut Vec<u8>);
 
     /// Deserializes an instance of `Self` from the provided input bytes.
-    /// 
+    ///
     /// Returns a tuple containing the deserialized instance and a slice of the remaining input bytes after the deserialized data.
     /// Thus, implementations must know how many bytes they consume from the input, in case the input contains more data than needed to deserialize an instance of `Self`.
     /// The caller is responsible for ensuring that the input bytes contain enough data to deserialize an instance of `Self`.
@@ -45,7 +60,6 @@ where
     }
 }
 
-
 #[non_exhaustive]
 #[derive(Debug, Error, PartialEq, Eq)]
 pub enum DeserializationError {

From 882e1c6f4dd14a8adb0ec7a1b292b1ca5a534385 Mon Sep 17 00:00:00 2001
From: Michael Debertol <michael.debertol@gmail.com>
Date: Thu, 5 Mar 2026 01:12:32 +0100
Subject: [PATCH 07/15] update some can data types to use TryFrom

---
 liquidcan_rust/src/can_data.rs           | 85 +++++++++++++++++-------
 liquidcan_rust/src/message_conversion.rs | 18 ++---
 2 files changed, 71 insertions(+), 32 deletions(-)

diff --git a/liquidcan_rust/src/can_data.rs b/liquidcan_rust/src/can_data.rs
index 2ef2e98..f6a72e4 100644
--- a/liquidcan_rust/src/can_data.rs
+++ b/liquidcan_rust/src/can_data.rs
@@ -107,6 +107,17 @@ impl CanDataValue {
     }
 }
 
+/// # Variable-length serialization
+///
+/// `CanDataValue` serializes to 1–4 bytes depending on the variant.
+/// During deserialization the concrete type is not known, so `deserialize`
+/// consumes **all remaining input** into a [`Raw`](CanDataValue::Raw) variant.
+/// Use [`convert_from_raw`](CanDataValue::convert_from_raw) to reinterpret
+/// the raw bytes once the expected type is known.
+///
+/// **Because deserialization is greedy, `CanDataValue` must be the last field
+/// in any `ByteCodec` struct.** Placing it before other fields will prevent
+/// a clean round-trip.
 impl ByteCodec for CanDataValue {
     const MAX_SERIALIZED_SIZE: usize = 4;
 
@@ -155,38 +166,47 @@ impl ByteCodec for CanDataValue {
     }
 }
 
-/// Custom string type for CAN messages, fixed size of N bytes,
+/// Custom string type for CAN messages, with a maximum buffer of N bytes,
 /// null terminated (i.e. at most N-1 non-null bytes), ascii-only.
+///
+/// # Variable-length serialization
+///
+/// Only the characters up to and including the null terminator are serialized,
+/// so the wire size is `len + 1` rather than `N`.
+/// Because the null byte acts as an unambiguous delimiter, `CanString` may
+/// safely appear at any position in a `ByteCodec` struct (not just the end).
 #[derive(Debug, Clone)]
 pub struct CanString<const N: usize> {
     data: [u8; N],
 }
 
-impl<const N: usize> From<[u8; N]> for CanString<N> {
-    fn from(data: [u8; N]) -> Self {
-        // Ensure the string is null-terminated
-        assert!(
-            data.iter().position(|&b| b == 0).is_some(),
-            "CanString must be null-terminated."
-        );
-        // Ensure all characters are ASCII
-        assert!(
-            data.iter().all(|&b| b.is_ascii()),
-            "CanString must contain only ASCII characters."
-        );
-        CanString { data }
+impl<const N: usize> TryFrom<[u8; N]> for CanString<N> {
+    type Error = String;
+
+    fn try_from(data: [u8; N]) -> Result<Self, Self::Error> {
+        if data.iter().position(|&b| b == 0).is_none() {
+            return Err("CanString must be null-terminated.".to_string());
+        }
+        if !data.iter().all(|&b| b.is_ascii()) {
+            return Err("CanString must contain only ASCII characters.".to_string());
+        }
+        Ok(CanString { data })
     }
 }
 
-impl<const N: usize> From<&str> for CanString<N> {
-    fn from(s: &str) -> Self {
+impl<const N: usize> TryFrom<&str> for CanString<N> {
+    type Error = String;
+
+    fn try_from(s: &str) -> Result<Self, Self::Error> {
         let bytes = s.as_bytes();
-        assert!(bytes.len() < N, "String too long for CanString<{}>", N);
+        if bytes.len() >= N {
+            return Err(format!("String too long for CanString<{}>", N));
+        }
 
         let mut data = [0u8; N];
         data[..bytes.len()].copy_from_slice(bytes);
 
-        data.into()
+        data.try_into()
     }
 }
 
@@ -219,7 +239,10 @@ impl<const N: usize> ByteCodec for CanString<N> {
                 let mut data = [0u8; N];
                 data[..pos].copy_from_slice(&input[..pos]);
 
-                Ok((data.into(), &input[pos + 1..]))
+                let s: CanString<N> = data
+                    .try_into()
+                    .map_err(|e: String| DeserializationError::InvalidData(e))?;
+                Ok((s, &input[pos + 1..]))
             } else {
                 Err(DeserializationError::InvalidData(format!(
                     "CanString exceeds maximum length of {}",
@@ -236,6 +259,14 @@ impl<const N: usize> ByteCodec for CanString<N> {
 
 /// Represents a packed set of CAN data values.
 /// The raw byte form must fit into N bytes.
+///
+/// # Variable-length serialization
+///
+/// Only the bytes that were actually packed are serialized (i.e. the wire
+/// size equals the sum of the sizes of the contained values, not `N`).
+/// Deserialization consumes up to `N` bytes from the remaining input, so
+/// **this type must be the last field** in any `ByteCodec` struct to
+/// round-trip correctly.
 #[derive(Clone, Debug, PartialEq)]
 pub struct PackedCanDataValues<const N: usize> {
     data: Vec<u8>,
@@ -244,13 +275,16 @@ pub struct PackedCanDataValues<const N: usize> {
 impl<const N: usize> PackedCanDataValues<N> {
     /// Unpack the raw byte data into a vector of CanDataValue based on the provided data types.
     /// The caller must ensure that the order and types of the data match what was originally packed.
-    pub fn unpack(&self, data_types: &[CanDataType]) -> Result<Vec<CanDataValue>, DeserializationError> {
+    pub fn unpack(
+        &self,
+        data_types: &[CanDataType],
+    ) -> Result<Vec<CanDataValue>, DeserializationError> {
         let mut values = Vec::new();
         let mut offset = 0;
 
         for &data_type in data_types {
             let size = data_type.get_size();
-            if offset + size > N {
+            if offset + size > self.data.len() {
                 return Err(DeserializationError::InvalidData(format!(
                     "Not enough data to unpack CanDataValue of type {:?}",
                     data_type
@@ -300,9 +334,14 @@ impl<const N: usize> ByteCodec for PackedCanDataValues<N> {
     }
 }
 
-
-
 /// Up to N bytes that do not include a null byte.
+///
+/// # Variable-length serialization
+///
+/// Only the meaningful (non-zero) prefix is serialized.
+/// Deserialization reads until a null byte or end of input (up to `N` bytes),
+/// so **this type must be the last field** in any `ByteCodec` struct to
+/// round-trip correctly.
 #[derive(Debug, Clone)]
 pub struct NonNullCanBytes<const N: usize> {
     data: [u8; N],
diff --git a/liquidcan_rust/src/message_conversion.rs b/liquidcan_rust/src/message_conversion.rs
index 33de4a0..6218e58 100644
--- a/liquidcan_rust/src/message_conversion.rs
+++ b/liquidcan_rust/src/message_conversion.rs
@@ -28,8 +28,8 @@ impl From<CanMessage> for socketcan::CanFdFrame {
 mod tests {
     use crate::can_message::CanMessage;
     use crate::payloads;
-    use socketcan::EmbeddedFrame;
     use crate::payloads::FieldStatus;
+    use socketcan::EmbeddedFrame;
 
     fn test_round_trip(msg: CanMessage) {
         let can_data: socketcan::CanFdFrame = msg.clone().into();
@@ -73,7 +73,7 @@ mod tests {
             par_count: 5,
             firmware_hash: 1234,
             liquid_hash: 5678,
-            device_name: "Test".into(),
+            device_name: "Test".try_into().unwrap(),
         };
         let msg = CanMessage::NodeInfoAnnouncement { payload };
         test_round_trip(msg);
@@ -82,7 +82,7 @@ mod tests {
     #[test]
     fn test_info_status() {
         let payload = payloads::StatusPayload {
-            msg: "Info status message".into(),
+            msg: "Info status message".try_into().unwrap(),
         };
         let msg = CanMessage::InfoStatus { payload };
         test_round_trip(msg);
@@ -91,7 +91,7 @@ mod tests {
     #[test]
     fn test_warning_status() {
         let payload = payloads::StatusPayload {
-            msg: "Warning status message".into(),
+            msg: "Warning status message".try_into().unwrap(),
         };
         let msg = CanMessage::WarningStatus { payload };
         test_round_trip(msg);
@@ -100,7 +100,7 @@ mod tests {
     #[test]
     fn test_error_status() {
         let payload = payloads::StatusPayload {
-            msg: "Error status message".into(),
+            msg: "Error status message".try_into().unwrap(),
         };
         let msg = CanMessage::ErrorStatus { payload };
         test_round_trip(msg);
@@ -111,7 +111,7 @@ mod tests {
         let payload = payloads::FieldRegistrationPayload {
             field_id: 5,
             field_type: payloads::CanDataType::UInt16,
-            field_name: "Telemetry Value Field".into(),
+            field_name: "Telemetry Value Field".try_into().unwrap(),
         };
         let msg = CanMessage::TelemetryValueRegistration { payload };
         test_round_trip(msg);
@@ -122,7 +122,7 @@ mod tests {
         let payload = payloads::FieldRegistrationPayload {
             field_id: 7,
             field_type: payloads::CanDataType::Boolean,
-            field_name: "Parameter Field".into(),
+            field_name: "Parameter Field".try_into().unwrap(),
         };
         let msg = CanMessage::ParameterRegistration { payload };
         test_round_trip(msg);
@@ -230,7 +230,7 @@ mod tests {
     #[test]
     fn test_field_id_lookup_req() {
         let payload = payloads::FieldIDLookupReqPayload {
-            field_name: "Test Field Name".into(),
+            field_name: "Test Field Name".try_into().unwrap(),
         };
         let msg = CanMessage::FieldIDLookupReq { payload };
         test_round_trip(msg);
@@ -240,8 +240,8 @@ mod tests {
     fn test_field_id_lookup_res() {
         let payload = payloads::FieldIDLookupResPayload {
             field_id: 22,
-            field_status: FieldStatus::Ok,
             field_type: payloads::CanDataType::Float32,
+            field_status: FieldStatus::Ok,
         };
         let msg = CanMessage::FieldIDLookupRes { payload };
         test_round_trip(msg);

From 9d12ee4ee65d8b7aaccfd167365d82b36456edc1 Mon Sep 17 00:00:00 2001
From: Michael Debertol <michael.debertol@gmail.com>
Date: Thu, 5 Mar 2026 01:14:07 +0100
Subject: [PATCH 08/15] fix FieldIDLookupResPayload definition to match spec

---
 liquidcan_rust/src/payloads.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/liquidcan_rust/src/payloads.rs b/liquidcan_rust/src/payloads.rs
index 5661884..6dace22 100644
--- a/liquidcan_rust/src/payloads.rs
+++ b/liquidcan_rust/src/payloads.rs
@@ -2,8 +2,9 @@ use liquidcan_rust_macros::byte_codec::ByteCodec;
 use modular_bitfield::Specifier;
 use zerocopy_derive::{Immutable, IntoBytes, TryFromBytes};
 
-pub use crate::can_data::{CanDataType, CanDataValue, CanString, NonNullCanBytes, PackedCanDataValues};
-
+pub use crate::can_data::{
+    CanDataType, CanDataValue, CanString, NonNullCanBytes, PackedCanDataValues,
+};
 
 #[derive(Specifier, Debug, Copy, Clone, PartialEq, Eq, Immutable, TryFromBytes, IntoBytes)]
 #[repr(u8)]
@@ -44,13 +45,13 @@ pub struct FieldRegistrationPayload {
 
 #[derive(Debug, Clone, ByteCodec, PartialEq)]
 pub struct TelemetryGroupDefinitionPayload {
-    pub group_id: u8,        // Unique identifier for this group
+    pub group_id: u8,                   // Unique identifier for this group
     pub field_ids: NonNullCanBytes<62>, // Array of field IDs in this group
 }
 
 #[derive(Debug, Clone, ByteCodec, PartialEq)]
 pub struct TelemetryGroupUpdatePayload {
-    pub group_id: u8,     // Group identifier
+    pub group_id: u8,                    // Group identifier
     pub values: PackedCanDataValues<62>, // Packed values of all telemetry values in the group
 }
 
@@ -61,8 +62,8 @@ pub struct HeartbeatPayload {
 
 #[derive(Debug, Clone, ByteCodec, PartialEq)]
 pub struct ParameterSetReqPayload {
-    pub parameter_id: u8, // Parameter identifier
-    pub value: CanDataValue,  // New value (type depends on parameter)
+    pub parameter_id: u8,    // Parameter identifier
+    pub value: CanDataValue, // New value (type depends on parameter)
 }
 
 // Important: only derives TryFromBytes because enum ParameterSetStatus doesn't cover all possible enum variants for u8
@@ -88,7 +89,7 @@ pub struct FieldGetReqPayload {
 pub struct FieldGetResPayload {
     pub field_id: u8,              // Field identifier
     pub field_status: FieldStatus, // Status of the get operation
-    pub value: CanDataValue,           // Field value
+    pub value: CanDataValue,       // Field value
 }
 
 #[derive(Debug, Clone, ByteCodec, PartialEq)]
@@ -100,8 +101,8 @@ pub struct FieldIDLookupReqPayload {
 #[derive(Debug, Clone, ByteCodec, PartialEq)]
 pub struct FieldIDLookupResPayload {
     pub field_id: u8,              // Field ID
-    pub field_status: FieldStatus, // Status of the lookup operation
     pub field_type: CanDataType,   // Field Datatype
+    pub field_status: FieldStatus, // Status of the lookup operation
 }
 
 // Important: only derives TryFromBytes because bool doesn't derive FromBytes
@@ -119,7 +120,6 @@ pub struct ParameterSetLockConfirmationPayload {
     pub field_status: FieldStatus,           // Status of the parameter
 }
 
-
 static_assertions::const_assert_eq!(NodeInfoResPayload::MAX_SERIALIZED_SIZE, 63);
 static_assertions::const_assert_eq!(StatusPayload::MAX_SERIALIZED_SIZE, 63);
 static_assertions::const_assert_eq!(FieldRegistrationPayload::MAX_SERIALIZED_SIZE, 63);

From 0db163b89b16fad2256e699885d608a5ba258b31 Mon Sep 17 00:00:00 2001
From: Michael Debertol <michael.debertol@gmail.com>
Date: Thu, 5 Mar 2026 01:14:34 +0100
Subject: [PATCH 09/15] update spec for variable length serialization

---
 LiquidCAN.tex                   |  3 ++-
 sections/03_frame_layout.tex    | 14 +++++++++---
 sections/08_message_types.tex   |  2 +-
 sections/09_data_structures.tex | 40 ++++++++++++++++-----------------
 4 files changed, 34 insertions(+), 25 deletions(-)

diff --git a/LiquidCAN.tex b/LiquidCAN.tex
index b48dfba..be39b60 100644
--- a/LiquidCAN.tex
+++ b/LiquidCAN.tex
@@ -90,7 +90,7 @@
 
 \vspace{1cm}
 
-{\large Version 1.3}
+{\large Version 1.4}
 
 \vspace{0.5cm}
 
@@ -116,6 +116,7 @@ \section*{Version History}
 1.1 & 2026-01-25 & Fixed total sizes of structs. & Fabian Weichselbaum \\
 1.2 & 2026-02-09 & Fixed inconsistant field value lengths \& typos & Raffael Rott\\
 1.3 & 2026-02-28 & Added a status field to field access responses& Raffael Rott\\
+1.4 & 2026-03-05 & Variable-length frame serialization; updated payload sizes & Michael Debertol\\
 % Make sure to change the version on the first page
 \bottomrule
 \end{longtable}
diff --git a/sections/03_frame_layout.tex b/sections/03_frame_layout.tex
index 4ed87b7..dbd2bbb 100644
--- a/sections/03_frame_layout.tex
+++ b/sections/03_frame_layout.tex
@@ -1,7 +1,8 @@
 \section{Common Frame Layout}\label{sec:frame-layout}
 \paragraph{}
-The CAN data field consists of 64 bytes.
-The first byte of each message contains the message type. 
+The CAN data field is variable-length, up to a maximum of 64 bytes.
+The first byte of each message contains the message type.
+The remaining bytes carry the payload, whose length depends on the message type.
 This simple format allows the protocol to be extended in the future by adding more message types.
 See Section \ref{sec:message-types} for a detailed description of message types and their numeric values.
 
@@ -11,7 +12,14 @@ \section{Common Frame Layout}\label{sec:frame-layout}
 Field & Bytes & Description \\
 \midrule
 message\_type & 1 & Type of message (see Message Types) \\
-data & 63 & Payload data \\
+data & 0--63 & Payload data (length depends on message type) \\
 \bottomrule
 \end{tabular}
 \end{center}
+
+\textbf{Note:} Each message type defines its own payload size. Message types that
+contain only fixed-size fields have a constant wire size, while those that end
+with a variable-length field (e.g.\ null-terminated strings or packed data
+arrays) may use fewer bytes than the maximum. Should the payload not fit exactly into
+one of the CAN FD data field sizes (1-8, 12, 16, 20, 24, 32, 48, or 64 bytes),
+it should be padded with zeros to the next valid size.
\ No newline at end of file
diff --git a/sections/08_message_types.tex b/sections/08_message_types.tex
index 2e7373d..87fc3ac 100644
--- a/sections/08_message_types.tex
+++ b/sections/08_message_types.tex
@@ -30,7 +30,7 @@ \section{Message Types}\label{sec:message-types}
 50 & \texttt{parameter\_set\_req}\label{msg:parameter-set-req} & ParameterSetReq (\ref{struct:ParameterSetReq}) & Server/Node $\rightarrow$ Node & Request to set a parameter value \\
 51 & \texttt{parameter\_set\_confirmation}\label{msg:parameter-set-confirmation} & ParameterSetConfirmation (\ref{struct:ParameterSetConfirmation}) & Node $\rightarrow$ Server/Node & Response with confirmed parameter value \\
 52 & \texttt{parameter\_set\_lock\_req}\label{msg:parameter-set-lock-req} & ParameterSetLock (\ref{struct:ParameterSetLock}) & Server/Node $\rightarrow$ Node & Request to lock a parameter \\
-53 & \texttt{parameter\_set\_lock\_confirmation}\label{msg:parameter-set-lock-res} & ParameterSetLock (\ref{struct:ParameterSetLock}) & Node $\rightarrow$ Server & Response confirming parameter lock \\
+53 & \texttt{parameter\_set\_lock\_confirmation}\label{msg:parameter-set-lock-res} & ParameterSetLockConfirmation (\ref{struct:ParameterSetLockConfirmation}) & Node $\rightarrow$ Server & Response confirming parameter lock \\
 \midrule
 \multicolumn{5}{l}{\textit{Field Access}} \\
 60 & \texttt{field\_get\_req}\label{msg:field-get-req} & FieldGetReq (\ref{struct:FieldGetReq}) & Server/Node $\rightarrow$ Node & Request field value \\
diff --git a/sections/09_data_structures.tex b/sections/09_data_structures.tex
index c0cc8f3..9334e6a 100644
--- a/sections/09_data_structures.tex
+++ b/sections/09_data_structures.tex
@@ -59,9 +59,9 @@ \subsection{NodeInfoRes}\label{struct:NodeInfoRes}
 par\_cnt & 1 & Number of parameters on this node \\
 firmware\_hash & 4 & Hash of the firmware version \\
 liquid\_hash & 4 & Hash of the LiquidCan protocol version \\
-device\_name & 53 & Human-readable device name \\
+device\_name & $\leq$53 & Human-readable device name (null-terminated) \\
 \midrule
-\textbf{Total} & \textbf{63} & \\
+\textbf{Total} & \textbf{11--63} & \\
 \bottomrule
 \end{tabular}
 \end{center}
@@ -86,7 +86,7 @@ \subsection{Status}\label{struct:Status}
 \toprule
 Field & Bytes & Description \\
 \midrule
-msg & 63 & Status message text \\
+msg & $\leq$63 & Status message text (null-terminated) \\
 \bottomrule
 \end{tabular}
 \end{center}
@@ -110,9 +110,9 @@ \subsection{FieldRegistration}\label{struct:FieldRegistration}
 \midrule
 field\_id & 1 & Unique identifier for this field \\
 field\_type & 1 & Data type (DataType enum) \\
-field\_name & 61 & Human-readable field name \\
+field\_name & $\leq$61 & Human-readable field name (null-terminated) \\
 \midrule
-\textbf{Total} & \textbf{63} & \\
+\textbf{Total} & \textbf{3--63} & \\
 \bottomrule
 \end{tabular}
 \end{center}
@@ -134,9 +134,9 @@ \subsection{TelemetryGroupDefinition}\label{struct:TelemetryGroupDefinition}
 Field & Bytes & Description \\
 \midrule
 group\_id & 1 & Unique identifier for this group \\
-field\_ids & 62 & Array of field IDs in this group \\
+field\_ids & $\leq$62 & Array of field IDs in this group (terminated by end of frame) \\
 \midrule
-\textbf{Total} & \textbf{63} & \\
+\textbf{Total} & \textbf{2--63} & \\
 \bottomrule
 \end{tabular}
 \end{center}
@@ -157,9 +157,9 @@ \subsection{TelemetryGroupUpdate}\label{struct:TelemetryGroupUpdate}
 Field & Bytes & Description \\
 \midrule
 group\_id & 1 & Group identifier \\
-values & 62 & Packed values of all telemetry values in the group \\
+values & $\leq$62 & Packed values of all telemetry values in the group \\
 \midrule
-\textbf{Total} & \textbf{63} & \\
+\textbf{Total} & \textbf{2--63} & \\
 \bottomrule
 \end{tabular}
 \end{center}
@@ -205,9 +205,9 @@ \subsection{ParameterSetReq}\label{struct:ParameterSetReq}
 Field & Bytes & Description \\
 \midrule
 parameter\_id & 1 & Parameter identifier \\
-value & 61 & New value (type depends on parameter) \\
+value & 1--4 & New value (size depends on parameter datatype) \\
 \midrule
-\textbf{Total} & \textbf{62} & \\
+\textbf{Total} & \textbf{2--5} & \\
 \bottomrule
 \end{tabular}
 \end{center}
@@ -215,7 +215,7 @@ \subsection{ParameterSetReq}\label{struct:ParameterSetReq}
 \begin{lstlisting}[caption={ParameterSetReq struct}]
 typedef struct __attribute__((packed)) {
     uint8_t parameter_id;
-    uint8_t value[61];
+    uint8_t value[]; // 1-4 bytes, flexible array member
 } parameter_set_req_t;
 \end{lstlisting}
 
@@ -257,9 +257,9 @@ \subsection{ParameterSetConfirmation}\label{struct:ParameterSetConfirmation}
 \midrule
 parameter\_id & 1 & Parameter identifier \\
 status & 1 & Status code (ParameterSetStatus enum) \\
-value & 61 & Confirmed value after set operation \\
+value & 1--4 & Confirmed value after set operation (size depends on datatype) \\
 \midrule
-\textbf{Total} & \textbf{63} & \\
+\textbf{Total} & \textbf{3--6} & \\
 \bottomrule
 \end{tabular}
 \end{center}
@@ -271,7 +271,7 @@ \subsection{ParameterSetConfirmation}\label{struct:ParameterSetConfirmation}
 typedef struct __attribute__((packed)) {
     uint8_t parameter_id;
     uint8_t status;
-    uint8_t value[61];
+    uint8_t value[]; // 1-4 bytes, flexible array member
 } parameter_set_confirmation_t;
 \end{lstlisting}
 
@@ -305,9 +305,9 @@ \subsection{FieldGetRes}\label{struct:FieldGetRes}
 \midrule
 field\_id & 1 & Field identifier \\
 field\_status & 1 & Field existence status (FieldStatus enum) \\
-value & 61 & Field value \\
+value & 1--4 & Field value (size depends on field datatype) \\
 \midrule
-\textbf{Total} & \textbf{63} & \\
+\textbf{Total} & \textbf{3--6} & \\
 \bottomrule
 \end{tabular}
 \end{center}
@@ -320,7 +320,7 @@ \subsection{FieldGetRes}\label{struct:FieldGetRes}
 typedef struct __attribute__((packed)) {
     uint8_t field_id;
     uint8_t field_status;
-    uint8_t value[61];
+    uint8_t value[]; // 1-4 bytes, flexible array member
 } field_get_res_t;
 \end{lstlisting}
 
@@ -333,9 +333,9 @@ \subsection{FieldIDLookupReq}\label{struct:FieldIDLookupReq}
 \toprule
 Field & Bytes & Description \\
 \midrule
-field\_name & 61 & Field Name \\
+field\_name & $\leq$61 & Field Name (null-terminated) \\
 \midrule
-\textbf{Total} & \textbf{61} & \\
+\textbf{Total} & \textbf{2--61} & \\
 \bottomrule
 \end{tabular}
 \end{center}

From 71e27a918c75f2d9be8acc9a33c9054106ae50d6 Mon Sep 17 00:00:00 2001
From: Michael Debertol <michael.debertol@gmail.com>
Date: Thu, 5 Mar 2026 01:17:55 +0100
Subject: [PATCH 10/15] add missing size assertions

---
 liquidcan_rust/src/payloads.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/liquidcan_rust/src/payloads.rs b/liquidcan_rust/src/payloads.rs
index 6dace22..42da856 100644
--- a/liquidcan_rust/src/payloads.rs
+++ b/liquidcan_rust/src/payloads.rs
@@ -133,3 +133,7 @@ static_assertions::const_assert_eq!(FieldGetResPayload::MAX_SERIALIZED_SIZE, 6);
 static_assertions::const_assert_eq!(FieldIDLookupReqPayload::MAX_SERIALIZED_SIZE, 61);
 static_assertions::const_assert_eq!(FieldIDLookupResPayload::MAX_SERIALIZED_SIZE, 3);
 static_assertions::const_assert_eq!(ParameterSetLockPayload::MAX_SERIALIZED_SIZE, 2);
+static_assertions::const_assert_eq!(FieldStatus::MAX_SERIALIZED_SIZE, 1);
+static_assertions::const_assert_eq!(CanDataType::MAX_SERIALIZED_SIZE, 1);
+static_assertions::const_assert_eq!(ParameterSetStatus::MAX_SERIALIZED_SIZE, 1);
+static_assertions::const_assert_eq!(ParameterLockStatus::MAX_SERIALIZED_SIZE, 1);

From 5721b528903f10eea76111745a803ab28313927f Mon Sep 17 00:00:00 2001
From: Michael Debertol <michael.debertol@gmail.com>
Date: Thu, 5 Mar 2026 01:19:10 +0100
Subject: [PATCH 11/15] silence clippy

---
 liquidcan_rust/src/can_data.rs | 6 +++---
 liquidcan_rust/src/lib.rs      | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/liquidcan_rust/src/can_data.rs b/liquidcan_rust/src/can_data.rs
index f6a72e4..a1ba0ef 100644
--- a/liquidcan_rust/src/can_data.rs
+++ b/liquidcan_rust/src/can_data.rs
@@ -149,7 +149,7 @@ impl ByteCodec for CanDataValue {
                 out.push(*v as u8);
             }
             CanDataValue::Raw(data) => {
-                out.extend_from_slice(&data);
+                out.extend_from_slice(data);
             }
         }
     }
@@ -184,7 +184,7 @@ impl<const N: usize> TryFrom<[u8; N]> for CanString<N> {
     type Error = String;
 
     fn try_from(data: [u8; N]) -> Result<Self, Self::Error> {
-        if data.iter().position(|&b| b == 0).is_none() {
+        if !data.contains(&0) {
             return Err("CanString must be null-terminated.".to_string());
         }
         if !data.iter().all(|&b| b.is_ascii()) {
@@ -358,7 +358,7 @@ impl<const N: usize> TryFrom<&[u8]> for NonNullCanBytes<N> {
                 N
             ));
         }
-        if value.iter().any(|&b| b == 0) {
+        if value.contains(&0) {
             return Err("Input data contains null byte".to_string());
         }
         let mut data = [0u8; N];
diff --git a/liquidcan_rust/src/lib.rs b/liquidcan_rust/src/lib.rs
index f103c94..026e243 100644
--- a/liquidcan_rust/src/lib.rs
+++ b/liquidcan_rust/src/lib.rs
@@ -1,8 +1,8 @@
+mod can_data;
 pub mod can_message;
 pub mod message_conversion;
 pub mod payloads;
 pub mod raw_can_message;
-mod can_data;
 
 pub use can_message::CanMessage;
 pub use raw_can_message::CanMessageId;

From 9dbce1ca60f615c9550be727c7a6d7c70e43b5e5 Mon Sep 17 00:00:00 2001
From: Michael Debertol <michael.debertol@gmail.com>
Date: Thu, 5 Mar 2026 01:25:40 +0100
Subject: [PATCH 12/15] allow converting raw CanDataValue even if it is longer

---
 liquidcan_rust/src/can_data.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/liquidcan_rust/src/can_data.rs b/liquidcan_rust/src/can_data.rs
index a1ba0ef..d11a2bb 100644
--- a/liquidcan_rust/src/can_data.rs
+++ b/liquidcan_rust/src/can_data.rs
@@ -49,7 +49,7 @@ impl CanDataValue {
         data: &[u8],
         data_type: CanDataType,
     ) -> Result<Self, DeserializationError> {
-        if data.len() != data_type.get_size() {
+        if data.len() < data_type.get_size() {
             return Err(DeserializationError::InvalidData(format!(
                 "Data length {} does not match expected length {} for type {:?}",
                 data.len(),
@@ -58,6 +58,8 @@ impl CanDataValue {
             )));
         }
 
+        let data = &data[..data_type.get_size()];
+
         match data_type {
             CanDataType::Float32 => {
                 let mut arr = [0u8; 4];

From b4e835d80a854fb67ca0048faf14604a49f0edaa Mon Sep 17 00:00:00 2001
From: Michael Debertol <michael.debertol@gmail.com>
Date: Thu, 5 Mar 2026 01:35:25 +0100
Subject: [PATCH 13/15] make ci happy

---
 .../tests/test_byte_codec.rs                  | 227 +++++++++---------
 liquidcan_rust/src/message_conversion.rs      |   2 +-
 2 files changed, 115 insertions(+), 114 deletions(-)

diff --git a/liquidcan_rust/liquidcan_rust_macros/tests/test_byte_codec.rs b/liquidcan_rust/liquidcan_rust_macros/tests/test_byte_codec.rs
index 3dc87a2..3312509 100644
--- a/liquidcan_rust/liquidcan_rust_macros/tests/test_byte_codec.rs
+++ b/liquidcan_rust/liquidcan_rust_macros/tests/test_byte_codec.rs
@@ -4,30 +4,30 @@ use zerocopy::{Immutable, IntoBytes, TryFromBytes};
 #[repr(C)]
 #[derive(TryFromBytes, IntoBytes, Immutable, Clone, Copy, Debug, PartialEq, Eq)]
 struct CanFramePayload {
-	arbitration_id: u16,
-	data: u16,
+    arbitration_id: u16,
+    data: u16,
 }
 
 #[repr(u8)]
 #[derive(ByteCodec, Debug, PartialEq, Eq)]
 enum CanMessage {
-	Heartbeat = 0x01,
-	Frame(CanFramePayload) = 0x02,
-	Command { cmd: u16, value: u16 } = 0x03,
-	Empty = 0x04,
+    Heartbeat = 0x01,
+    Frame(CanFramePayload) = 0x02,
+    Command { cmd: u16, value: u16 } = 0x03,
+    Empty = 0x04,
 }
 
 #[repr(u8)]
 #[derive(TryFromBytes, IntoBytes, Immutable, Clone, Copy, Debug, PartialEq, Eq)]
 enum CheckedByte {
-	A = 0x11,
-	B = 0x22,
+    A = 0x11,
+    B = 0x22,
 }
 
 #[derive(ByteCodec, Debug, PartialEq, Eq)]
 struct NamedPacket {
-	port: u16,
-	payload: CanFramePayload,
+    port: u16,
+    payload: CanFramePayload,
 }
 
 #[derive(ByteCodec, Debug, PartialEq, Eq)]
@@ -38,163 +38,164 @@ struct Marker;
 
 #[test]
 fn serializes_to_variable_lengths() {
-	let mut heartbeat = Vec::new();
-	CanMessage::Heartbeat.serialize(&mut heartbeat);
+    let mut heartbeat = Vec::new();
+    CanMessage::Heartbeat.serialize(&mut heartbeat);
 
-	let mut frame = Vec::new();
-	CanMessage::Frame(CanFramePayload {
-		arbitration_id: 0x1234,
-		data: 0xABCD,
-	})
-	.serialize(&mut frame);
+    let mut frame = Vec::new();
+    CanMessage::Frame(CanFramePayload {
+        arbitration_id: 0x1234,
+        data: 0xABCD,
+    })
+    .serialize(&mut frame);
 
-	let mut command = Vec::new();
-	CanMessage::Command {
-		cmd: 0x0102,
-		value: 0x0304,
-	}
-	.serialize(&mut command);
+    let mut command = Vec::new();
+    CanMessage::Command {
+        cmd: 0x0102,
+        value: 0x0304,
+    }
+    .serialize(&mut command);
 
-	assert_eq!(heartbeat.len(), 1);
-	assert_eq!(frame.len(), 1 + core::mem::size_of::<CanFramePayload>());
-	assert_eq!(command.len(), 1 + core::mem::size_of::<u16>() * 2);
+    assert_eq!(heartbeat.len(), 1);
+    assert_eq!(frame.len(), 1 + core::mem::size_of::<CanFramePayload>());
+    assert_eq!(command.len(), 1 + core::mem::size_of::<u16>() * 2);
 }
 
 #[test]
 fn roundtrips_all_variant_shapes() {
-	let original = [
-		CanMessage::Heartbeat,
-		CanMessage::Frame(CanFramePayload {
-			arbitration_id: 0x0001,
-			data: 0xCAFE,
-		}),
-		CanMessage::Command {
-			cmd: 0xBEEF,
-			value: 0x2222,
-		},
-		CanMessage::Empty,
-	];
-
-	for value in original {
-		let mut bytes = Vec::new();
-		value.serialize(&mut bytes);
-
-		let (decoded, rest) = CanMessage::deserialize(&bytes).expect("deserialize should succeed");
-		assert_eq!(decoded, value);
-		assert!(rest.is_empty());
-	}
+    let original = [
+        CanMessage::Heartbeat,
+        CanMessage::Frame(CanFramePayload {
+            arbitration_id: 0x0001,
+            data: 0xCAFE,
+        }),
+        CanMessage::Command {
+            cmd: 0xBEEF,
+            value: 0x2222,
+        },
+        CanMessage::Empty,
+    ];
+
+    for value in original {
+        let mut bytes = Vec::new();
+        value.serialize(&mut bytes);
+
+        let (decoded, rest) = CanMessage::deserialize(&bytes).expect("deserialize should succeed");
+        assert_eq!(decoded, value);
+        assert!(rest.is_empty());
+    }
 }
 
 #[test]
 fn fails_for_invalid_discriminant() {
-	let err = CanMessage::deserialize(&[0xFF]).expect_err("expected invalid discriminant");
-	assert!(matches!(
-		err,
-		DeserializationError::InvalidDiscriminant(0xFF)
-	));
+    let err = CanMessage::deserialize(&[0xFF]).expect_err("expected invalid discriminant");
+    assert!(matches!(
+        err,
+        DeserializationError::InvalidDiscriminant(0xFF)
+    ));
 }
 
 #[test]
 fn fails_on_empty_input() {
-	let err = CanMessage::deserialize(&[]).expect_err("expected not enough data");
-	assert!(matches!(err, DeserializationError::NotEnoughData));
+    let err = CanMessage::deserialize(&[]).expect_err("expected not enough data");
+    assert!(matches!(err, DeserializationError::NotEnoughData));
 }
 
 #[test]
 fn fails_when_variant_payload_is_truncated() {
-	let err = CanMessage::deserialize(&[0x03, 0xAA]).expect_err("expected not enough data");
-	assert!(matches!(err, DeserializationError::NotEnoughData));
+    let err = CanMessage::deserialize(&[0x03, 0xAA]).expect_err("expected not enough data");
+    assert!(matches!(err, DeserializationError::NotEnoughData));
 }
 
 #[test]
 fn zerocopy_base_case_roundtrip() {
-	let payload = CanFramePayload {
-		arbitration_id: 0x1357,
-		data: 0x2468,
-	};
+    let payload = CanFramePayload {
+        arbitration_id: 0x1357,
+        data: 0x2468,
+    };
 
-	let mut bytes = Vec::new();
-	payload.serialize(&mut bytes);
-	assert_eq!(bytes.len(), core::mem::size_of::<CanFramePayload>());
+    let mut bytes = Vec::new();
+    payload.serialize(&mut bytes);
+    assert_eq!(bytes.len(), core::mem::size_of::<CanFramePayload>());
 
-	let (decoded, rest) = CanFramePayload::deserialize(&bytes).expect("deserialize should succeed");
-	assert_eq!(decoded, payload);
-	assert!(rest.is_empty());
+    let (decoded, rest) = CanFramePayload::deserialize(&bytes).expect("deserialize should succeed");
+    assert_eq!(decoded, payload);
+    assert!(rest.is_empty());
 }
 
 #[test]
 fn zerocopy_base_case_reports_invalid_data() {
-	let err = CheckedByte::deserialize(&[0xFF]).expect_err("expected invalid data");
-	assert!(matches!(err, DeserializationError::InvalidData(_)));
+    let err = CheckedByte::deserialize(&[0xFF]).expect_err("expected invalid data");
+    assert!(matches!(err, DeserializationError::InvalidData(_)));
 }
 
 #[test]
 fn zerocopy_checked_enum_roundtrip() {
-	let mut bytes = Vec::new();
-	CheckedByte::A.serialize(&mut bytes);
+    let mut bytes = Vec::new();
+    CheckedByte::A.serialize(&mut bytes);
 
-	let (decoded, rest) = CheckedByte::deserialize(&bytes).expect("deserialize should succeed");
-	assert_eq!(decoded, CheckedByte::A);
-	assert!(rest.is_empty());
+    let (decoded, rest) = CheckedByte::deserialize(&bytes).expect("deserialize should succeed");
+    assert_eq!(decoded, CheckedByte::A);
+    assert!(rest.is_empty());
 
-	let mut bytes_b = Vec::new();
-	CheckedByte::B.serialize(&mut bytes_b);
-	let (decoded_b, rest_b) = CheckedByte::deserialize(&bytes_b).expect("deserialize should succeed");
-	assert_eq!(decoded_b, CheckedByte::B);
-	assert!(rest_b.is_empty());
+    let mut bytes_b = Vec::new();
+    CheckedByte::B.serialize(&mut bytes_b);
+    let (decoded_b, rest_b) =
+        CheckedByte::deserialize(&bytes_b).expect("deserialize should succeed");
+    assert_eq!(decoded_b, CheckedByte::B);
+    assert!(rest_b.is_empty());
 }
 
 #[test]
 fn struct_named_roundtrip() {
-	let packet = NamedPacket {
-		port: 0x55AA,
-		payload: CanFramePayload {
-			arbitration_id: 0x1234,
-			data: 0x5678,
-		},
-	};
+    let packet = NamedPacket {
+        port: 0x55AA,
+        payload: CanFramePayload {
+            arbitration_id: 0x1234,
+            data: 0x5678,
+        },
+    };
 
-	let mut bytes = Vec::new();
-	packet.serialize(&mut bytes);
+    let mut bytes = Vec::new();
+    packet.serialize(&mut bytes);
 
-	let (decoded, rest) = NamedPacket::deserialize(&bytes).expect("deserialize should succeed");
-	assert_eq!(decoded, packet);
-	assert!(rest.is_empty());
+    let (decoded, rest) = NamedPacket::deserialize(&bytes).expect("deserialize should succeed");
+    assert_eq!(decoded, packet);
+    assert!(rest.is_empty());
 }
 
 #[test]
 fn struct_tuple_roundtrip() {
-	let packet = TuplePacket(
-		0x0A0B,
-		CanFramePayload {
-			arbitration_id: 0x0C0D,
-			data: 0x0E0F,
-		},
-	);
+    let packet = TuplePacket(
+        0x0A0B,
+        CanFramePayload {
+            arbitration_id: 0x0C0D,
+            data: 0x0E0F,
+        },
+    );
 
-	let mut bytes = Vec::new();
-	packet.serialize(&mut bytes);
+    let mut bytes = Vec::new();
+    packet.serialize(&mut bytes);
 
-	let (decoded, rest) = TuplePacket::deserialize(&bytes).expect("deserialize should succeed");
-	assert_eq!(decoded, packet);
-	assert!(rest.is_empty());
+    let (decoded, rest) = TuplePacket::deserialize(&bytes).expect("deserialize should succeed");
+    assert_eq!(decoded, packet);
+    assert!(rest.is_empty());
 }
 
 #[test]
 fn struct_unit_roundtrip_preserves_remaining_bytes() {
-	let marker = Marker;
-	let mut bytes = Vec::new();
-	marker.serialize(&mut bytes);
-	assert!(bytes.is_empty());
+    let marker = Marker;
+    let mut bytes = Vec::new();
+    marker.serialize(&mut bytes);
+    assert!(bytes.is_empty());
 
-	let input = [0xAA, 0xBB];
-	let (decoded, rest) = Marker::deserialize(&input).expect("deserialize should succeed");
-	assert_eq!(decoded, Marker);
-	assert_eq!(rest, &input);
+    let input = [0xAA, 0xBB];
+    let (decoded, rest) = Marker::deserialize(&input).expect("deserialize should succeed");
+    assert_eq!(decoded, Marker);
+    assert_eq!(rest, &input);
 }
 
 #[test]
 fn struct_deserialize_truncated_field_fails() {
-	let err = NamedPacket::deserialize(&[0x01]).expect_err("expected not enough data");
-	assert!(matches!(err, DeserializationError::NotEnoughData));
+    let err = NamedPacket::deserialize(&[0x01]).expect_err("expected not enough data");
+    assert!(matches!(err, DeserializationError::NotEnoughData));
 }
diff --git a/liquidcan_rust/src/message_conversion.rs b/liquidcan_rust/src/message_conversion.rs
index 6218e58..5b0d4f7 100644
--- a/liquidcan_rust/src/message_conversion.rs
+++ b/liquidcan_rust/src/message_conversion.rs
@@ -142,7 +142,7 @@ mod tests {
     fn test_telemetry_group_update() {
         let data_values = [
             payloads::CanDataValue::Int32(42),
-            payloads::CanDataValue::Float32(3.14),
+            payloads::CanDataValue::Float32(12.34),
             payloads::CanDataValue::Boolean(true),
         ];
         let payload = payloads::TelemetryGroupUpdatePayload {

From 8147cb4dad36a06761bcef3198a6aefd03d9e9d3 Mon Sep 17 00:00:00 2001
From: Michael Debertol <michael.debertol@gmail.com>
Date: Thu, 5 Mar 2026 01:37:52 +0100
Subject: [PATCH 14/15] remove local path in LiquidCAN.tex

---
 LiquidCAN.tex | 1 -
 1 file changed, 1 deletion(-)

diff --git a/LiquidCAN.tex b/LiquidCAN.tex
index be39b60..5cdfc83 100644
--- a/LiquidCAN.tex
+++ b/LiquidCAN.tex
@@ -1,4 +1,3 @@
-% /home/raffael/Documents/Nextcloud/Hobbies/SpaceTeam/LiquidCan/documentation.tex
 \documentclass[11pt,a4paper]{article}
 \usepackage[margin=20mm,a4paper]{geometry}
 \usepackage{lmodern}

From d057b09b930003c03d17fb6b50ff4a4e9584a150 Mon Sep 17 00:00:00 2001
From: Michael Debertol <michael.debertol@gmail.com>
Date: Thu, 5 Mar 2026 01:37:57 +0100
Subject: [PATCH 15/15] re-generate pdf

---
 LiquidCAN.pdf | Bin 299383 -> 308897 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/LiquidCAN.pdf b/LiquidCAN.pdf
index f2735900062d12d92232000c16dfbda5b9dc4ddc..a93e5747ca28fb1310cd6a23de0c1196081e58a2 100644
GIT binary patch
delta 134402
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

delta 125322
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