diff --git a/packed_struct/src/packing.rs b/packed_struct/src/packing.rs
index f38ffa6..be0b902 100644
--- a/packed_struct/src/packing.rs
+++ b/packed_struct/src/packing.rs
@@ -19,6 +19,30 @@ pub trait PackedStruct where Self: Sized {
     fn unpack(src: &Self::ByteArray) -> PackingResult<Self>;
 }
 
+pub trait PackedStructHeader where Self: PackedStruct + Sized {
+    /// The appropriately sized byte array into which this structure will be packed, for example [u8; 2]. 
+    type HeaderByteArray : ByteArray;
+    
+    /// Returns the header data to attach it to the front of the packed data
+    fn get_header(&self, data: &[u8]) -> PackingResult<Self::HeaderByteArray>;
+    /// Validates the structure/footer from a byte array when unpacking.
+    fn validate_header(_src: &[u8]) -> PackingResult<()> {
+        Ok(())
+    }
+}
+
+pub trait PackedStructFooter where Self: PackedStruct + Sized {
+    /// The appropriately sized byte array into which this structure will be packed, for example [u8; 2]. 
+    type FooterByteArray : ByteArray;
+    
+    /// Returns the footer data to attach it to the end of the packed data
+    fn get_footer(&self, data: &[u8]) -> PackingResult<Self::FooterByteArray>;
+    /// Validates the structure/footer from a byte array when unpacking.
+    fn validate_footer(_src: &[u8]) -> PackingResult<()> {
+        Ok(())
+    }
+}
+
 /// Infos about a particular type that can be packaged.
 pub trait PackedStructInfo {
     /// Number of bits that this structure occupies when being packed.
@@ -44,7 +68,7 @@ pub trait PackedStructSlice where Self: Sized {
 }
 
 #[cfg_attr(feature = "use_serde", derive(Serialize, Deserialize))]
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 /// Packing errors that might occur during packing or unpacking
 pub enum PackingError {
     InvalidValue,
@@ -56,7 +80,9 @@ pub enum PackingError {
     BufferSizeMismatch { expected: usize, actual: usize },
     BufferModMismatch { actual_size: usize, modulo_required: usize },
     SliceIndexingError { slice_len: usize },
-    InternalError
+    InternalError,
+    #[cfg(feature = "std")]
+    UserError(String)
 }
 
 impl crate::Display for PackingError {
@@ -68,7 +94,7 @@ impl crate::Display for PackingError {
 #[cfg(feature="std")]
 impl ::std::error::Error for PackingError {
     fn description(&self) -> &str {
-        match *self {
+        match self {
             PackingError::InvalidValue => "Invalid value",
             PackingError::BitsError => "Bits error",
             PackingError::BufferTooSmall => "Buffer too small",            
@@ -78,7 +104,9 @@ impl ::std::error::Error for PackingError {
             PackingError::BufferModMismatch { .. } => "The structure's size is not a multiple of the item's size",
             PackingError::SliceIndexingError { .. } => "Failed to index into a slice",
             PackingError::MoreThanOneDynamicType => "Only one dynamically sized type is supported in the tuple",
-            PackingError::InternalError => "Internal error"
+            PackingError::InternalError => "Internal error",
+            #[cfg(feature = "std")]
+            PackingError::UserError(err) => err
         }
     }
 }
diff --git a/packed_struct_codegen/src/pack.rs b/packed_struct_codegen/src/pack.rs
index 2129b56..71aff07 100644
--- a/packed_struct_codegen/src/pack.rs
+++ b/packed_struct_codegen/src/pack.rs
@@ -49,7 +49,9 @@ pub struct PackStruct<'a> {
     pub num_bytes: usize,
     pub num_bits: usize,
     pub data_struct: &'a syn::DataStruct,
-    pub derive_input: &'a syn::DeriveInput
+    pub derive_input: &'a syn::DeriveInput,
+    pub header: Option<Header>,
+    pub footer: Option<Footer>,
 }
 
 
diff --git a/packed_struct_codegen/src/pack_codegen.rs b/packed_struct_codegen/src/pack_codegen.rs
index 2762e67..7645c53 100644
--- a/packed_struct_codegen/src/pack_codegen.rs
+++ b/packed_struct_codegen/src/pack_codegen.rs
@@ -4,6 +4,8 @@ extern crate syn;
 use crate::pack::*;
 use crate::pack_codegen_docs::*;
 use crate::common::*;
+use crate::pack_parse::Footer;
+use crate::pack_parse::Header;
 use syn::spanned::Spanned;
 use crate::utils::*;
 
@@ -17,15 +19,92 @@ pub fn derive_pack(parsed: &PackStruct) -> syn::Result<proc_macro2::TokenStream>
     let type_documentation = type_docs(parsed);
     let num_bytes = parsed.num_bytes;
     let num_bits = parsed.num_bits;
-    
 
+    
     let mut pack_fields = vec![];
     let mut unpack_fields = vec![];
     let mut unpack_struct_set = vec![];
+    
+    let header = &parsed.header;
+    let mut header_offset = 0;
+    let mut header_trait_token_get_data = quote!{};
+    let mut header_trait_token_validate = quote!{};
+
+    if let Some(pre) = header {
+        match pre {
+            Header::Trait(size) => {
+                header_offset = *size;
+                header_trait_token_get_data = quote! {
+                    {
+                        let bytes = Self::get_header(&self, &target)?;
+                        assert!(#num_bytes >= bytes.len(), "Packed bytes array is smaller than header array even though we added the header length!"); 
+                        assert!(#size == bytes.len(), "Header size set with attribute is not equal to header array size returned by PackedStructHeader trait!"); 
+                        target[0..bytes.len()].copy_from_slice(&bytes);
+                    }
+                };
+                header_trait_token_validate = quote! {
+                    {
+                        Self::validate_header(src)?;
+                    }
+                };
+            },
+            Header::Bytes(bytes) => {
+                header_offset = bytes.len();
+                pack_fields.push(quote! {
+                    {
+                        let byt = vec![#(#bytes),*];
+                        assert!(#num_bytes >= byt.len(), "Packed bytes array is smaller than header array even though we added the header length!"); 
+                        target[0..byt.len()].copy_from_slice(&byt);
+                    }
+                });
+                // We don't need to generate something for unpack here, since we pass an offset to pack_bits unpack ignores any header or footer data
+            },
+        }
+    }
+
+    let footer = &parsed.footer;
+    let mut footer_trait_token_get_data = quote!{};
+    let mut footer_trait_token_validate = quote!{};
+
+    if let Some(app) = footer {
+        match app {
+            Footer::Trait(size) => {
+                let footer_offset = num_bytes - *size;
+                footer_trait_token_get_data = quote! {
+                    {
+                        let bytes = Self::get_footer(&self, &target)?;
+                        assert!(#num_bytes >= bytes.len(), "Packed bytes array is smaller than footer array even though we added the footer length!"); 
+                        assert!(#size == bytes.len(), "Footer size set with attribute is not equal to footer array size returned by PackedStructFooter trait!"); 
+                        target[#footer_offset..].copy_from_slice(&bytes);
+                    }
+                };
+                footer_trait_token_validate = quote! {
+                    {
+                        Self::validate_footer(src)?;
+                    }
+                };
+            },
+            Footer::Bytes(bytes) => {
+                let footer_offset = num_bytes - bytes.len();
+                pack_fields.push(quote! {
+                    {
+                        let byt = vec![#(#bytes),*];
+                        assert!(#num_bytes >= byt.len(), "Packed bytes array is smaller than footer array even though we added the footer length!"); 
+                        target[#footer_offset..].copy_from_slice(&byt);
+                    }
+                });
+                // We don't need to generate something for unpack here, since we pass an offset to pack_bits unpack ignores any header or footer data
+            },
+        }
+    }
 
     {
+        // We want the validation for header and footer to happen before we unpack the rest of the fields, since there might be broken data if a validation fails
+        unpack_fields.push(header_trait_token_validate);
+        unpack_fields.push(footer_trait_token_validate);
+
         let mut reg  = |src: &dyn quote::ToTokens, target: &dyn quote::ToTokens, field: &FieldRegular| -> syn::Result<()> {
-            let bits = pack_bits(field);
+            let bits = pack_bits(field, header_offset);
 
             let pack = pack_field(src, field);
             let unpack = unpack_field(field)?;
@@ -79,6 +158,9 @@ pub fn derive_pack(parsed: &PackStruct) -> syn::Result<proc_macro2::TokenStream>
             }        
         }
 
+        pack_fields.push(header_trait_token_get_data);
+        pack_fields.push(footer_trait_token_get_data);
+
     }
 
     let result_ty = result_type();
@@ -111,7 +193,7 @@ pub fn derive_pack(parsed: &PackStruct) -> syn::Result<proc_macro2::TokenStream>
             #[allow(unused_imports, unused_parens)]
             fn pack(&self) -> ::packed_struct::PackingResult<Self::ByteArray> {
                 use ::packed_struct::*;
-
+                
                 let mut target = [0 as u8; #num_bytes];
 
                 #(#pack_fields)*
@@ -152,13 +234,13 @@ struct PackBitsCopy {
     unpack: proc_macro2::TokenStream
 }
 
-fn pack_bits(field: &FieldRegular) -> PackBitsCopy {
+fn pack_bits(field: &FieldRegular, header_offset: usize) -> PackBitsCopy {
     // memcpy
     if (field.bit_range_rust.start % 8) == 0 && (field.bit_range_rust.end % 8) == 0 &&
        (field.bit_range_rust.len() % 8) == 0 && field.bit_range_rust.len() >= 8 
     {
-        let start = field.bit_range_rust.start / 8;
-        let end = field.bit_range_rust.end / 8;
+        let start = field.bit_range_rust.start / 8 + header_offset;
+        let end = field.bit_range_rust.end / 8 + header_offset;
         
         PackBitsCopy {
             pack: quote! {
@@ -172,8 +254,8 @@ fn pack_bits(field: &FieldRegular) -> PackBitsCopy {
         }
     } else {
         let packed_field_len = (field.bit_width as f32 / 8.0).ceil() as usize; 
-        let start_byte = (field.bit_range_rust.start as f32 / 8.0).floor() as usize;
-        let shift = ((packed_field_len as isize*8) - (field.bit_width as isize)) - (field.bit_range_rust.start as isize - (start_byte as isize * 8));
+        let start_byte = (field.bit_range_rust.start as f32 / 8.0).floor() as usize + header_offset;
+        let shift = ((packed_field_len as isize*8) - (field.bit_width as isize)) - (field.bit_range_rust.start as isize - ((start_byte - header_offset) as isize * 8));
 
         let emit_shift = |s: isize| {
             match s {
diff --git a/packed_struct_codegen/src/pack_parse.rs b/packed_struct_codegen/src/pack_parse.rs
index ff27bfe..d44f4aa 100644
--- a/packed_struct_codegen/src/pack_parse.rs
+++ b/packed_struct_codegen/src/pack_parse.rs
@@ -14,8 +14,8 @@ use std::ops::Range;
 
 use crate::utils_syn::{get_expr_int_val, get_single_segment, tokens_to_string};
 
-pub fn parse_sub_attributes(attributes: &[syn::Attribute], main_attribute: &str, wrong_attribute: &str) -> syn::Result<Vec<(String, String)>> {
-    let mut r = vec![];
+pub fn parse_sub_attributes(attributes: &[syn::Attribute], main_attribute: &str, wrong_attribute: &str) -> syn::Result<Vec<(String, syn::Expr)>> {
+    let mut r: Vec<(String, syn::Expr)> = vec![];
 
     for attr in attributes {
         if attr.path().is_ident(wrong_attribute) {
@@ -31,13 +31,11 @@ pub fn parse_sub_attributes(attributes: &[syn::Attribute], main_attribute: &str,
             };
             for meta in nested {
                 match meta {            
-                    syn::Meta::Path(_) => (),
+                    syn::Meta::Path(_) => {},
                     syn::Meta::List(_) => (),
                     syn::Meta::NameValue(nv) => {
-                        if let (Some(key), syn::Expr::Lit(lit)) = (nv.path.get_ident(), &nv.value) {
-                            if let syn::Lit::Str(lit) = &lit.lit {
-                                r.push((key.to_string(), lit.value()));
-                            }
+                        if let (Some(key), lit) = (nv.path.get_ident(), &nv.value) {
+                            r.push((key.to_string(), lit.clone()));
                         }
                     }
                 }
@@ -48,6 +46,26 @@ pub fn parse_sub_attributes(attributes: &[syn::Attribute], main_attribute: &str,
     Ok(r)
 }
 
+pub fn parse_sub_attributes_as_string(attributes: &[syn::Attribute], main_attribute: &str, wrong_attribute: &str) -> syn::Result<Vec<(String, String)>> {
+    parse_sub_attributes(attributes, main_attribute, wrong_attribute).map(|vec| {
+        vec.into_iter().map(|(key, expr)| {
+            (key, get_string_from_expr(&expr).unwrap_or_default())
+        }).collect()
+    })
+}
+
+pub fn get_string_from_expr(expr: &syn::Expr) -> Option<String> {
+    if let syn::Expr::Lit(lit) = expr {
+        if let syn::Lit::Str(lit) = &lit.lit {
+            Some(lit.value())
+        } else {
+            None
+        }
+    } else {
+        None
+    }
+}
+
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 /// https://en.wikipedia.org/wiki/Bit_numbering
@@ -87,6 +105,97 @@ impl IntegerEndianness {
 }
 
 
+fn get_bytes_from_expr_lit(bytes: &mut Vec<u8>, expr_lit: &syn::ExprLit) {
+    match &expr_lit.lit {
+        syn::Lit::Byte( byte) => bytes.push(byte.value()),
+        syn::Lit::ByteStr(st) => bytes.append(&mut st.value()),
+        syn::Lit::Int(i) => {
+            if let Ok(val) = i.base10_parse::<u8>() {
+                bytes.push(val);
+            }
+        },
+        _ => ()
+    }
+}
+
+fn get_bytes_from_expr(bytes: &mut Vec<u8>, expr: &syn::Expr) {
+    match expr {
+        syn::Expr::Lit(lit) => get_bytes_from_expr_lit(bytes, lit),
+        syn::Expr::Array(arr) => {
+            arr.elems.iter().for_each(|expr| get_bytes_from_expr(bytes, expr) )
+        },
+        _ => (),
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum Header{
+    Bytes(Vec<u8>),
+    Trait(usize),
+}
+
+impl Header {
+    pub fn from_expr(expr: &syn::Expr) -> Option<Self> {
+        let mut bytes = vec![];
+        get_bytes_from_expr(&mut bytes,  expr);
+        if !bytes.is_empty() {
+            Some(Header::Bytes(bytes))
+        } else {
+            None
+        }
+    }
+
+    pub fn from_trait_expr(expr: &syn::Expr) -> Option<Self> {
+        let mut len: usize = 0;
+        if let syn::Expr::Lit(lit) = expr {
+            if let syn::Lit::Int(int) = &lit.lit {
+                if let Ok(val) = int.base10_parse::<usize>() {
+                    len = val;
+                }
+            }
+        }
+        if len > 0 {
+            Some(Header::Trait(len))
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum Footer{
+    Bytes(Vec<u8>),
+    Trait(usize),
+}
+
+impl Footer {
+    pub fn from_expr(expr: &syn::Expr) -> Option<Self> {
+        let mut bytes = vec![];
+        get_bytes_from_expr(&mut bytes,  expr);
+        if !bytes.is_empty() {
+            Some(Footer::Bytes(bytes))
+        } else {
+            None
+        }
+    }
+
+    pub fn from_trait_expr(expr: &syn::Expr) -> Option<Self> {
+        let mut len: usize = 0;
+        if let syn::Expr::Lit(lit) = expr {
+            if let syn::Lit::Int(int) = &lit.lit {
+                if let Ok(val) = int.base10_parse::<usize>() {
+                    len = val;
+                }
+            }
+        }
+        if len > 0 {
+            Some(Footer::Trait(len))
+        } else {
+            None
+        }
+    }
+}
+
 fn get_builtin_type_bit_width(p: &syn::PathSegment) -> syn::Result<Option<usize>> {
     match p.ident.to_string().as_str() {
         "bool" => Ok(Some(1)),
@@ -166,7 +275,7 @@ fn get_field_mid_positioning(field: &syn::Field) -> syn::Result<FieldMidPosition
         _ => { return Err(syn::Error::new(field.ty.span(), "Unsupported type")); }
     };
 
-    let field_attributes = PackFieldAttribute::parse_all(&parse_sub_attributes(&field.attrs, "packed_field", "packed_struct")?);
+    let field_attributes = PackFieldAttribute::parse_all(&parse_sub_attributes_as_string(&field.attrs, "packed_field", "packed_struct")?);
 
     let bits_position = field_attributes.iter().filter_map(|a| match a {
         &PackFieldAttribute::BitPosition(b) | &PackFieldAttribute::BytePosition(b) => Some(b),
@@ -242,7 +351,7 @@ fn parse_reg_field(field: &syn::Field, ty: &syn::Type, bit_range: &Range<usize>,
     let bit_width = (bit_range.end - bit_range.start) + 1;
     
     let ty_str = tokens_to_string(ty);
-    let field_attributes = PackFieldAttribute::parse_all(&parse_sub_attributes(&field.attrs, "packed_field", "packed_struct")?);
+    let field_attributes = PackFieldAttribute::parse_all(&parse_sub_attributes_as_string(&field.attrs, "packed_field", "packed_struct")?);
 
 
     let is_enum_ty = field_attributes.iter().filter_map(|a| match *a {
@@ -349,8 +458,6 @@ pub fn parse_num(s: &str) -> Result<usize, String> {
     }
 }
 
-
-
 pub fn parse_struct(ast: &syn::DeriveInput) -> syn::Result<PackStruct> {
     let attributes = PackStructAttribute::parse_all(&parse_sub_attributes(&ast.attrs, "packed_struct", "packed_field")?);
 
@@ -425,20 +532,48 @@ pub fn parse_struct(ast: &syn::DeriveInput) -> syn::Result<PackStruct> {
         }
     }
 
-    let num_bits: usize = {
+    let mut num_bits: usize = {
         if let Some(struct_size_bytes) = struct_size_bytes {
             struct_size_bytes * 8
         } else {
             let last_bit = fields_parsed.iter().map(|f| match f {
                 FieldKind::Regular { ref field, .. } => field.bit_range_rust.end,
                 FieldKind::Array { ref elements, .. } => elements.last().unwrap().bit_range_rust.end
-            }).max().unwrap();
+            }).max().unwrap_or(0);
             last_bit
         }
     };
 
+    let mut header: Option<Header> = None;
+
+    attributes.iter().for_each(|a| {
+        if let PackStructAttribute::Header(prep) = a {
+            num_bits += 8 * match prep {
+                Header::Bytes(bytes) => bytes.len(),
+                Header::Trait(size) => *size,
+            };
+            header = Some(prep.to_owned());
+        }
+    });
+
+    let mut footer: Option<Footer> = None;
+
+    attributes.iter().for_each(|a| {
+        if let PackStructAttribute::Footer(app) = a {
+            num_bits += 8 * match app {
+                Footer::Bytes(bytes) => bytes.len(),
+                Footer::Trait(size) => *size,
+            };
+            footer = Some(app.to_owned());
+        }
+    });
+
     let num_bytes = (num_bits as f32 / 8.0).ceil() as usize;
 
+    if num_bits == 0 {
+        return Err(syn::Error::new(ast.span(), "Empty Structures without header or footer are not supported"));
+    }
+
     if first_field_is_auto_positioned && (num_bits % 8) != 0 && struct_size_bytes.is_none() {
         return Err(syn::Error::new(fields[0].span(), "Please explicitly position the bits of the first field of this structure, as the alignment isn't obvious to the end user."));
     }
@@ -477,6 +612,8 @@ pub fn parse_struct(ast: &syn::DeriveInput) -> syn::Result<PackStruct> {
         data_struct,
         fields: fields_parsed,
         num_bytes,
-        num_bits
+        num_bits,
+        header,
+        footer
     })
 }
diff --git a/packed_struct_codegen/src/pack_parse_attributes.rs b/packed_struct_codegen/src/pack_parse_attributes.rs
index f44bc82..907987e 100644
--- a/packed_struct_codegen/src/pack_parse_attributes.rs
+++ b/packed_struct_codegen/src/pack_parse_attributes.rs
@@ -5,7 +5,11 @@ pub enum PackStructAttributeKind {
     SizeBytes,
     //SizeBits,
     DefaultIntEndianness,
-    BitNumbering
+    BitNumbering,
+    Header,
+    HeaderWithTrait,
+    Footer,
+    FooterWithTrait,
 }
 
 impl PackStructAttributeKind {
@@ -16,7 +20,11 @@ impl PackStructAttributeKind {
             SizeBytes => "size_bytes",
             //SizeBits => "size_bits",
             DefaultIntEndianness => "endian",
-            BitNumbering => "bit_numbering"
+            BitNumbering => "bit_numbering",
+            Header => "header",
+            HeaderWithTrait => "header_size",
+            Footer => "footer",
+            FooterWithTrait => "footer_size"
         }
     }
 }
@@ -25,26 +33,49 @@ pub enum PackStructAttribute {
     SizeBytes(usize),
     //SizeBits(usize),
     DefaultIntEndianness(IntegerEndianness),
-    BitNumbering(BitNumbering)
+    BitNumbering(BitNumbering),
+    Header(Header),
+    Footer(Footer),
 }
 
 impl PackStructAttribute {
-    pub fn parse(name: &str, val: &str) -> Result<Self, String> {
+    pub fn parse(name: &str, val: &syn::Expr) -> Result<Self, String> {
         if name == PackStructAttributeKind::DefaultIntEndianness.get_attr_name() {
+            let val = &get_string_from_expr(val).unwrap_or_default();
             let v = IntegerEndianness::from_str(val).ok_or_else(|| format!("Invalid default int endian value: {}", val))?;
             return Ok(PackStructAttribute::DefaultIntEndianness(v));
         }
 
         if name == PackStructAttributeKind::BitNumbering.get_attr_name() {
-            let b = BitNumbering::from_str(val).expect("Invalid bit numbering attribute value");
+            let b = BitNumbering::from_str(&get_string_from_expr(val).unwrap_or_default()).expect("Invalid bit numbering attribute value");
             return Ok(PackStructAttribute::BitNumbering(b));
         }
 
         if name == PackStructAttributeKind::SizeBytes.get_attr_name() {
-            let b = parse_num(val)?;
+            let b = parse_num(&get_string_from_expr(val).unwrap_or_default())?;
             return Ok(PackStructAttribute::SizeBytes(b));
         }
 
+        if name == PackStructAttributeKind::Header.get_attr_name() {
+            let b = Header::from_expr(val).expect("Invalid prepend value");
+            return Ok(PackStructAttribute::Header(b));
+        }
+
+        if name == PackStructAttributeKind::Footer.get_attr_name() {
+            let b = Footer::from_expr(val).expect("Invalid append value");
+            return Ok(PackStructAttribute::Footer(b));
+        }
+
+        if name == PackStructAttributeKind::HeaderWithTrait.get_attr_name() {
+            let b = Header::from_trait_expr(val).expect("Invalid prepend value");
+            return Ok(PackStructAttribute::Header(b));
+        }
+
+        if name == PackStructAttributeKind::FooterWithTrait.get_attr_name() {
+            let b = Footer::from_trait_expr(val).expect("Invalid append value");
+            return Ok(PackStructAttribute::Footer(b));
+        }
+
         /*
         if name == PackStructAttributeKind::SizeBits.get_attr_name() {
             let b = parse_num(val);
@@ -52,10 +83,11 @@ impl PackStructAttribute {
         }
         */
 
+        let val = &get_string_from_expr(val).unwrap_or_default();
         Err(format!("Unknown struct attribute: {}, value {}", name, val))
     }
 
-    pub fn parse_all(attributes: &[(String, String)]) -> Vec<Self> {
+    pub fn parse_all(attributes: &[(String, syn::Expr)]) -> Vec<Self> {
         let mut r = vec![];
         for (name, val) in attributes {
             if let Ok(attr) = Self::parse(name, val) {
diff --git a/packed_struct_examples/src/example2.rs b/packed_struct_examples/src/example2.rs
new file mode 100644
index 0000000..d73afa7
--- /dev/null
+++ b/packed_struct_examples/src/example2.rs
@@ -0,0 +1,129 @@
+//! Documentation example for the header and footer attributes and traits
+
+use packed_struct::{prelude::*, PackedStructHeader, PackedStructFooter};
+
+// Sometimes you want a static header or footer on a packed struckt. For example when you want to send the packed struct as a command via serial and you need the command to have a header
+#[derive(PackedStruct, Debug, Copy, Clone, PartialEq)]
+#[packed_struct(bit_numbering = "msb0", endian = "msb", header = [0x80, 0x60], footer = 0x16)]
+pub struct FunctionCommand {
+    #[packed_field(bytes = "0..=1")]
+    pub address: u16,
+    #[packed_field(bits = "16")]
+    pub f1: bool,
+    #[packed_field(bits = "17")]
+    pub f2: bool,
+    #[packed_field(bits = "18")]
+    pub f3: bool,
+    #[packed_field(bits = "19")]
+    pub f4: bool,
+    #[packed_field(bits = "20")]
+    pub f5: bool,
+    #[packed_field(bits = "21")]
+    pub f6: bool,
+    #[packed_field(bits = "22")]
+    pub f7: bool,
+    #[packed_field(bits = "23")]
+    pub f8: bool,
+}
+
+#[test]
+fn test_static_header_and_footer() {
+    let fun = FunctionCommand {
+        address: 1,
+        f1: true,
+        f2: false,
+        f3: true,
+        f4: false,
+        f5: false,
+        f6: true,
+        f7: false,
+        f8: true
+    };
+
+    let packed = fun.pack().unwrap();
+    assert_eq!(&packed, &[0x80 as u8, 0x60, 0x00, 0x01, 0b10100101, 0x16]);
+
+    let _unpacked = FunctionCommand::unpack(&[0x80 as u8, 0x60, 0x00, 0x01, 0b10100101, 0x00]).unwrap();
+
+    println!("{}", fun);
+}
+
+// Other times you might need to specify the header dynamically, for example if the header is different if all fields are false. You might also want to make sure your struct gets received correctly put an xor value in the footer
+#[derive(PackedStruct, Debug, Clone, PartialEq)]
+#[packed_struct(bit_numbering = "msb0", endian = "msb", header_size = 1, footer_size = 1)]
+pub struct DynamicCommand {
+    #[packed_field(bits = "0")]
+    pub f1: bool,
+    #[packed_field(bits = "1")]
+    pub f2: bool,
+    #[packed_field(bits = "2")]
+    pub f3: bool,
+    #[packed_field(bits = "3")]
+    pub f4: bool,
+    #[packed_field(bits = "4")]
+    pub f5: bool,
+    #[packed_field(bits = "5")]
+    pub f6: bool,
+    #[packed_field(bits = "6")]
+    pub f7: bool,
+    #[packed_field(bits = "7")]
+    pub f8: bool,
+}
+
+impl PackedStructHeader for DynamicCommand {
+    type HeaderByteArray = [u8; 1];
+
+    fn get_header(&self, data: &[u8]) -> packed_struct::PackingResult<Self::HeaderByteArray> {
+        let header = if data[1] == 0 {
+            [0x00]
+        } else {
+            [0x80]
+        };
+        Ok(header)
+    }
+}
+
+impl PackedStructFooter for DynamicCommand {
+    type FooterByteArray = [u8; 1];
+
+    fn get_footer(&self, data: &[u8]) -> packed_struct::PackingResult<Self::FooterByteArray> {
+        // Note that the header is already part of the data at this point
+        let mut xor: u8 = 0;
+        data.into_iter().for_each(|value| xor ^= value);
+        Ok([xor])
+    }
+
+    fn validate_footer(src: &[u8]) -> packed_struct::PackingResult<()> {
+        let mut xor: u8 = 0;
+        src[0..src.len()].into_iter().for_each(|value| xor ^= value);
+        if src.ends_with(&[xor]) {
+            Ok(())
+        } else {
+            Err(PackingError::UserError(format!("Invalid xor: {} to {:?}", xor, src.last().unwrap())))
+        }
+    }
+}
+
+#[test]
+fn test_dynamic_header_and_footer() {
+    let dy = DynamicCommand {
+        f1: true,
+        f2: false,
+        f3: true,
+        f4: false,
+        f5: false,
+        f6: true,
+        f7: false,
+        f8: true
+    };
+
+    let packed = dy.pack().unwrap();
+    assert_eq!(&packed, &[0x80 as u8,0b10100101, 0x25]);
+
+    // We've set the footer to zero so it will fail to unpack
+    let unpacked_result = DynamicCommand::unpack(&[0x80 as u8, 0b10100101, 0x00]);
+
+    assert_eq!(unpacked_result, Err(PackingError::UserError("Invalid xor: 37 to 0".to_owned())));
+
+    println!("{}", dy);
+}
\ No newline at end of file
diff --git a/packed_struct_examples/src/lib.rs b/packed_struct_examples/src/lib.rs
index a324a22..17baa4b 100644
--- a/packed_struct_examples/src/lib.rs
+++ b/packed_struct_examples/src/lib.rs
@@ -4,6 +4,7 @@ extern crate packed_struct;
 use packed_struct::prelude::*;
 
 pub mod example1;
+pub mod example2;
 
 
 /// MultiWii status structure