Init Commit: Moved bproto to seperate repo

template/c/template/bproto.cmake.jinja2

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 3.10)
+
+# Add the library
+add_library(bproto STATIC 
+    ${CMAKE_CURRENT_LIST_DIR}/src/{{protocol.name}}_bitfield.c
+    ${CMAKE_CURRENT_LIST_DIR}/src/{{protocol.name}}_crc.c
+    ${CMAKE_CURRENT_LIST_DIR}/src/{{protocol.name}}_mapping.c
+    ${CMAKE_CURRENT_LIST_DIR}/src/{{protocol.name}}_message_fromBytes.c
+    ${CMAKE_CURRENT_LIST_DIR}/src/{{protocol.name}}_message_toBytes.c
+)
+
+target_include_directories(bproto PUBLIC 
+    ${CMAKE_CURRENT_LIST_DIR}/include
+)

template/c/template/include/bitfield/bitfield.h.jinja2

@@ -0,0 +1,18 @@
+#pragma once
+#include <stddef.h>
+#include <stdint.h>
+{% for bitfield in bitfields %}
+#define {{bitfield.size_name}} {{bitfield.size}}
+{%- endfor %}
+{% for bitfield in bitfields %}
+typedef struct {{bitfield.name}} {
+{%- for bit in bitfield.bits %}
+    unsigned int {{bit.name}} : {{bit.length}};
+{%- endfor %}
+} {{bitfield.name}};
+{% endfor -%}
+{% for bitfield in bitfields %}
+size_t fromBytes_{{bitfield.name}}(uint8_t * data, {{bitfield.name}} * bitfield);
+
+size_t toBytes_{{bitfield.name}}(uint8_t * data, {{bitfield.name}} * bitfield);
+{% endfor %}

template/c/template/include/crc.h.jinja2

@@ -0,0 +1,18 @@
+
+#ifndef _CRC16_H_
+#define _CRC16_H_
+
+#include <stdint.h>
+#include <stddef.h>
+
+#ifdef __cplusplus                                                                                                       
+extern "C" {                                                                                                             
+#endif
+
+uint16_t {{protocol.name}}_crc16_ccitt(const uint8_t* buffer, size_t size);
+
+#ifdef __cplusplus                                                                                                       
+}
+#endif
+
+#endif // _CRC16_H_

template/c/template/include/enums.h.jinja2

@@ -0,0 +1,26 @@
+#pragma once
+typedef enum {
+    {{protocol.name}}_PARSER_RESULT_OK, 
+    {{protocol.name}}_PARSER_RESULT_ERROR_INVALID_SIZE,
+    {{protocol.name}}_PARSER_RESULT_ERROR_INVALID_ID,
+    {{protocol.name}}_PARSER_RESULT_ERROR_INVALID_CRC,
+} {{protocol.name}}_PARSER_RESULT;
+
+typedef enum {
+{%- for msg in messages %}
+    {{msg.id_name}} = {{msg.id}}{% if not loop.last %},{% endif %}
+{%- endfor %}
+} {{protocol.name}}_MSG_ID ;
+
+typedef enum {
+{%- for msg in messages %}
+    {{msg.size_name}} = {{msg.size}}{% if not loop.last %},{% endif %}
+{%- endfor %}
+} {{protocol.name}}_MSG_SIZE;
+{% for enum in enums %}
+typedef enum {
+{%- for v in enum.consts %}
+    {{ v[0] }} = {{ v[1] }}{% if not loop.last %},{% endif %}
+{%- endfor %}
+} {{enum.name}};
+{% endfor %}

template/c/template/include/message/message.h.jinja2

@@ -0,0 +1,27 @@
+#pragma once
+#include "{{protocol.name}}_bitfield.h"
+#include "{{protocol.name}}_enum.h"
+#include "{{protocol.name}}_crc.h"
+#include <stdint.h>
+#include <stdbool.h>
+
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+#define MAX_MESSAGE_STRUCT_SIZE {{ protocol.max_struct_size_expr }}
+#define MAX_MESSAGE_DATA_SIZE {{ protocol.max_data_size }}
+{% for msg in messages %}
+typedef struct {{msg.name}} {
+{%- for field in msg.fields %}
+    {{ field.type.name }} {{ field.name }}{{ field.type.array }};
+{%- endfor %}
+} {{msg.name}};
+{% endfor %}
+
+{%- for msg in messages %}
+size_t toBytes_{{msg.name}}({{msg.name}} * msg, uint8_t * data);
+
+{{protocol.name}}_PARSER_RESULT fromBytes_{{msg.name}}({{msg.name}} * msg, uint8_t * data, size_t data_size, size_t * parsed_size);
+{% endfor %}
+
+{{protocol.name}}_PARSER_RESULT fromBytes(void * msg, uint8_t * data, size_t data_size, size_t * parsed_size, {{protocol.name}}_MSG_ID * msg_id);
+
+{{protocol.name}}_MSG_SIZE {{protocol.name}}_mapMessageToSize(uint8_t msg_id);

template/c/template/src/bitfield.c.jinja2

@@ -0,0 +1,6 @@
+#include "{{protocol.name}}_bitfield.h"
+{% for bitfield in bitfields %}
+{% include 'c/template/src/bitfield/fromBytes.c.jinja2' %}
+
+{% include 'c/template/src/bitfield/toBytes.c.jinja2' %}
+{% endfor %}

template/c/template/src/bitfield/fromBytes.c.jinja2

@@ -0,0 +1,10 @@
+size_t fromBytes_{{bitfield.name}}(uint8_t * data, {{bitfield.name}} * bitfield) {
+    {%- for bit in bitfield.bits %}
+    {%- if bit.spacer %}
+    // {{ bit.length }} bits of nothingness
+    {%- else %}
+    bitfield->{{ bit.name }} = (data[{{ bit.byte_pos }}] >> {{ bit.bit_pos }}) & 0b1;
+    {%- endif -%}
+    {% endfor %}
+    return {{bitfield.size}};
+}

template/c/template/src/bitfield/toBytes.c.jinja2

@@ -0,0 +1,12 @@
+size_t toBytes_{{bitfield.name}}(uint8_t * data, {{bitfield.name}} * bitfield) {
+    memset(data, 0, {{bitfield.size}});
+    {%- for bit in bitfield.bits %}
+    {%- if bit.spacer %}
+    // {{ bit.length }} bits of nothingness
+    {%- else %}
+    data[{{ bit.byte_pos }}] |= (bitfield->{{ bit.name }} & 0b1) << {{ bit.bit_pos }};
+    {%- endif -%}
+
+    {% endfor %}
+    return {{bitfield.size}};
+}

template/c/template/src/crc.c.jinja2

@@ -0,0 +1,48 @@
+#include "{{protocol.name}}_crc.h"
+
+// From: https://gist.github.com/rafacouto/59326c90d6a55f86a3ba
+
+static const uint16_t {{protocol.name}}_ccitt_hash[] = {
+    0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
+    0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,
+    0x1231,0x0210,0x3273,0x2252,0x52b5,0x4294,0x72f7,0x62d6,
+    0x9339,0x8318,0xb37b,0xa35a,0xd3bd,0xc39c,0xf3ff,0xe3de,
+    0x2462,0x3443,0x0420,0x1401,0x64e6,0x74c7,0x44a4,0x5485,
+    0xa56a,0xb54b,0x8528,0x9509,0xe5ee,0xf5cf,0xc5ac,0xd58d,
+    0x3653,0x2672,0x1611,0x0630,0x76d7,0x66f6,0x5695,0x46b4,
+    0xb75b,0xa77a,0x9719,0x8738,0xf7df,0xe7fe,0xd79d,0xc7bc,
+    0x48c4,0x58e5,0x6886,0x78a7,0x0840,0x1861,0x2802,0x3823,
+    0xc9cc,0xd9ed,0xe98e,0xf9af,0x8948,0x9969,0xa90a,0xb92b,
+    0x5af5,0x4ad4,0x7ab7,0x6a96,0x1a71,0x0a50,0x3a33,0x2a12,
+    0xdbfd,0xcbdc,0xfbbf,0xeb9e,0x9b79,0x8b58,0xbb3b,0xab1a,
+    0x6ca6,0x7c87,0x4ce4,0x5cc5,0x2c22,0x3c03,0x0c60,0x1c41,
+    0xedae,0xfd8f,0xcdec,0xddcd,0xad2a,0xbd0b,0x8d68,0x9d49,
+    0x7e97,0x6eb6,0x5ed5,0x4ef4,0x3e13,0x2e32,0x1e51,0x0e70,
+    0xff9f,0xefbe,0xdfdd,0xcffc,0xbf1b,0xaf3a,0x9f59,0x8f78,
+    0x9188,0x81a9,0xb1ca,0xa1eb,0xd10c,0xc12d,0xf14e,0xe16f,
+    0x1080,0x00a1,0x30c2,0x20e3,0x5004,0x4025,0x7046,0x6067,
+    0x83b9,0x9398,0xa3fb,0xb3da,0xc33d,0xd31c,0xe37f,0xf35e,
+    0x02b1,0x1290,0x22f3,0x32d2,0x4235,0x5214,0x6277,0x7256,
+    0xb5ea,0xa5cb,0x95a8,0x8589,0xf56e,0xe54f,0xd52c,0xc50d,
+    0x34e2,0x24c3,0x14a0,0x0481,0x7466,0x6447,0x5424,0x4405,
+    0xa7db,0xb7fa,0x8799,0x97b8,0xe75f,0xf77e,0xc71d,0xd73c,
+    0x26d3,0x36f2,0x0691,0x16b0,0x6657,0x7676,0x4615,0x5634,
+    0xd94c,0xc96d,0xf90e,0xe92f,0x99c8,0x89e9,0xb98a,0xa9ab,
+    0x5844,0x4865,0x7806,0x6827,0x18c0,0x08e1,0x3882,0x28a3,
+    0xcb7d,0xdb5c,0xeb3f,0xfb1e,0x8bf9,0x9bd8,0xabbb,0xbb9a,
+    0x4a75,0x5a54,0x6a37,0x7a16,0x0af1,0x1ad0,0x2ab3,0x3a92,
+    0xfd2e,0xed0f,0xdd6c,0xcd4d,0xbdaa,0xad8b,0x9de8,0x8dc9,
+    0x7c26,0x6c07,0x5c64,0x4c45,0x3ca2,0x2c83,0x1ce0,0x0cc1,
+    0xef1f,0xff3e,0xcf5d,0xdf7c,0xaf9b,0xbfba,0x8fd9,0x9ff8,
+    0x6e17,0x7e36,0x4e55,0x5e74,0x2e93,0x3eb2,0x0ed1,0x1ef0,
+};
+
+uint16_t {{protocol.name}}_crc16_ccitt(const uint8_t* buffer, size_t size)
+{
+    uint16_t crc = {{protocol.crc_initial}};
+    while (size-- > 0)
+    {
+    	crc = (crc << 8) ^ {{protocol.name}}_ccitt_hash[((crc >> 8) ^ *(buffer++)) & 0x00FF];
+    }
+    return crc;
+}

template/c/template/src/message/fromBytes.c.jinja2

@@ -0,0 +1,70 @@
+#include "{{protocol.name}}_bitfield.h"
+#include "{{protocol.name}}_enum.h"
+#include "{{protocol.name}}_message.h"
+#include "{{protocol.name}}_crc.h"
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include <string.h>
+{% for msg in messages %}
+{{protocol.name}}_PARSER_RESULT fromBytes_{{msg.name}}({{msg.name}} * msg, uint8_t * data, size_t data_size, size_t * parsed_size) {
+    data += 1;
+{% for field in msg.fields %}
+{%- if field.decompose_mode == "for" %}
+    for(int i=0; i<{{field.array_size}}; i++) {
+        {% if field.pre_init_value != None %}msg->{{field.name}}[i] = {{field.pre_init_value}};{% endif %}
+        memcpy(&msg->{{field.name}}[i], data, sizeof({{field.type.aux or field.type.name}}));
+        data += {{field.base_size}};
+    }
+{%- elif field.decompose_mode == "inline_for" %}
+    {%- for i in range(field.array_size) %}
+    {% if field.pre_init_value != None %}msg->{{field.name}}[{{i}}] = {{field.pre_init_value}};{% endif %}
+    {% if field.fromBytes_overwride %}{{ field.fromBytes_overwride }}{% else %}memcpy(&msg->{{field.name}}[{{i}}], data, sizeof({{field.type.aux or field.type.name}}));{% endif %};
+    data += {{field.base_size}};
+    {%- endfor %}
+{%- else %}
+    {% if field.pre_init_value != None %}msg->{{field.name}} = {{field.pre_init_value}};{% endif %}
+    {% if field.fromBytes_overwride %}{{ field.fromBytes_overwride }}{% else %}memcpy(&msg->{{field.name}}, data, sizeof({{field.type.aux or field.type.name}}));{% endif %};
+    data += {{field.base_size}};
+{%- endif %}
+{% endfor %}
+    *parsed_size = {{msg.size}};
+    return {{protocol.name}}_PARSER_RESULT_OK;
+}
+{% endfor %}
+
+{{protocol.name}}_PARSER_RESULT fromBytes(void * msg, uint8_t * data, size_t data_size, size_t * parsed_size, {{protocol.name}}_MSG_ID * msg_id) {
+    if(data_size < 1) {
+        return {{protocol.name}}_PARSER_RESULT_ERROR_INVALID_SIZE;
+    }
+
+    uint8_t incomming_msg_id= data[0];
+    size_t expected_size = {{protocol.name}}_mapMessageToSize(incomming_msg_id);
+
+    if(expected_size <= 0) {
+        return {{protocol.name}}_PARSER_RESULT_ERROR_INVALID_ID;
+    }
+
+    if(data_size < expected_size) {
+        return {{protocol.name}}_PARSER_RESULT_ERROR_INVALID_SIZE;
+    }
+
+    uint16_t crc;
+    memcpy(&crc, data + expected_size - {{ protocol.crc_size }}, sizeof(uint16_t));
+
+    if(HCP_crc16_ccitt(data, expected_size - {{ protocol.crc_size }}) != crc) {
+        return {{protocol.name}}_PARSER_RESULT_ERROR_INVALID_CRC;
+    }
+
+    *msg_id = incomming_msg_id;
+
+    switch(incomming_msg_id) {
+{%- for msg in messages %}
+        case {{msg.id_name}}:
+            return fromBytes_{{msg.name}}(msg, data, data_size, parsed_size);
+            break;
+{% endfor %}
+    }
+
+    return {{protocol.name}}_PARSER_RESULT_OK;
+}

template/c/template/src/message/mapping.c.jinja2

@@ -0,0 +1,14 @@
+#include "{{protocol.name}}_enum.h"
+#include <stdint.h>
+
+{{protocol.name}}_MSG_SIZE {{protocol.name}}_mapMessageToSize(uint8_t msg_id) {
+    switch(msg_id) {
+{%- for msg in messages %}
+        case {{msg.id_name}}:
+            return {{msg.size_name}};
+{%- endfor %}
+        default:
+            return 0;
+    }
+}
+

template/c/template/src/message/toBytes.c.jinja2

@@ -0,0 +1,34 @@
+#include "{{protocol.name}}_bitfield.h"
+#include "{{protocol.name}}_enum.h"
+#include "{{protocol.name}}_message.h"
+#include "{{protocol.name}}_crc.h"
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+{% for msg in messages %}
+size_t toBytes_{{msg.name}}({{msg.name}} * msg, uint8_t * data) {
+    uint8_t * data_begin = data;
+    *data = (uint8_t)({{msg.id_name}});
+    data += 1;
+{% for field in msg.fields %}
+{%- if field.decompose_mode == "for" %}
+    for(int i=0; i<{{field.array_size}}; i++) {
+        memcpy(data, &msg->{{field.name}}[i], sizeof({{field.type.aux or field.type.name}}));
+        data += {{field.base_size}};
+    }
+{%- elif field.decompose_mode == "inline_for" %}
+    {%- for i in range(field.array_size) %}
+    {% if field.toBytes_overwride %}{{field.toBytes_overwride}}{% else %}memcpy(data, &msg->{{field.name}}[{{i}}], sizeof({{field.type.aux or field.type.name}}));{% endif %};
+    data += {{field.base_size}};
+    {%- endfor %}
+{%- else %}
+    {% if field.toBytes_overwride %}{{field.toBytes_overwride}}{% else %}memcpy(data, &msg->{{field.name}}, sizeof({{field.type.aux or field.type.name}}));{% endif %};
+    data += {{field.base_size}};
+{%- endif %}
+{% endfor %}
+    uint16_t crc = {{protocol.name}}_crc16_ccitt(data_begin, {{msg.size_name}} - {{protocol.crc_size}});
+    memcpy(data, &crc, sizeof(uint16_t));
+
+    return {{msg.size_name}};
+}
+{% endfor %}

template/python/static/bproto_base.py

@@ -0,0 +1,67 @@
+import abc
+
+
+class bproto_Package(abc.ABC):
+    @abc.abstractmethod
+    def to_bytes(self) -> bytes:
+        raise NotImplementedError()
+    
+    @abc.abstractmethod
+    def from_bytes(self, data: bytes):
+        raise NotImplementedError()
+    
+
+class bproto_Bitfield(abc.ABC):
+    @abc.abstractmethod
+    def to_bytes(self) -> bytes:
+        pass
+    
+    @abc.abstractmethod
+    def from_bytes(self, data: bytes):
+        pass
+    
+    def __str__(self):
+        return self.__repr__()
+
+
+def crc16_calc_inital(data: bytearray) -> int:
+    """CRC-16/CITT-FALSE
+    from https://stackoverflow.com/questions/35205702/calculating-crc16-in-python
+
+    Args:
+        data (bytearray): protocol hash
+
+    Returns:
+        bytes: initals for crc16_calc_with_initial
+    """
+    crc = 0xFFFF
+    for i in range(0, len(data)):
+        crc ^= data[i] << 8
+        for j in range(0, 8):
+            if (crc & 0x8000) > 0:
+                crc = (crc << 1) ^ 0x1021
+            else:
+                crc = crc << 1
+    return crc
+
+
+def calc_crc_sum(data: bytearray, inital: int) -> bytes:
+    """CRC-16/CITT-FALSE
+    form https://stackoverflow.com/questions/35205702/calculating-crc16-in-python
+    
+    Args:
+        data (bytearray): protocol data
+        inital (int): Inital calculated from protocol hash
+
+    Returns:
+        bytes: 2 byte CRC Checksum
+    """
+    crc = inital
+    for i in range(0, len(data)):
+        crc ^= data[i] << 8
+        for j in range(0, 8):
+            if (crc & 0x8000) > 0:
+                crc = (crc << 1) ^ 0x1021
+            else:
+                crc = crc << 1
+    return crc & 0xFFFF

template/python/static/bproto_error.py

@@ -0,0 +1,19 @@
+class bproto_Error(Exception):
+    def __init__(self, message):
+        self.message = message
+
+
+class bproto_PackageError(bproto_Error):
+    pass
+
+
+class bproto_PackageErrorInvalidSize(bproto_PackageError):
+    pass
+
+
+class bproto_PackageErrorInvalidMessageID(bproto_PackageError):
+    pass
+
+
+class bproto_PackageErrorInvalidCRC(bproto_PackageError):
+    pass

template/python/template/bproto_protocol_bitfield.py.jinja2

@@ -0,0 +1,38 @@
+from bproto_base import bproto_Bitfield
+
+{% for bitfield in bitfields %}
+class {{bitfield.name}}(bproto_Bitfield):
+    BYTE_SIZE = {{bitfield.size}}
+
+    def __init__(self,
+            {%- for bit in bitfield.bits %}
+                 {{bit.name}}=False,
+            {%- endfor %}
+                 ):
+        {%- for bit in bitfield.bits %}
+        self.{{bit.name}} = {{bit.name}}
+        {%- endfor %}
+
+    def to_bytes(self) -> bytes:
+        res = 0
+        {%- for bit in bitfield.bits %}
+        res |= (1 << {{bit.pos}}) if self.{{bit.name}} else 0
+        {%- endfor %}
+        return int.to_bytes(res, self.BYTE_SIZE, '{{protocol.endian_str}}')
+
+    def from_bytes(self, data: bytes):
+        bits = int.from_bytes(data[:self.BYTE_SIZE], '{{protocol.endian_str}}')
+        {%- for bit in bitfield.bits %}
+        self.{{bit.name}} = (bits & (1 << {{bit.pos}})) != 0
+        {%- endfor %}
+        return self
+
+    def __repr__(self) -> str:
+        value_str = ", ".join([
+            {%- for bit in bitfield.bits %}
+            "{{bit.name}}=" + str(self.{{bit.name}}),
+            {%- endfor %}
+        ])
+        return "{{bitfield.name}}(" + value_str + ")"
+
+{% endfor %}

template/python/template/bproto_protocol_packets.py.jinja2

@@ -0,0 +1,19 @@
+from bproto_base import bproto_Package, calc_crc_sum
+from bproto_error import bproto_Error, bproto_PackageErrorInvalidSize, bproto_PackageErrorInvalidMessageID, bproto_PackageErrorInvalidCRC
+
+from {{ import_name }}_protocol_enum import {% for e in enums %}{{e.name}}{% if not loop.last %}, {% endif %}{% endfor %}
+from {{ import_name }}_protocol_bitfield import {% for b in bitfields %}{{b.name}}{% if not loop.last %}, {% endif %}{% endfor %}
+from {{ import_name }}_protocol_message_ids import MessageIds_{{ protocol.name }}, MESSAGE_SIZE_MAP_{{ protocol.name }}
+
+from typing import Annotated, List
+import struct
+
+CRC_INITAL = {{ protocol.crc_initial }}
+
+
+{% for m in messages %}
+{%- include 'python/template/message/class.jinja2' -%}
+{%- if not loop.last %}
+
+{% else %}{%- endif -%}{%- endfor %}
+{% include 'python/template/message/parse_generic.jinja2' -%}

template/python/template/bproto_protocol_packets_ids.py.jinja2

@@ -0,0 +1,15 @@
+import enum
+
+
+class MessageIds_{{ protocol.name }}(enum.Enum):
+    {%- for msg in messages %}
+    {{ msg.id_name }} = {{ msg.id }}
+    {%- endfor %}
+
+
+MESSAGE_SIZE_MAP_{{ protocol.name }} = {
+    {%- for msg in messages %}
+    MessageIds_{{ protocol.name }}.{{ msg.id_name }}: {{ msg.size }},
+    {%- endfor %}
+}
+

template/python/template/enum.py.jinja2

@@ -0,0 +1,8 @@
+import enum
+{% for e in enums %}
+
+class {{ e.name }}(enum.Enum):
+{%- for k,v in e.consts %}
+    {{ k }} = {{ v }}
+{%- endfor %}
+{% endfor %}

template/python/template/message/class.jinja2

@@ -0,0 +1,20 @@
+class {{m.name}}(bproto_Package):
+    ID = MessageIds_{{ protocol.name }}.{{m.id_name}}
+    SIZE = {{ m.size }}
+    {% for f in m.fields %}
+    {{f.name}}: {{f.type}}
+    {%- endfor %}
+
+    def __init__(self,
+                 {% for f in m.fields -%}
+                 {{f.name}}: {{f.type}} = {{f.default_value}},
+                 {% endfor -%}
+                 ):
+        {% for f in m.fields -%}
+        self.{{f.name}} = {{f.name}}
+        {% endfor -%}
+
+
+{% include 'python/template/message/toBytes.jinja2' %}
+{% include 'python/template/message/fromBytes.jinja2' %}
+

template/python/template/message/fromBytes.jinja2

@@ -0,0 +1,21 @@
+    
+    def from_bytes(self, data: bytes):
+
+        if len(data) < self.SIZE:
+            raise bproto_PackageErrorInvalidSize(f"A size of {len(data)} is to small for {{ protocol.name }} (min. {self.SIZE})")
+
+        msg_id = struct.unpack('{{protocol.endian_format}}B', data[:1])[0]
+        crc_data = struct.unpack('{{protocol.endian_format}}H', data[-{{ protocol.crc_size }}:])[0]
+
+        if calc_crc_sum(data[:-{{ protocol.crc_size }}], CRC_INITAL) != crc_data:
+            raise bproto_PackageErrorInvalidCRC(f"CRC {crc_data:04x} did not match calculated")
+
+        if msg_id != self.ID.value:
+            raise bproto_PackageErrorInvalidMessageID("Message ID {msd_id} does not match {{ protocol.name }}'s id {self.ID.value}")
+
+        data = data[1:]
+        {% for f in m.fields -%}
+        self.{{ f.name }} = {{ f.from_bytes_conversion }}
+        data = data[{{ f.size }}:]
+        {% endfor -%}
+        return self

template/python/template/message/parse_generic.jinja2

@@ -0,0 +1,31 @@
+
+def parse_package(data: bytes) -> tuple[bproto_Package, int]:
+    if len(data) < 1:
+        raise bproto_PackageErrorInvalidSize("Package has no data")
+    
+    msg_id = struct.unpack('{{protocol.endian_format}}B', data[:1])[0]
+
+    if msg_id not in MessageIds_{{ protocol.name }}:
+        raise bproto_PackageErrorInvalidMessageID(f"Message ID '{msg_id}' is invaild")
+
+    msg_id = MessageIds_{{ protocol.name }}(msg_id)
+    expected_size = MESSAGE_SIZE_MAP_{{ protocol.name }}.get(msg_id) or 0
+
+    if expected_size > len(data):
+        raise bproto_PackageErrorInvalidSize(f"Package is to short for '{msg_id}' ({expected_size} > {len(data)})")
+    
+    pkg_data = data[:expected_size]
+
+    crc_data = struct.unpack('{{protocol.endian_format}}H', pkg_data[-2:])[0]
+
+    if calc_crc_sum(pkg_data[:-2], CRC_INITAL) != crc_data:
+        raise bproto_PackageErrorInvalidCRC(f"CRC {crc_data:04x} did not match calculated")
+
+    match(msg_id):
+        {%- for msg in messages %}
+        case MessageIds_{{ protocol.name }}.{{ msg.id_name }}:
+            return {{msg.name}}().from_bytes(pkg_data), expected_size
+        {%- endfor %}
+        case _:
+            raise bproto_Error("Message ID could not be interpreted; this should not have happen; its a developer error! Create a issue")
+

template/python/template/message/toBytes.jinja2

@@ -0,0 +1,8 @@
+    
+    def to_bytes(self) -> bytes:
+        res = struct.pack("{{protocol.endian_format}}B", self.ID.value)
+        {% for f in m.fields -%}
+        res += {{ f.to_bytes_conversion }}
+        {% endfor -%}
+        res += struct.pack("{{protocol.endian_format}}H", calc_crc_sum(res, CRC_INITAL))
+        return res

template/txt/protocolSummary.txt.jinja2

@@ -0,0 +1,26 @@
+Name: {{name}}
+Version: {{version}}
+
+Enums:
+{%- for enum in enums %}
+    {{enum.name}}: 
+    {%- for v in enum.consts %}
+        - {{v[0]}} = {{v[1]}}
+    {%- endfor %}
+{% endfor %}
+Bitfield:
+{%- for bitfield in bitfields %}
+    {{bitfield.name}}: 
+    {%- for v in bitfield.fields %}
+        - {{v[0]}}: {{v[1]}}
+    {%- endfor %}
+{% endfor %}
+Messages:
+{%- for message in messages %}
+    [{{message.id}}] {{message.name}}:
+        Size: {{message.size}} bytes
+        Fields:
+        {%- for field in message.fields %}
+            - ({{field.size}}) {{field.name}}: {{field.type}}[{{field.array_size}}] {% if field.ref != None %}-> {{field.ref}}{% endif %}
+        {%- endfor %}
+{% endfor -%}