burst-link-protocol 0.1.0__tar.gz

burst_link_protocol-0.1.0/.github/dependabot.yml

@@ -0,0 +1,11 @@
+version: 2
+updates:
+  # Maintain dependencies for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    groups:
+      actions:
+        patterns:
+          - "*"

burst_link_protocol-0.1.0/.github/workflows/pip.yml

@@ -0,0 +1,38 @@
+name: Pip
+
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    name: Build with Pip
+    runs-on: ${{ matrix.platform }}
+    strategy:
+      fail-fast: false
+      matrix:
+        # platform: [windows-latest, macos-latest, ubuntu-latest]
+        platform: [ ubuntu-latest]
+        python-version: ["3.12"]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Set min macOS version
+      if: runner.os == 'macOS'
+      run: |
+        echo "MACOSX_DEPLOYMENT_TARGET=10.14" >> $GITHUB_ENV
+
+    - name: Build and install
+      run: |
+        pip install --verbose .
+
+    - name: Test
+      run: python -m pytest

burst_link_protocol-0.1.0/.github/workflows/wheel.yml

@@ -0,0 +1,82 @@
+name: Wheels
+
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches:
+     - master
+  release:
+    types:
+      - published
+
+jobs:
+  build_sdist:
+    name: Build SDist
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: true
+
+    - name: Build SDist
+      run: pipx run build --sdist
+
+    - name: Check metadata
+      run: pipx run twine check dist/*
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: dist-sdist
+        path: dist/*.tar.gz
+
+
+  build_wheels:
+    name: Wheels on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest
+        # , macos-13, macos-14, windows-latest
+        ]
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: true
+
+    - uses: pypa/cibuildwheel@v2.22
+    # only build 3.12
+      env:
+        # CIBW_BUILD: "cp312-*"
+        CIBW_BUILD: "cp312-manylinux_x86_64"
+
+    - name: Verify clean directory
+      run: git diff --exit-code
+      shell: bash
+
+    - name: Upload wheels
+      uses: actions/upload-artifact@v4
+      with:
+        path: wheelhouse/*.whl
+        name: dist-${{ matrix.os }}
+
+  upload_all:
+    name: Upload if release
+    needs: [build_wheels, build_sdist]
+    runs-on: ubuntu-latest
+    # if: github.event_name == 'release' && github.event.action == 'published'
+    permissions:
+      id-token: write
+    environment: pypi_release
+
+    steps:
+    - uses: actions/setup-python@v5
+    - uses: actions/download-artifact@v4
+      with:
+        path: dist
+        pattern: dist-*
+        merge-multiple: true
+
+    - uses: pypa/gh-action-pypi-publish@release/v1

burst_link_protocol-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+build
+.venv
+*.whl
+poetry.lock
+**.pyc
+.coverage
+*.tar.gz

burst_link_protocol-0.1.0/.vscode/c_cpp_properties.json

@@ -0,0 +1,23 @@
+{
+    "configurations": [
+        {
+            "name": "Win32",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "${workspaceFolder}/.venv/Lib/site-packages/nanobind/include/nanobind", //To be fixed
+                "${env:PYTHON_INCLUDE}"
+            ],
+            "defines": [
+                "_DEBUG",
+                "UNICODE",
+                "_UNICODE"
+            ],
+            "windowsSdkVersion": "10.0.26100.0",
+            "compilerPath": "cl.exe",
+            "cStandard": "c17",
+            "cppStandard": "c++17",
+            "intelliSenseMode": "windows-msvc-x64"
+        }
+    ],
+    "version": 4
+}

burst_link_protocol-0.1.0/.vscode/launch.json

@@ -0,0 +1,25 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Python C++ Debug",
+      "type": "pythoncpp",
+      "request": "launch",
+      "pythonLaunchName": "Python: Current File",
+      "cppAttachName": "(Windows) Attach",
+    },
+    {
+      "name": "(Windows) Attach",
+      "type": "cppvsdbg",
+      "request": "attach",
+      "processId": ""
+    },
+    {
+      "name": "Python: Current File",
+      "type": "debugpy",
+      "request": "launch",
+      "program": "test/test.py",
+      "console": "integratedTerminal"
+    }
+  ]
+}

burst_link_protocol-0.1.0/.vscode/settings.json

@@ -0,0 +1,86 @@
+{
+    "python-envs.pythonProjects": [],
+    "files.associations": {
+        "algorithm": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "cctype": "cpp",
+        "charconv": "cpp",
+        "chrono": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "complex": "cpp",
+        "concepts": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "exception": "cpp",
+        "filesystem": "cpp",
+        "format": "cpp",
+        "forward_list": "cpp",
+        "functional": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "ios": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "iterator": "cpp",
+        "limits": "cpp",
+        "list": "cpp",
+        "locale": "cpp",
+        "map": "cpp",
+        "memory": "cpp",
+        "new": "cpp",
+        "optional": "cpp",
+        "ostream": "cpp",
+        "ratio": "cpp",
+        "set": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "stop_token": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "system_error": "cpp",
+        "thread": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp",
+        "unordered_map": "cpp",
+        "unordered_set": "cpp",
+        "utility": "cpp",
+        "variant": "cpp",
+        "vector": "cpp",
+        "xfacet": "cpp",
+        "xhash": "cpp",
+        "xiosbase": "cpp",
+        "xlocale": "cpp",
+        "xlocbuf": "cpp",
+        "xlocinfo": "cpp",
+        "xlocmes": "cpp",
+        "xlocmon": "cpp",
+        "xlocnum": "cpp",
+        "xloctime": "cpp",
+        "xmemory": "cpp",
+        "xstring": "cpp",
+        "xtr1common": "cpp",
+        "xtree": "cpp",
+        "xutility": "cpp",
+        "crc.h": "c",
+        "decoder.h": "c",
+        "stddef.h": "c",
+        "stdint.h": "c"
+    },
+    "python.testing.pytestArgs": [
+        "test"
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true
+}

burst_link_protocol-0.1.0/.vscode/tasks.json

@@ -0,0 +1,20 @@
+{
+	"version": "2.0.0",
+	"tasks": [
+		{
+			"type": "shell",
+			"label": "pip install",
+			"command": "pip",
+			"args": [
+				"install",
+				"--no-build-isolation",
+				"-ve",
+				"."
+			],	
+			"group": {
+				"kind": "build",
+				"isDefault": true
+			},
+		}
+	]
+}

burst_link_protocol-0.1.0/CMakeLists.txt

@@ -0,0 +1,90 @@
+cmake_minimum_required(VERSION 3.15...3.26)
+
+project(i_think_this_name_does_not_matter LANGUAGES C CXX)
+
+if (NOT SKBUILD)
+  message(WARNING "\
+  This CMake file is meant to be executed using 'scikit-build'. Running
+  it directly will almost certainly not produce the desired result. If
+  you are a user trying to install this package, please use the command
+  below, which will install all necessary build dependencies, compile
+  the package in an isolated environment, and then install it.
+  =====================================================================
+   $ pip install .
+  =====================================================================
+  If you are a software developer, and this is your own package, then
+  it is usually much more efficient to install the build dependencies
+  in your environment once and use the following command that avoids
+  a costly creation of a new virtual environment at every compilation:
+  =====================================================================
+   $ pip install nanobind scikit-build-core[pyproject]
+   $ pip install --no-build-isolation -ve .
+  =====================================================================
+  You may optionally add -Ceditable.rebuild=true to auto-rebuild when
+  the package is imported. Otherwise, you need to re-run the above
+  after editing C++ files.")
+endif()
+
+# Try to import all Python components potentially needed by nanobind
+find_package(Python 3.8
+  REQUIRED COMPONENTS Interpreter Development.Module
+  OPTIONAL_COMPONENTS Development.SABIModule)
+
+ if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
+  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
+endif()
+
+option(COVERAGE "Enable coverage reporting" ON)
+if(COVERAGE)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -g -fprofile-arcs -ftest-coverage")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0 -g -fprofile-arcs -ftest-coverage")
+endif()
+
+execute_process(
+    COMMAND "${Python_EXECUTABLE}" -m nanobind --cmake_dir
+    OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE NB_DIR)
+    list(APPEND CMAKE_PREFIX_PATH "${NB_DIR}")
+
+# Import nanobind through CMake's find_package mechanism
+find_package(nanobind CONFIG REQUIRED)
+
+# We are now ready to compile the actual extension module
+nanobind_add_module(
+  # Name of the extension
+  burst_interface_c
+
+  # Target the stable ABI for Python 3.12+, which reduces
+  # the number of binary wheels that must be built. This
+  # does nothing on older Python versions
+  STABLE_ABI
+
+  # Build libnanobind statically and merge it into the
+  # extension (which itself remains a shared library)
+  #
+  # If your project builds multiple extensions, you can
+  # replace this flag by NB_SHARED to conserve space by
+  # reusing a shared libnanobind across libraries
+  NB_STATIC
+
+  # Source code goes here
+  src/decoder.c
+  src/encoder.c
+  src/python_bindings.cpp
+  src/crc.c
+)
+
+nanobind_add_stub(
+  
+    burst_interface_c_stub
+    INSTALL_TIME
+    MODULE burst_interface_c
+    OUTPUT burst_interface_c.pyi
+    PYTHON_PATH $<TARGET_FILE_DIR:burst_interface_c>
+    DEPENDS burst_interface_c
+)
+
+target_include_directories(burst_interface_c PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src)
+
+# Install directive for scikit-build-core
+install(TARGETS burst_interface_c LIBRARY DESTINATION ".")

burst_link_protocol-0.1.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: burst-link-protocol
+Version: 0.1.0
+Summary: Binary Utility for Reliable Stream Transfer (BURST) is a library for encoding and decoding binary data streams into and from a byte stream.
+Author-Email: Floris vernieuwe <floris@vernieuwe.eu>
+Requires-Python: <4.0,>=3.10
+Requires-Dist: cobs<2.0.0,>=1.2.1
+Requires-Dist: numpy<3.0.0,>=2.2.3
+Requires-Dist: crc<8.0.0,>=7.1.0
+Requires-Dist: pytest<9.0.0,>=8.3.4
+Requires-Dist: pytest-cov<7.0.0,>=6.0.0
+Requires-Dist: pytest-benchmark<6.0.0,>=5.1.0
+Requires-Dist: scikit-build-core[pyproject]<0.11.0,>=0.10.7; extra == "dev"
+Requires-Dist: nanobind<3.0.0,>=2.5.0; extra == "dev"
+Requires-Dist: pytest<9.0.0,>=8.3.4; extra == "dev"
+Requires-Dist: pytest-cov<7.0.0,>=6.0.0; extra == "dev"
+Requires-Dist: pytest-benchmark<6.0.0,>=5.1.0; extra == "dev"
+Provides-Extra: dev

burst_link_protocol-0.1.0/README.md

@@ -0,0 +1,69 @@
+# BURST interface 
+Binary Utility for Reliable Stream Transfer (BURST) is a library for encoding and decoding binary data streams, a packet format.
+It combines a 16 bit checksum and cobs encoding to convert packets into a format that can be sent over a stream.
+
+This projects is written so it can be used both in python, c and c++ based project
+
+# Installation instuctions
+
+## As an user
+
+Simple installation
+```sh
+pip install -e .
+```
+
+## As a developer
+
+Fast build
+```sh
+pip install --no-build-isolation -ve .
+```
+
+Auto rebuild on run
+```sh
+pip install --no-build-isolation -Ceditable.rebuild=true -ve .
+```
+
+
+### Python Stub files generation
+
+They are generated automatically buy can also be generated 
+
+```
+python -m nanobind.stubgen -m nanobind_example_ext
+```
+
+# Publishing instructions
+
+```
+
+```
+
+# Test
+
+```sh
+pytest
+```
+
+# BURST protocol
+TODO
+* STAGE 1
+    * Convert cpp to c files [OK]
+    * Formalise naming [OK]
+    * Add c encode functions [OK]
+    * Test c encode functions [OK]
+    * Update README 
+    * Improve poetry.toml   [OK]
+
+
+* STAGE 2
+    * Add CI/CD on github to compile x86
+       * Fix dependencies once compilation succeeds
+    * Publish on pypi
+* STAGE 3
+    * Add a way to get C test coverage
+
+
+
+

burst_link_protocol-0.1.0/pyproject.toml

@@ -0,0 +1,56 @@
+[project]
+name = "burst-link-protocol"
+version = "0.1.0"  # Choose one version reference here
+description = "Binary Utility for Reliable Stream Transfer (BURST) is a library for encoding and decoding binary data streams into and from a byte stream."
+requires-python = ">=3.10,<4.0"
+authors = [
+  { name = "Floris vernieuwe", email = "floris@vernieuwe.eu" }
+]
+
+dependencies = [
+  "cobs>=1.2.1,<2.0.0",
+  "numpy>=2.2.3,<3.0.0",
+  "crc>=7.1.0,<8.0.0",
+  "pytest>=8.3.4,<9.0.0",
+  "pytest-cov>=6.0.0,<7.0.0",
+  "pytest-benchmark>=5.1.0,<6.0.0"
+  
+]
+
+
+[project.optional-dependencies]
+dev = [
+  "scikit-build-core[pyproject]>=0.10.7,<0.11.0",
+  "nanobind>=2.5.0,<3.0.0",
+  "pytest>=8.3.4,<9.0.0",
+  "pytest-cov>=6.0.0,<7.0.0",
+  "pytest-benchmark>=5.1.0,<6.0.0"
+]
+
+[build-system]
+requires = ["scikit-build-core>=0.10", "nanobind>=1.3.2"]
+build-backend = "scikit_build_core.build"
+
+[tool.scikit-build]
+minimum-version = "build-system.requires"
+cmake.build-type = "Debug"
+cmake.args = ["-DCMAKE_EXPORT_COMPILE_COMMANDS=ON -DCOVERAGE=ON"]
+build-dir = "build/{wheel_tag}"
+wheel.py-api = "cp312"
+
+
+
+[tool.cibuildwheel]
+# Necessary to see build output from the actual compilation
+build-verbosity = 1
+
+# Run pytest to ensure that the package was correctly built
+# test-command = "pytest test"
+# test-requires = "pytest"
+
+# Don't test Python 3.8 wheels on macOS/arm64
+test-skip="cp38-macosx_*:arm64"
+
+# Needed for full C++17 support
+[tool.cibuildwheel.macos.environment]
+MACOSX_DEPLOYMENT_TARGET = "10.14"

burst_link_protocol-0.1.0/src/burst_interface.h

@@ -0,0 +1,67 @@
+#ifndef BURST_INTERFACE_H
+#define BURST_INTERFACE_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#define COBS_DELIMITER 0x00
+#define COBS_MAX_CODE 0xFF
+
+// Status codes returned by the encoder.
+typedef enum
+{
+    BURST_DATA_CONSUMED,
+    BURST_PACKET_READY,
+    BURST_OVERFLOW_ERROR,
+    BURST_ENCODE_ERROR,
+    BURST_CRC_ERROR,
+    BURST_DECODE_ERROR
+} burst_status_t;
+
+typedef struct
+{
+    uint8_t *data;
+    size_t size;
+} burst_packet_t;
+
+typedef struct
+{
+    uint8_t *buffer;    // Output buffer for encoded packets.
+    size_t buffer_size; // Total size of the output buffer.
+    size_t out_head;    // Current offset (number of bytes written).
+} burst_encoder_t;
+
+typedef struct
+{
+    uint8_t *buffer;    // Output buffer for decoded data.
+    size_t buffer_size; // Size of the output buffer.
+    size_t out_head;    // Current count of decoded bytes stored.
+
+    uint8_t current_code;    // Current block’s code byte; 0 indicates a new block is
+                             // expected.
+    uint8_t bytes_remaining; // Number of data bytes left to copy for the current
+                             // block.
+    bool pending_zero;       // true if a zero should be inserted before starting the
+                             // next block.
+
+    bool finished; // true if the packet is complete and available in the buffer
+} burst_decoder_t;
+
+
+// Encoder
+void burst_encoder_init(burst_encoder_t *ctx, uint8_t *buffer, size_t size);
+burst_status_t burst_encoder_add_packet(burst_encoder_t *ctx, const uint8_t *data, size_t size);
+burst_packet_t burst_encoder_flush(burst_encoder_t *ctx);
+
+
+// Decoder
+void burst_decoder_init(burst_decoder_t *ctx, uint8_t *buffer, size_t size);
+burst_status_t bust_decoder_add_data(burst_decoder_t *ctx, const uint8_t *data, size_t size,
+                                     size_t *consumed_bytes);
+void burst_decoder_reset(burst_decoder_t *ctx);
+burst_status_t burst_decoder_add_byte(burst_decoder_t *ctx, uint8_t byte);
+
+burst_packet_t burst_decoder_get_packet(burst_decoder_t *ctx);
+
+#endif // ENCODER_H

burst_link_protocol-0.1.0/src/burst_link_protocol/__init__.py

@@ -0,0 +1,4 @@
+from burst_interface_c import  BurstInterfaceC
+from .main import BurstInterfacePy
+
+__all__ = ["BurstInterfaceC", "BurstInterfacePy"]

burst_link_protocol-0.1.0/src/burst_link_protocol/main.py

@@ -0,0 +1,41 @@
+from cobs import cobs
+from crc import Calculator,Crc16
+
+crc = Calculator(Crc16.IBM_3740)
+
+class BurstInterfacePy:
+    buffer = b""
+
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def crc16( data: bytes) -> bytes:
+        return crc.checksum(data).to_bytes(2, "big")
+    
+
+    @staticmethod
+    def encode_packet(packet: bytes) -> bytes:
+        packet_with_crc = packet + BurstInterfacePy.crc16(packet)
+        return cobs.encode(packet_with_crc) + b"\x00"
+
+    @staticmethod
+    def decode_packet(packet: bytes) -> bytes:
+        # decode and check crc
+        decoded = cobs.decode(packet)
+
+        if BurstInterfacePy.crc16(decoded[:-2]) != decoded[-2:]:
+            raise ValueError("CRC mismatch")
+
+        return decoded[:-2]
+
+    def encode(self, packets: list[bytes]) -> bytes:
+        return b"".join([self.encode_packet(packet) for packet in packets])
+
+    def decode(self, steam: bytes) -> list[bytes]:
+        self.buffer += steam
+        separated_packets = self.buffer.split(b"\x00")
+        # Add last packet to buffer
+        self.buffer = separated_packets.pop()
+        return [self.decode_packet(packet) for packet in separated_packets]
+

burst_link_protocol-0.1.0/src/crc.c

@@ -0,0 +1,20 @@
+#include <stddef.h>
+#include <stdint.h>
+
+/*
+ * Calculate CRC16-CCITT (polynomial 0x1021, initial value 0xFFFF) over
+ * the provided data.
+ */
+uint16_t crc16_ccitt(const uint8_t *data, size_t length) {
+  uint16_t crc = 0xFFFF;
+  for (size_t i = 0; i < length; i++) {
+    crc ^= ((uint16_t)data[i]) << 8;
+    for (int j = 0; j < 8; j++) {
+      if (crc & 0x8000)
+        crc = (crc << 1) ^ 0x1021;
+      else
+        crc <<= 1;
+    }
+  }
+  return crc;
+}

burst_link_protocol-0.1.0/src/crc.h

@@ -0,0 +1,4 @@
+#include <stdint.h>
+
+uint16_t crc16_ccitt(const uint8_t *data, size_t length);
+#define CRC_SIZE sizeof(uint16_t)

burst_link_protocol-0.1.0/src/decoder.c

@@ -0,0 +1,150 @@
+#include "burst_interface.h"
+#include "crc.h"
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+
+void burst_decoder_init(burst_decoder_t *ctx, uint8_t *buffer, size_t size)
+{
+  ctx->buffer = buffer;
+  ctx->buffer_size = size;
+  burst_decoder_reset(ctx);
+}
+
+burst_status_t bust_decoder_add_data(burst_decoder_t *ctx, const uint8_t *data, size_t size,
+                             size_t *consumed_bytes)
+{
+  // If the decoder was finished, reset it.
+  if (ctx->finished)
+  {
+    burst_decoder_reset(ctx);
+  }
+
+  for (size_t i = 0; i < size; i++)
+  {
+    uint8_t byte = data[i];
+    (*consumed_bytes)++;
+
+    burst_status_t result = burst_decoder_add_byte(ctx, byte);
+
+    if (result != BURST_DATA_CONSUMED)
+    {
+      ctx->finished = true;
+      return result;
+    }
+  }
+  return BURST_DATA_CONSUMED;
+}
+void burst_decoder_reset(burst_decoder_t *ctx)
+{
+  ctx->out_head = 0;
+  ctx->current_code = 0;
+  ctx->bytes_remaining = 0;
+  ctx->pending_zero = false;
+  ctx->finished = false;
+}
+
+burst_status_t burst_decoder_complete_packet(burst_decoder_t *ctx)
+{
+  // Ensure we have at least two bytes for the CRC.
+  if (ctx->out_head < CRC_SIZE)
+  {
+    return BURST_CRC_ERROR;
+  }
+
+  // Calculate the CRC over the packet data excluding the last two CRC bytes.
+  uint16_t computed_crc = crc16_ccitt(ctx->buffer, ctx->out_head - CRC_SIZE);
+
+  // Extract the received CRC from the last two bytes (big-endian).
+  uint16_t received_crc =
+      ((uint16_t)ctx->buffer[ctx->out_head - CRC_SIZE] << 8) |
+      ctx->buffer[ctx->out_head - 1];
+
+  // Check if the CRCs match.
+  if (computed_crc != received_crc)
+  {
+    return BURST_CRC_ERROR;
+  }
+
+  // CRC check passed, we can remove it from the packet.
+  ctx->out_head -= CRC_SIZE;
+  return BURST_PACKET_READY;
+}
+
+// If byte is a delimiter but a block is not complete, return COBS_DECODE_ERROR
+// If the buffer is full, return COBS_OVERFLOW_ERROR
+// If the byte is consumed, but the packet is not complete, return COBS_DATA_CONSUMED
+// If the packet is complete, return COBS_PACKET_READY
+burst_status_t burst_decoder_add_byte(burst_decoder_t *ctx, uint8_t byte)
+{
+    // Check if there is space for more data.
+    if (ctx->out_head >= ctx->buffer_size) {
+        return BURST_OVERFLOW_ERROR;
+    }
+    
+    // If the byte is a delimiter, decide if it terminates the packet.
+    if (byte == COBS_DELIMITER) {
+        // If in the middle of a block, a delimiter is not allowed.
+        if (ctx->current_code != 0) {
+            return BURST_DECODE_ERROR;
+        }
+        // Otherwise, the packet is complete.
+        return burst_decoder_complete_packet(ctx);
+    }
+    
+    // If a zero is pending from a previous block, insert it now.
+    if (ctx->pending_zero) {
+        if (ctx->out_head >= ctx->buffer_size) {
+            return BURST_OVERFLOW_ERROR;
+        }
+        ctx->buffer[ctx->out_head++] = COBS_DELIMITER;
+        ctx->pending_zero = false;
+        // Now, treat the current byte as a new block code.
+        ctx->current_code = byte;
+        ctx->bytes_remaining = (byte > 0 ? byte - 1 : 0);
+        return BURST_DATA_CONSUMED;
+    }
+    
+    // If not currently in a block, this byte is the new block code.
+    if (ctx->current_code == 0) {
+        ctx->current_code = byte;
+        ctx->bytes_remaining = (byte > 0 ? byte - 1 : 0);
+        return BURST_DATA_CONSUMED;
+    }
+    
+    // Otherwise, we are in the middle of a block so treat the byte as data.
+    ctx->buffer[ctx->out_head++] = byte;
+    if (ctx->bytes_remaining > 0) {
+        ctx->bytes_remaining--;
+    }
+    
+    // When the block is complete...
+    if (ctx->bytes_remaining == 0) {
+        // If the block's code is less than COBS_MAX_CODE, a zero is pending.
+        if (ctx->current_code < COBS_MAX_CODE) {
+            ctx->pending_zero = true;
+        }
+        ctx->current_code = 0;
+    }
+    
+    return BURST_DATA_CONSUMED;
+}
+
+
+burst_packet_t burst_decoder_get_packet(burst_decoder_t *ctx)
+{
+
+  if (!ctx->finished)
+  {
+    burst_packet_t packet;
+    packet.data = NULL;
+    packet.size = 0;
+    return packet;
+  }
+
+  burst_packet_t packet;
+  packet.data = ctx->buffer;
+  packet.size = ctx->out_head;
+  return packet;
+}

burst_link_protocol-0.1.0/src/encoder.c

@@ -0,0 +1,91 @@
+#include "burst_interface.h"
+#include "crc.h"  // Assumes crc16_ccitt() is available.
+#include <stddef.h>
+#include <stdint.h>
+
+// COBS encoding with CRC appending.
+// The input to be encoded is the raw packet data followed by the two CRC bytes.
+// The algorithm works by maintaining a "code" (the count of nonzero bytes)
+// and inserting that count at the start of each block. When a zero is encountered
+// (or when the block length reaches COBS_MAX_CODE) the block is terminated.
+burst_status_t burst_encoder_add_packet(burst_encoder_t *ctx, const uint8_t *data, size_t size)
+{
+    // Compute the CRC over the raw packet data.
+    uint16_t crc = crc16_ccitt(data, size);
+    uint8_t crc_high = (crc >> 8) & 0xFF;
+    uint8_t crc_low  = crc & 0xFF;
+    // The total number of bytes to encode: raw data + 2 bytes of CRC.
+    size_t total_bytes = size + CRC_SIZE;
+
+    // Initialize COBS block state.
+    uint8_t code = 1; // Code value starts at 1.
+    // Reserve space for the code byte.
+    if (ctx->out_head >= ctx->buffer_size)
+        return BURST_OVERFLOW_ERROR;
+    size_t code_index = ctx->out_head;
+    ctx->buffer[ctx->out_head++] = 0; // Placeholder for the code.
+
+    // Process each byte from the raw data and then the CRC.
+    for (size_t i = 0; i < total_bytes; i++) {
+        uint8_t byte;
+        if (i < size)
+            byte = data[i];
+        else if (i == size)
+            byte = crc_high;
+        else // i == size + 1
+            byte = crc_low;
+
+        if (byte == 0) {
+            // Write the current code to the reserved position.
+            ctx->buffer[code_index] = code;
+            // Start a new block.
+            code = 1;
+            if (ctx->out_head >= ctx->buffer_size)
+                return BURST_OVERFLOW_ERROR;
+            code_index = ctx->out_head;
+            ctx->buffer[ctx->out_head++] = 0; // Reserve placeholder for new code.
+        } else {
+            // Append the nonzero byte.
+            if (ctx->out_head >= ctx->buffer_size)
+                return BURST_OVERFLOW_ERROR;
+            ctx->buffer[ctx->out_head++] = byte;
+            code++;
+            // If the maximum code value is reached, finish the block.
+            if (code == COBS_MAX_CODE) {
+                ctx->buffer[code_index] = code;
+                code = 1;
+                if (ctx->out_head >= ctx->buffer_size)
+                    return BURST_OVERFLOW_ERROR;
+                code_index = ctx->out_head;
+                ctx->buffer[ctx->out_head++] = 0; // Reserve new placeholder.
+            }
+        }
+    }
+    
+    // Finalize the last block.
+    ctx->buffer[code_index] = code;
+    
+    // Append the packet delimiter.
+    if (ctx->out_head >= ctx->buffer_size)
+         return BURST_OVERFLOW_ERROR;
+    ctx->buffer[ctx->out_head++] = COBS_DELIMITER;
+    
+    return BURST_PACKET_READY;
+}
+
+void burst_encoder_init(burst_encoder_t *ctx, uint8_t *buffer, size_t size)
+{
+    ctx->buffer = buffer;
+    ctx->buffer_size = size;
+    ctx->out_head = 0;
+}
+
+burst_packet_t burst_encoder_flush(burst_encoder_t *ctx)
+{
+    burst_packet_t packet;
+    packet.data = ctx->buffer;
+    packet.size = ctx->out_head;
+    // Reset the encoder context for the next use.
+    ctx->out_head = 0;
+    return packet;
+}

burst_link_protocol-0.1.0/src/python_bindings.cpp

@@ -0,0 +1,80 @@
+#include <nanobind/nanobind.h>
+extern "C"
+{
+#include <burst_interface.h>
+}
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+struct BurstInterface
+{
+    burst_decoder_t decoder;
+    uint8_t decoder_buffer[1024] = {0};
+    burst_encoder_t encoder;
+    uint8_t encoder_buffer[1024] = {0};
+
+    BurstInterface()
+    {
+        burst_decoder_init(&decoder, decoder_buffer, sizeof(decoder_buffer));
+        burst_encoder_init(&encoder, encoder_buffer, sizeof(encoder_buffer));
+    }
+
+    nb::list decode(nb::bytes data, bool fail_on_crc_error = false)
+    {
+        nb::list result;
+        uint8_t *data_ptr = (uint8_t *)data.data();
+        size_t data_size = data.size();
+
+        size_t bytes_consumed = 0;
+        while (bytes_consumed < data_size)
+        {
+            burst_status_t status = bust_decoder_add_data(&decoder, data_ptr + bytes_consumed, data_size - bytes_consumed, &bytes_consumed);
+
+            if (status == BURST_PACKET_READY)
+            {
+                burst_packet_t packet = burst_decoder_get_packet(&decoder);
+                nb::bytes packet_bytes(reinterpret_cast<const char *>(packet.data), packet.size);
+                result.append(packet_bytes);
+            }
+
+            if (fail_on_crc_error)
+            {
+                if (status == BURST_CRC_ERROR)
+                {
+                    throw std::runtime_error("CRC error");
+                }
+                if (status == BURST_DECODE_ERROR)
+                {
+                    throw std::runtime_error("Decode error");
+                }
+                if (status == BURST_OVERFLOW_ERROR)
+                {
+                    throw std::runtime_error("Overflow error");
+                }
+            }
+        }
+        return result;
+    }
+
+    nb::bytes encode(nb::list data)
+    {
+        for (size_t i = 0; i < data.size(); i++)
+        {
+            nb::bytes data_bytes = data[i];
+            burst_encoder_add_packet(&encoder, (uint8_t *)data_bytes.data(), data_bytes.size());
+        }
+        // flush the encoder
+        burst_packet_t packet = burst_encoder_flush(&encoder);
+        return nb::bytes(reinterpret_cast<const char *>(packet.data), packet.size);
+    }
+};
+
+NB_MODULE(burst_interface_c, m)
+{
+
+    nb::class_<BurstInterface>(m, "BurstInterfaceC")
+        .def(nb::init<>())
+        .def("decode", &BurstInterface::decode, "data"_a, "fail_on_crc_error"_a = false)
+        .def("encode", &BurstInterface::encode, "packets"_a);
+}

burst_link_protocol-0.1.0/test/test_c_validation.py

@@ -0,0 +1,52 @@
+
+from burst_link_protocol import BurstInterfacePy,BurstInterfaceC
+import pytest
+import numpy as np
+
+def test_c_decoder_python():
+    python_interface =  BurstInterfacePy()
+    c_interface =  BurstInterfaceC()
+
+    packets = [b"Hello, world!", b"Goodbye, world!"]
+
+    data = python_interface.encode(packets)
+    decoded = c_interface.decode(data)
+    print(decoded)
+    assert packets == decoded
+
+def test_python_crc_validation():
+    interface =  BurstInterfacePy()
+    packets = [b"Hello, world!", b"Goodbye, world!"]
+
+    data = bytearray(interface.encode(packets))
+
+    for i in range( len(data)):
+        c_interface =  BurstInterfaceC()
+
+        data_copy = data.copy()
+
+        # modify byte x
+        data_copy[i] = (data_copy[i] + 1) % 256
+        with pytest.raises(Exception):
+            decoded = c_interface.decode(bytes(data_copy),fail_on_crc_error=True)
+            print(decoded)
+            assert len(decoded) == len(packets), f"Expected {len(packets)} packets, got {len(decoded)}"
+
+def test_max_size_error():
+    interface =  BurstInterfacePy()
+    c_interface =  BurstInterfaceC()
+    packets = np.random.bytes(1500)
+    with pytest.raises(Exception):
+        data = c_interface.decode(interface.encode([packets]),fail_on_crc_error=True)
+    
+def test_encoding():
+    interface =  BurstInterfacePy()
+    c_interface =  BurstInterfaceC()
+    packets = [b"Hello, world!", b"Goodbye, world!"]
+
+    assert interface.encode(packets) == c_interface.encode(packets)
+
+# if __name__ == "__main__":
+#     # test_c_decoder_python()
+#     # test_python_crc_validation()
+#     # max_size_error()

burst_link_protocol-0.1.0/test/test_python_validation.py

@@ -0,0 +1,27 @@
+
+from burst_link_protocol import BurstInterfacePy
+import pytest
+
+def test_python():
+    interface =  BurstInterfacePy()
+    packets = [b"Hello, world!", b"Goodbye, world!"]
+
+    data = interface.encode(packets)
+    decoded = interface.decode(data)
+    assert packets == decoded
+
+def test_python_crc_validation():
+    interface =  BurstInterfacePy()
+    packets = [b"Hello, world!", b"Goodbye, world!"]
+
+    data = bytearray(interface.encode(packets))
+
+    for i in range( len(data)):
+        data_copy = data.copy()
+
+        # modify byte x
+        data_copy[i] = (data_copy[i] + 1) % 256
+        with pytest.raises(Exception):
+            decoded = interface.decode(bytes(data_copy))
+            print(decoded)
+            assert len(decoded) == len(packets), f"Expected {len(packets)} packets, got {len(decoded)}"

burst_link_protocol-0.1.0/test/test_speed.py

@@ -0,0 +1,20 @@
+
+from burst_link_protocol import BurstInterfacePy,BurstInterfaceC
+import pytest
+import numpy as np
+
+def prepare_packets(packet_size:int) -> bytes:
+    python_interface =  BurstInterfacePy()
+    return python_interface.encode([np.zeros(packet_size).tobytes()])
+
+
+
+@pytest.mark.parametrize("n", [1, 10, 100, 1000])
+def test_performance_c(benchmark, n):
+    c_interface =  BurstInterfaceC()
+    benchmark(c_interface.decode, prepare_packets(n))
+
+@pytest.mark.parametrize("n", [1, 10, 100, 1000])
+def test_performance_python(benchmark, n):
+    c_interface =  BurstInterfacePy()
+    benchmark(c_interface.decode, prepare_packets(n))