burst-link-protocol 1.0.4__tar.gz → 1.1.4__tar.gz

{burst_link_protocol-1.0.4 → burst_link_protocol-1.1.4}/.vscode/c_cpp_properties.json

@@ -4,7 +4,7 @@
             "name": "Win32",
             "includePath": [
                 "${workspaceFolder}/**",
-                "${workspaceFolder}/.venv/Lib/site-packages/nanobind/include/nanobind", //To be fixed
+                "${workspaceFolder/.venv/lib/python3.13/site-packages/nanobind/include/nanobind", //To be fixed
                 "${env:PYTHON_INCLUDE}"
             ],
             "defines": [

{burst_link_protocol-1.0.4 → burst_link_protocol-1.1.4}/.vscode/tasks.json

@@ -4,8 +4,9 @@
 		{
 			"type": "shell",
 			"label": "pip install",
-			"command": "pip",
+			"command": "uv",
 			"args": [
+				"pip",
 				"install",
 				"--no-build-isolation",
 				"-ve",

{burst_link_protocol-1.0.4 → burst_link_protocol-1.1.4}/CMakeLists.txt

@@ -1,8 +1,33 @@
 cmake_minimum_required(VERSION 3.15...3.26)
+# If espidf is reading this CMakeLists.txt, skip so its ignored
 
-project(i_think_this_name_does_not_matter LANGUAGES C CXX)
 
-if (NOT SKBUILD)
+# If ESP-IDF is reading this CMakeLists.txt, register it as an ESP-IDF component
+if(DEFINED ENV{IDF_PATH})
+  idf_component_register(SRCS
+    "src/burst/burst_decoder.c"
+    "src/burst/burst_encoder.c"
+    "src/burst/burst_generic.c"
+    INCLUDE_DIRS "src")
+
+  return()
+endif()
+
+# If Zephyr is reading this CMakeLists.txt, register it as a Zephyr module
+if(Zephyr_FOUND)
+  zephyr_library_named(burst-link-protocol)
+  zephyr_library_sources(
+    "src/burst/burst_decoder.c"
+    "src/burst/burst_encoder.c"
+    "src/burst/burst_generic.c"
+  )
+
+  target_include_directories(burst-link-protocol PUBLIC src)
+  return()
+endif()
+
+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
@@ -30,30 +55,34 @@ find_package(Python 3.8
   REQUIRED COMPONENTS Interpreter Development.Module
   OPTIONAL_COMPONENTS Development.SABIModule)
 
- if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+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")
+  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}")
+  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
 
+  # domain name
+  NB_DOMAIN burst_interface_domain
+
   # 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
@@ -68,23 +97,23 @@ nanobind_add_module(
   NB_STATIC
 
   # Source code goes here
-  src/decoder.c
-  src/encoder.c
+  src/burst/burst_decoder.c
+  src/burst/burst_encoder.c
+  src/burst/burst_generic.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
+
+  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 ".")
+install(TARGETS burst_interface_c LIBRARY DESTINATION ".")

{burst_link_protocol-1.0.4 → burst_link_protocol-1.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: burst-link-protocol
-Version: 1.0.4
+Version: 1.1.4
 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>
 License-File: LICENSE
@@ -14,6 +14,8 @@ 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>=0.10.7
 Requires-Dist: nanobind>=2.5.0
+Requires-Dist: pyserial>=3.5
+Requires-Dist: janus>=2.0.0
 Provides-Extra: dev
 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"
@@ -61,6 +63,7 @@ uv pip install --reinstall --no-build-isolation -ve .
 Auto rebuild on run
 ```sh
 uv pip install --reinstall --no-build-isolation -Ceditable.rebuild=true -ve .
+# or 
 pip install --no-build-isolation -Ceditable.rebuild=true -ve .
 ``` 
 

{burst_link_protocol-1.0.4 → burst_link_protocol-1.1.4}/README.md

@@ -37,6 +37,7 @@ uv pip install --reinstall --no-build-isolation -ve .
 Auto rebuild on run
 ```sh
 uv pip install --reinstall --no-build-isolation -Ceditable.rebuild=true -ve .
+# or 
 pip install --no-build-isolation -Ceditable.rebuild=true -ve .
 ``` 
 

{burst_link_protocol-1.0.4 → burst_link_protocol-1.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "burst-link-protocol"
-version = "1.0.4"  # Choose one version reference here
+version = "1.1.4"  # 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 = [
@@ -16,6 +16,8 @@ dependencies = [
   "pytest-benchmark>=5.1.0,<6.0.0",
   "scikit-build-core>=0.10.7",
   "nanobind>=2.5.0",
+  "pyserial>=3.5",
+  "janus>=2.0.0",
 ]
 license-files = ["LICENSE"]
 

burst_link_protocol-1.0.4/src/decoder.c → burst_link_protocol-1.1.4/src/burst/burst_decoder.c

@@ -1,11 +1,10 @@
+#include "burst_decoder.h"
+
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
 
-#include "burst_interface.h"
-#include "crc.h"
-
 void burst_decoder_init(burst_decoder_t *ctx, uint8_t *buffer, size_t size) {
 	ctx->buffer = buffer;
 	ctx->buffer_size = size;
@@ -54,7 +53,7 @@ burst_status_t burst_decoder_complete_packet(burst_decoder_t *ctx) {
 	}
 
 	// 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);
+	uint16_t computed_crc = burst_crc16(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];
@@ -82,6 +81,7 @@ burst_status_t burst_decoder_add_byte(burst_decoder_t *ctx, uint8_t byte) {
 				return burst_decoder_complete_packet(ctx);
 			}
 
+			/* fallthrough */
 		case COBS_DECODE_READ_CODE:
 
 			// If last code was 0xF, its a overhead byte
@@ -119,6 +119,9 @@ burst_status_t burst_decoder_add_byte(burst_decoder_t *ctx, uint8_t byte) {
 
 			return BURST_DATA_CONSUMED;
 	}
+
+	// This should never happen, but some compilers are dumb
+	return BURST_DECODE_ERROR;
 }
 
 burst_packet_t burst_decoder_get_packet(burst_decoder_t *ctx) {
@@ -134,3 +137,57 @@ burst_packet_t burst_decoder_get_packet(burst_decoder_t *ctx) {
 	packet.size = ctx->out_head;
 	return packet;
 }
+
+void burst_managed_decoder_init(burst_managed_decoder_t *burst_managed_decoder, uint8_t *buffer, size_t size, burst_managed_decoder_callback_t callback,
+                                void *user_data) {
+	burst_managed_decoder->callback_function = callback;
+	burst_managed_decoder->user_data = user_data;
+	burst_decoder_init(&burst_managed_decoder->decoder, buffer, size);
+}
+
+int burst_managed_decoder_handle_data(burst_managed_decoder_t *burst_managed_decoder, const uint8_t *data, size_t len) {
+	if (len == 0) {
+		return 0;  // No data to process
+	}
+
+	burst_managed_decoder->statistics.bytes_ingested += len;
+	size_t bytes_consumed = 0;
+	while (bytes_consumed < len) {
+		uint8_t *data_ptr = (uint8_t *)data + bytes_consumed;
+		size_t data_len = len - bytes_consumed;
+
+		burst_status_t status = bust_decoder_add_data(&burst_managed_decoder->decoder, data_ptr, data_len, &bytes_consumed);
+
+		switch (status) {
+			case BURST_PACKET_READY: {
+				burst_packet_t packet = burst_decoder_get_packet(&burst_managed_decoder->decoder);
+
+				if (packet.size > 0 && burst_managed_decoder->callback_function != NULL) {
+					// Call the callback function with the received data
+					burst_managed_decoder->callback_function(packet.data, packet.size, burst_managed_decoder->user_data);
+				}
+
+				burst_managed_decoder->statistics.bytes_processed += packet.size;
+				burst_managed_decoder->statistics.packets_processed++;
+
+				continue;
+			}
+
+			case BURST_CRC_ERROR:
+				burst_managed_decoder->statistics.crc_errors++;
+				continue;
+
+			case BURST_DECODE_ERROR:
+				burst_managed_decoder->statistics.decode_errors++;
+				continue;
+
+			case BURST_OVERFLOW_ERROR:
+				burst_managed_decoder->statistics.overflow_errors++;
+				continue;
+
+			default:
+				continue;
+		}
+	}
+	return bytes_consumed;
+}

burst_link_protocol-1.1.4/src/burst/burst_decoder.h

@@ -0,0 +1,56 @@
+#ifndef BURST_DECODER_H
+#define BURST_DECODER_H
+
+#include <burst/burst_generic.h>
+#include <stdbool.h>
+typedef int (*burst_managed_decoder_callback_t)(const uint8_t *data, size_t length, void *user_data);
+
+typedef struct
+{
+	uint32_t bytes_ingested;     // Total number of bytes ingested
+	uint32_t bytes_processed;    // Total number of bytes after processing
+	uint32_t packets_processed;  // Successfully decoded packets
+
+    // Error statistics
+    uint32_t crc_errors;
+    uint32_t overflow_errors;
+    uint32_t decode_errors;
+} burst_decoder_statistics_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.
+    enum cobs_decode_inc_state
+    {
+        COBS_DECODE_READ_CODE,
+        COBS_DECODE_RUN,
+        COBS_DECODE_FINISH_RUN
+    } state;
+    uint8_t block, code;
+
+    bool finished; // true if the packet is complete and available in the buffer
+
+    burst_decoder_statistics_t statistics; // Statistics for the decoder
+
+} burst_decoder_t;
+
+typedef struct
+{
+    burst_decoder_t decoder;               // Decoder instance
+    burst_decoder_statistics_t statistics; // Statistics for the decoder
+    burst_managed_decoder_callback_t callback_function; // Callback function for decoded packets
+    void *user_data;                       // User data for the callback function
+} burst_managed_decoder_t;
+
+void burst_decoder_init(burst_decoder_t *ctx, uint8_t *buffer, size_t size);
+void burst_decoder_reset(burst_decoder_t *ctx);
+burst_status_t burst_decoder_add_byte(burst_decoder_t *ctx, uint8_t byte);
+burst_status_t bust_decoder_add_data(burst_decoder_t *ctx, const uint8_t *data, size_t size, size_t *consumed_bytes);
+burst_packet_t burst_decoder_get_packet(burst_decoder_t *ctx);
+
+void burst_managed_decoder_init(burst_managed_decoder_t *burst_managed_decoder, uint8_t *buffer, size_t size, burst_managed_decoder_callback_t callback, void *user_data);
+int burst_managed_decoder_handle_data(burst_managed_decoder_t *burst_managed_decoder, const uint8_t *data, size_t len);
+
+#endif // BURST_DECODER_H

burst_link_protocol-1.1.4/src/burst/burst_encoder.c

@@ -0,0 +1,120 @@
+#include "burst_encoder.h"
+
+#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 = burst_crc16(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;
+}
+
+void burst_managed_encoder_init(burst_managed_encoder_t *burst_managed_encoder, uint8_t *buffer, size_t size) {
+	burst_encoder_init(&burst_managed_encoder->encoder, buffer, size);
+}
+
+int burst_managed_encoder_add_packet(burst_managed_encoder_t *burst_managed_encoder, const uint8_t *data, size_t len) {
+
+	if (len == 0) {
+		return 0;  // No data to process
+	}
+
+	burst_managed_encoder->statistics.bytes_ingested += len;
+
+	burst_status_t status = burst_encoder_add_packet(&burst_managed_encoder->encoder, data, len);
+
+	if (status == BURST_OVERFLOW_ERROR) {
+		// Overflow error, reset the encoder and return an error
+		burst_managed_encoder->statistics.overflow_errors++;
+		burst_managed_encoder->statistics.bytes_discarted += burst_encoder_flush(&burst_managed_encoder->encoder).size;
+
+		return -1;
+	}
+
+	burst_managed_encoder->statistics.packets_processed++;
+	return 0;
+}
+
+int burst_managed_encoder_free_space(burst_managed_encoder_t *burst_managed_encoder) {
+	return burst_managed_encoder->encoder.buffer_size - burst_managed_encoder->encoder.out_head;
+}
+
+burst_packet_t burst_managed_encoder_flush(burst_managed_encoder_t *burst_managed_encoder) {
+	burst_packet_t packet = burst_encoder_flush(&burst_managed_encoder->encoder);
+	burst_managed_encoder->statistics.bytes_processed += packet.size;
+	return packet;
+}

burst_link_protocol-1.1.4/src/burst/burst_encoder.h

@@ -0,0 +1,38 @@
+#ifndef BURST_ENCODER_H
+#define BURST_ENCODER_H
+
+#include <burst/burst_generic.h>
+#include <stdint.h>
+
+typedef struct {
+	uint32_t bytes_ingested;     // Total number of bytes ingested
+	uint32_t bytes_processed;    // Total number of bytes after processing
+	uint32_t packets_processed;  // Successfully decoded packets
+
+	// Error statistics
+	uint32_t overflow_errors;
+	uint32_t bytes_discarted;  // Total number of bytes discarded
+
+} burst_encoder_statistics_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 {
+	burst_encoder_t encoder;                // Decoder instance
+	burst_encoder_statistics_t statistics;  // Statistics for the decoder
+} burst_managed_encoder_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);
+void burst_managed_encoder_init(burst_managed_encoder_t *burst_managed_encoder, uint8_t *buffer, size_t size);
+int burst_managed_encoder_add_packet(burst_managed_encoder_t *burst_managed_encoder, const uint8_t *data, size_t len);
+burst_packet_t burst_managed_encoder_flush(burst_managed_encoder_t *burst_managed_encoder);
+int burst_managed_encoder_free_space(burst_managed_encoder_t *burst_managed_encoder);
+
+#endif  // BURST_ENCODER_H

burst_link_protocol-1.0.4/src/crc.c → burst_link_protocol-1.1.4/src/burst/burst_generic.c

@@ -5,7 +5,7 @@
  * 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 burst_crc16(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;

burst_link_protocol-1.1.4/src/burst/burst_generic.h

@@ -0,0 +1,30 @@
+
+#ifndef BURST_GENERIC_H
+#define BURST_GENERIC_H
+#include <stdint.h>
+#include <stddef.h>
+
+// 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;
+
+#define COBS_DELIMITER 0x00
+#define COBS_MAX_CODE 0xFF
+#define CRC_SIZE sizeof(uint16_t)
+
+uint16_t burst_crc16(const uint8_t *data, size_t length);
+
+#endif // BURST_GENERIC_H

burst_link_protocol-1.1.4/src/burst_link_protocol/__init__.py

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

burst_link_protocol-1.1.4/src/burst_link_protocol/serial_burst_interface.py

@@ -0,0 +1,233 @@
+from burst_interface_c import  BurstInterfaceC
+import serial
+import time
+import threading
+import asyncio
+import janus
+from pydantic import BaseModel, Field
+
+def to_si(value: float, suffix: str) -> str:
+    """
+    Convert a value to a string with SI suffix.
+    """
+    if value == 0:
+        return "0"
+    elif value < 1e-3:
+        return f"{value:.2f} {suffix}"
+    elif value < 1e3:
+        return f"{value:.2f} {suffix}"
+    elif value < 1e6:
+        return f"{value / 1e3:.2f} k{suffix}"
+    elif value < 1e9:
+        return f"{value / 1e6:.2f} M{suffix}"
+    else:
+        return f"{value / 1e9:.2f} G{suffix}"
+
+
+class BurstSerialStatistics(BaseModel):
+    last_update_timestamp: float = Field(default_factory=time.time)
+
+    bytes_handled: int = 0
+    bytes_processed: int = 0
+    packets_processed: int = 0
+    crc_errors: int = 0
+    overflow_errors: int = 0
+    decode_errors: int = 0
+
+    handled_bytes_per_second: float = 0
+    processed_bytes_per_second: float = 0
+    processed_packets_per_second: float = 0
+
+    def update(
+        self,
+        bytes_handled,
+        bytes_processed,
+        packets_processed,
+        crc_errors,
+        overflow_errors,
+        decode_errors,
+    ):
+
+        now = time.time()
+        if now - self.last_update_timestamp > 1:
+            delta_time = now - self.last_update_timestamp
+            self.last_update_timestamp = now
+
+            self.handled_bytes_per_second = (
+                (bytes_handled - self.bytes_handled) / delta_time
+            )
+            self.processed_bytes_per_second = (
+                (bytes_processed - self.bytes_processed) / delta_time
+            )
+            self.processed_packets_per_second = (
+                (packets_processed - self.packets_processed) / delta_time
+            )
+
+            self.bytes_handled = bytes_handled
+            self.bytes_processed = bytes_processed
+            self.packets_processed = packets_processed
+            self.crc_errors = crc_errors
+            self.overflow_errors = overflow_errors
+            self.decode_errors = decode_errors
+
+        return self
+
+    def __str__(self):
+        return (
+            f"Byte Raw: {to_si(self.bytes_handled, 'B')} ({to_si(self.handled_bytes_per_second*8, 'bps')}), "
+            f"Bytes processed: {to_si(self.bytes_processed, 'B')} ({to_si(self.processed_bytes_per_second*8, 'bps')}), "
+            f"Packets processed: {self.packets_processed} ({to_si(self.processed_packets_per_second, 'packets/s')}), "
+            f"Errors (CRC: {self.crc_errors}, Overflow: {self.overflow_errors}, Decode: {self.decode_errors})"
+        )
+
+class SerialBurstInterface:
+    debug_timings = False
+    debug_io = False
+
+    kill = False
+    block_size = 1000
+    RATE_CHECK_INTERVAL = 1
+
+    interface: BurstInterfaceC
+    last_rate_timestamp: float = 0
+
+    statitsics: BurstSerialStatistics
+
+    @classmethod
+    def from_serial(cls, port: str, bitrate: int):
+        serial_handle: serial.Serial = serial.Serial(port, bitrate, timeout=0.5)
+        serial_handle.set_buffer_size(rx_size=100 * 1024, tx_size=100 * 1024)  # type: ignore
+        return cls(serial_handle)
+
+    def __init__(self, serial_handle: serial.Serial):
+        self.handle = serial_handle
+        self.handle.reset_input_buffer()
+        self.handle.reset_output_buffer()
+
+        self.current_stats = BurstSerialStatistics()
+        self.statitsics = BurstSerialStatistics()
+
+        self.receive_task_handle = threading.Thread(target=self.receive_task, daemon=True)
+        self.transmit_task_handle = threading.Thread(target=self.transmit_task, daemon=True)
+
+        self.interface = BurstInterfaceC()
+        self.transmit_packet_queue = janus.Queue()
+        self.receive_packet_queue = janus.Queue()
+
+        self.receive_task_handle.start()
+        self.transmit_task_handle.start()
+
+    @property
+    def statistics(self):
+        return self.current_stats.update(
+            self.interface.bytes_handled,
+            self.interface.bytes_processed,
+            self.interface.packets_processed,
+            self.interface.crc_errors,
+            self.interface.overflow_errors,
+            self.interface.decode_errors,
+        )
+
+    def close(self):
+        self.kill = True
+        self.handle.close()
+        self.transmit_packet_queue.close()
+        self.receive_packet_queue.close()
+
+    def receive_task(self):
+        try:
+            while True:
+                # Read incoming data
+                data = self.handle.read(self.block_size)
+
+                if self.kill:
+                    break
+
+                if data:
+                    if self.debug_io:
+                        print(f"Received burst frame: {' '.join([f'{x:02X}' for x in data])}, length: {len(data)}")
+                    try:
+                        decoded_packets = self.interface.decode(data, fail_on_crc_error=True)
+                    except Exception as e:
+                        print(f"Error decoding: {e}")
+                        continue
+
+                    for packet in decoded_packets:
+                        # put all packets in the receive queue
+                        if self.debug_io:
+                            print(f"Received: {packet}")
+
+                        self.receive_packet_queue.sync_q.put(packet)
+
+                time.sleep(0.001)
+
+        except Exception as e:
+            print(f"Error in read task: {e}")
+            self.close()
+
+    def transmit_task(self):
+        try:
+            while True:
+                packet = self.transmit_packet_queue.sync_q.get()
+                if self.debug_io:
+                    print(f"Transmitting packet: {' '.join([f'{x:02X}' for x in packet])}")
+
+                data = self.interface.encode([packet])
+
+                if self.debug_io:
+                    from cobs import cobs
+
+                    daat = cobs.decode(data[:-1])
+                    # print in space separated hex
+                    print(f"Transmitting burst frame: {' '.join([f'{x:02X}' for x in daat])}")
+
+                    # print raw frame
+                    print(f"Transmitting 'raw' burst frame: {' '.join([f'{x:02X}' for x in data])}")
+                self.handle.write(data)
+
+        except Exception as e:
+            print(f"Error in transmit task: {e}")
+            self.close()
+
+    async def send(self, data: bytes):
+        await self.transmit_packet_queue.async_q.put(data)
+
+    async def flush_receive_queue(self):
+        while not self.receive_packet_queue.async_q.empty():
+            self.receive_packet_queue.async_q.get_nowait()
+
+    async def send_with_response(self, data: bytes):
+        # Flush all other packets
+        await self.flush_receive_queue()
+
+        start_time = time.time()
+        await self.transmit_packet_queue.async_q.put(data)
+        response = await self.receive_packet_queue.async_q.get()
+        end_time = time.time()
+
+        if self.debug_timings:
+            print(f"Time taken: {(end_time - start_time) * 1000} ms for {len(data)} bytes")
+
+        return response
+
+    async def receive(self):
+        return await self.receive_packet_queue.async_q.get()
+
+    def receive_all(self):
+        packets = []
+        while not self.receive_packet_queue.sync_q.empty():
+            packets.append(self.receive_packet_queue.sync_q.get())
+        return packets
+
+
+async def main():
+    interface = SerialBurstInterface.from_serial("COM4", 115200)
+
+    for i in range(1000):
+        response = await interface.send_with_response(10 * f"Hello World {i}!".encode())
+        print(f"Received: {response}")
+        await asyncio.sleep(0.01)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

burst_link_protocol-1.1.4/src/burst_link_protocol.h

@@ -0,0 +1,7 @@
+#ifndef BURST_INTERFACE_H
+#define BURST_INTERFACE_H
+
+#include "burst/burst_encoder.h"
+#include "burst/burst_decoder.h"
+
+#endif 

burst_link_protocol-1.1.4/src/python_bindings.cpp

@@ -0,0 +1,75 @@
+#include <nanobind/nanobind.h>
+extern "C" {
+#include <burst_link_protocol.h>
+}
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+struct BurstInterface {
+	burst_managed_decoder_t decoder = {0};
+	uint8_t decoder_buffer[1024] = {0};
+	burst_encoder_t encoder = {0};
+	uint8_t encoder_buffer[1024] = {0};
+
+	// Create buffer to hold the the vector of bytes likt a list
+
+	nb::list result;
+
+	BurstInterface() {
+		burst_managed_decoder_init(&decoder, decoder_buffer, sizeof(decoder_buffer), add_packet, this);
+		burst_encoder_init(&encoder, encoder_buffer, sizeof(encoder_buffer));
+	}
+
+	static int add_packet(const uint8_t *data, size_t size, void *user_data) {
+		// Create a bytes object from the data and append it to the result list
+		// nb::bytes packet_bytes(reinterpret_cast<const char *>(data), size);
+		// result.append(packet_bytes);
+		BurstInterface *self = static_cast<BurstInterface *>(user_data);
+		nb::bytes packet_bytes(reinterpret_cast<const char *>(data), size);
+		self->result.append(packet_bytes);  // Append the packet to the result list
+		return 0;                           // Return 0 to indicate success
+	}
+	nb::list decode(nb::bytes data, bool fail_on_crc_error = false) {
+		result.clear();  // Clear the result list before returning
+		burst_managed_decoder_handle_data(&decoder, (uint8_t *)data.data(), data.size());
+
+		return result;  // Return the result list containing the decoded packets
+	}
+
+	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);
+	}
+
+	uint32_t get_bytes_ingested() { return decoder.statistics.bytes_ingested; }
+	uint32_t get_bytes_processed() { return decoder.statistics.bytes_processed; }
+	uint32_t get_packets_processed() { return decoder.statistics.packets_processed; }
+
+	uint32_t get_crc_error_count() { return decoder.statistics.crc_errors; }
+	uint32_t get_overrun_count() { return decoder.statistics.overflow_errors; }
+	uint32_t get_packet_error_count() { return decoder.statistics.decode_errors; }
+
+	// Statistics
+};
+
+NB_MODULE(burst_interface_c, m) {
+	nb::set_leak_warnings(false);
+
+	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)
+		// Use a lambda
+		.def_prop_ro("bytes_handled", &BurstInterface::get_bytes_ingested)
+		.def_prop_ro("bytes_processed", &BurstInterface::get_bytes_processed)
+		.def_prop_ro("packets_processed", &BurstInterface::get_packets_processed)
+		.def_prop_ro("crc_errors", &BurstInterface::get_crc_error_count)
+		.def_prop_ro("overflow_errors", &BurstInterface::get_overrun_count)
+		.def_prop_ro("decode_errors", &BurstInterface::get_packet_error_count);
+}

burst_link_protocol-1.1.4/test/test_burst_decoding.py

@@ -0,0 +1,25 @@
+from burst_link_protocol import BurstInterfaceC, BurstInterfacePy
+
+payloads = [
+    # Malformed packet
+    ("04 01 ff 0e 06 d3 23 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 03 85 1f 00 0b 02 04 02 07 02 0b 02 04 02 08 02 0b 02 04 02 0c 02 0b 02 02 02 0d 02 0b 02 02 03 aa 94 00 04 02 ff 0e 03 d3 23 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 03 85 1f 00")
+    # Good packet
+    ("04 02 ff 0e 03 e1 23 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 01 03 99 fe 00")
+    ("04 01 ff 0e 06 ef be ad de c1 02 0b 02 01 02 01 02 0b 02 04 02 02 02 0b 02 04 02 03 02 0b 02 04 02 04 02 0b 02 04 02 05 02 0b 02 04 02 06 02 0b 02 04 02 a6 02 0b 02 04 02 07 02 0b 02 04 02 08 02 0b 02 04 02 0c 02 0b 02 02 02 0d 02 0b 02 02 03 aa 94 00")
+]
+
+
+def test_multi_encoded_payloads():
+    c_interface = BurstInterfaceC()
+    py_interface = BurstInterfacePy()
+    for payload in payloads:
+        payload = bytes.fromhex(payload.replace(" ", ""))
+        print(f"Testing payload: {payload.hex()}")
+        py_decoded_packet = py_interface.decode(payload)
+        print(f"Decoded payload: {py_decoded_packet}")
+        c_decoded_packet = c_interface.decode(payload, fail_on_crc_error=True)
+        print(f"Decoded payload: {c_decoded_packet}")
+
+
+if __name__ == "__main__":
+    test_multi_encoded_payloads()

{burst_link_protocol-1.0.4 → burst_link_protocol-1.1.4}/uv.lock

@@ -4,13 +4,15 @@ requires-python = ">=3.10, <4.0"
 
 [[package]]
 name = "burst-link-protocol"
-version = "1.0.3"
+version = "1.1.4"
 source = { editable = "." }
 dependencies = [
     { name = "cobs" },
     { name = "crc" },
+    { name = "janus" },
     { name = "nanobind" },
     { name = "numpy" },
+    { name = "pyserial" },
     { name = "pytest" },
     { name = "pytest-benchmark" },
     { name = "pytest-cov" },
@@ -30,9 +32,11 @@ dev = [
 requires-dist = [
     { name = "cobs", specifier = ">=1.2.1,<2.0.0" },
     { name = "crc", specifier = ">=7.1.0,<8.0.0" },
+    { name = "janus", specifier = ">=2.0.0" },
     { name = "nanobind", specifier = ">=2.5.0" },
     { name = "nanobind", marker = "extra == 'dev'", specifier = ">=2.5.0,<3.0.0" },
     { name = "numpy", specifier = ">=2.2.3,<3.0.0" },
+    { name = "pyserial", specifier = ">=3.5" },
     { name = "pytest", specifier = ">=8.3.4,<9.0.0" },
     { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.3.4,<9.0.0" },
     { name = "pytest-benchmark", specifier = ">=5.1.0,<6.0.0" },
@@ -161,6 +165,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050 },
 ]
 
+[[package]]
+name = "janus"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/7f/69884b6618be4baf6ebcacc716ee8680a842428a19f403db6d1c0bb990aa/janus-2.0.0.tar.gz", hash = "sha256:0970f38e0e725400496c834a368a67ee551dc3b5ad0a257e132f5b46f2e77770", size = 22910 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/68/34/65604740edcb20e1bda6a890348ed7d282e7dd23aa00401cbe36fd0edbd9/janus-2.0.0-py3-none-any.whl", hash = "sha256:7e6449d34eab04cd016befbd7d8c0d8acaaaab67cb59e076a69149f9031745f9", size = 12161 },
+]
+
 [[package]]
 name = "nanobind"
 version = "2.5.0"
@@ -268,6 +281,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e0/a9/023730ba63db1e494a271cb018dcd361bd2c917ba7004c3e49d5daf795a2/py_cpuinfo-9.0.0-py3-none-any.whl", hash = "sha256:859625bc251f64e21f077d099d4162689c762b5d6a4c3c97553d56241c9674d5", size = 22335 },
 ]
 
+[[package]]
+name = "pyserial"
+version = "3.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1e/7d/ae3f0a63f41e4d2f6cb66a5b57197850f919f59e558159a4dd3a818f5082/pyserial-3.5.tar.gz", hash = "sha256:3c77e014170dfffbd816e6ffc205e9842efb10be9f58ec16d3e8675b4925cddb", size = 159125 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/07/bc/587a445451b253b285629263eb51c2d8e9bcea4fc97826266d186f96f558/pyserial-3.5-py2.py3-none-any.whl", hash = "sha256:c4451db6ba391ca6ca299fb3ec7bae67a5c55dde170964c7a14ceefec02f2cf0", size = 90585 },
+]
+
 [[package]]
 name = "pytest"
 version = "8.3.5"

burst_link_protocol-1.0.4/.github/dependabot.yml

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

burst_link_protocol-1.0.4/platform/zephyr/CMakeLists.txt

@@ -1,9 +0,0 @@
-zephyr_library_named(burst-link-protocol)
-zephyr_library_sources(
-"../../src/decoder.c"
-"../../src/encoder.c"
-"../../src/crc.c"
-)
-
-target_include_directories(burst-link-protocol PUBLIC ../../src)
-

burst_link_protocol-1.0.4/src/burst_interface.h

@@ -1,56 +0,0 @@
-#ifndef BURST_INTERFACE_H
-#define BURST_INTERFACE_H
-
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.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 remaining_bytes;    // 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.
-
-	enum cobs_decode_inc_state {    COBS_DECODE_READ_CODE, COBS_DECODE_RUN, COBS_DECODE_FINISH_RUN } state;
-	uint8_t block, code;
-
-	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-1.0.4/src/burst_link_protocol/__init__.py

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

burst_link_protocol-1.0.4/src/crc.h

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

burst_link_protocol-1.0.4/src/encoder.c

@@ -1,92 +0,0 @@
-#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-1.0.4/src/python_bindings.cpp

@@ -1,80 +0,0 @@
-#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);
-}