simplejsble 0.0.3 → 0.0.5

package/simpleble/src/backends/dongl/serial/Protocol.h

@@ -0,0 +1,117 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <vector>
+
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+
+#include "Wire.h"
+#include "ProtocolBase.h"
+
+#include "protocol/d2h.pb.h"
+#include "protocol/h2d.pb.h"
+
+namespace SimpleBLE {
+namespace Dongl {
+namespace Serial {
+
+class Protocol : public ProtocolBase {
+  public:
+    Protocol(const std::string& device_path);
+    ~Protocol();
+
+    basic_WhoamiRsp basic_whoami();
+    basic_ResetRsp basic_reset();
+    basic_DfuStartRsp basic_dfu_start();
+
+    simpleble_InitRsp simpleble_init();
+    simpleble_ScanStartRsp simpleble_scan_start();
+    simpleble_ScanStopRsp simpleble_scan_stop();
+    simpleble_ConnectRsp simpleble_connect(simpleble_BluetoothAddressType address_type, const std::string& address);
+    simpleble_DisconnectRsp simpleble_disconnect(uint16_t conn_handle);
+    simpleble_ReadRsp simpleble_read(uint16_t conn_handle, uint16_t handle);
+    simpleble_WriteRsp simpleble_write(uint16_t conn_handle, uint16_t handle, simpleble_WriteOperation operation, const std::vector<uint8_t>& data);
+
+    // GAP commands
+    sd_GapAddrSetRsp sd_gap_addr_set(bool has_addr, sd_types_BleGapAddr addr);
+    sd_GapAddrGetRsp sd_gap_addr_get();
+    sd_GapWhitelistSetRsp sd_gap_whitelist_set(pb_size_t wl_addrs_count, sd_types_BleGapAddr wl_addrs[8], uint8_t len);
+    sd_GapDeviceIdentitiesSetRsp sd_gap_device_identities_set(pb_size_t id_keys_count, sd_types_BleGapIdKey id_keys[8], pb_size_t local_irks_count, sd_types_BleGapIrk local_irks[8], uint8_t len);
+    sd_GapPrivacySetRsp sd_gap_privacy_set(bool has_privacy_params, sd_types_BleGapPrivacyParams privacy_params);
+    sd_GapPrivacyGetRsp sd_gap_privacy_get();
+    sd_GapAdvSetConfigureRsp sd_gap_adv_set_configure(uint8_t adv_handle, bool has_adv_data, sd_types_BleGapAdvData adv_data, bool has_adv_params, sd_types_BleGapAdvParams adv_params);
+    sd_GapAdvStartRsp sd_gap_adv_start(uint8_t adv_handle, uint8_t conn_cfg_tag);
+    sd_GapAdvStopRsp sd_gap_adv_stop(uint8_t adv_handle);
+    sd_GapConnParamUpdateRsp sd_gap_conn_param_update(uint16_t conn_handle, bool has_conn_params, sd_types_BleGapConnParams conn_params);
+    sd_GapDisconnectRsp sd_gap_disconnect(uint16_t conn_handle, uint8_t hci_ret_code_code);
+    sd_GapTxPowerSetRsp sd_gap_tx_power_set(uint8_t role, uint16_t handle, int8_t tx_power);
+    sd_GapAppearanceSetRsp sd_gap_appearance_set(uint16_t appearance);
+    sd_GapAppearanceGetRsp sd_gap_appearance_get();
+    sd_GapPpcpSetRsp sd_gap_ppcp_set(bool has_conn_params, sd_types_BleGapConnParams conn_params);
+    sd_GapPpcpGetRsp sd_gap_ppcp_get();
+    sd_GapDeviceNameSetRsp sd_gap_device_name_set(bool has_write_perm, sd_types_BleGapConnSecMode write_perm, sd_GapDeviceNameSetCmd_dev_name_t dev_name, uint16_t len);
+    sd_GapDeviceNameGetRsp sd_gap_device_name_get();
+    sd_GapAuthenticateRsp sd_gap_authenticate(uint16_t conn_handle, bool has_sec_params, sd_types_BleGapSecParams sec_params);
+    sd_GapSecParamsReplyRsp sd_gap_sec_params_reply(uint16_t conn_handle, sd_types_BleGapSecStatus sec_ret_code, bool has_sec_params, sd_types_BleGapSecParams sec_params, bool has_sec_keyset, sd_types_BleGapSecKeyset sec_keyset);
+    sd_GapAuthKeyReplyRsp sd_gap_auth_key_reply(uint16_t conn_handle, sd_types_BleGapAuthKeyType key_type, sd_GapAuthKeyReplyCmd_key_t key);
+    sd_GapLescDhkeyReplyRsp sd_gap_lesc_dhkey_reply(uint16_t conn_handle, bool has_dhkey, sd_types_BleGapLescDhkey dhkey);
+    sd_GapKeypressNotifyRsp sd_gap_keypress_notify(uint16_t conn_handle, sd_types_BleGapKpNotType kp_not);
+    sd_GapLescOobDataGetRsp sd_gap_lesc_oob_data_get(uint16_t conn_handle, bool has_pk_own, sd_types_BleGapLescP256Pk pk_own);
+    sd_GapLescOobDataSetRsp sd_gap_lesc_oob_data_set(uint16_t conn_handle, bool has_oobd_own, sd_types_BleGapLescOobData oobd_own, bool has_oobd_peer, sd_types_BleGapLescOobData oobd_peer);
+    sd_GapEncryptRsp sd_gap_encrypt(uint16_t conn_handle, bool has_master_id, sd_types_BleGapMasterId master_id, bool has_enc_info, sd_types_BleGapEncInfo enc_info);
+    sd_GapSecInfoReplyRsp sd_gap_sec_info_reply(uint16_t conn_handle, bool has_enc_info, sd_types_BleGapEncInfo enc_info, bool has_id_info, sd_types_BleGapIrk id_info, bool has_sign_info, sd_types_BleGapSignInfo sign_info);
+    sd_GapConnSecGetRsp sd_gap_conn_sec_get(uint16_t conn_handle);
+    sd_GapRssiStartRsp sd_gap_rssi_start(uint16_t conn_handle, uint8_t threshold_dbm, uint8_t skip_count);
+    sd_GapRssiStopRsp sd_gap_rssi_stop(uint16_t conn_handle);
+    sd_GapScanStartRsp sd_gap_scan_start(sd_types_BleGapScanParams scan_params);
+    sd_GapScanStopRsp sd_gap_scan_stop();
+    sd_GapConnectRsp sd_gap_connect(bool has_peer_addr, sd_types_BleGapAddr peer_addr, bool has_scan_params, sd_types_BleGapScanParams scan_params, bool has_conn_params, sd_types_BleGapConnParams conn_params, uint8_t conn_cfg_tag);
+    sd_GapConnectCancelRsp sd_gap_connect_cancel();
+    sd_GapRssiGetRsp sd_gap_rssi_get(uint16_t conn_handle);
+    sd_GapPhyUpdateRsp sd_gap_phy_update(uint16_t conn_handle, bool has_phys, sd_BleGapPhysCmd phys);
+    sd_GapDataLengthUpdateRsp sd_gap_data_length_update(uint16_t conn_handle, bool has_dl_params, sd_types_BleGapDataLengthParams dl_params, bool has_dl_limitation, sd_types_BleGapDataLengthLimitation dl_limitation);
+    sd_GapQosChannelSurveyStartRsp sd_gap_qos_channel_survey_start(uint32_t interval_us);
+    sd_GapQosChannelSurveyStopRsp sd_gap_qos_channel_survey_stop();
+    sd_GapAdvAddrGetRsp sd_gap_adv_addr_get(uint8_t adv_handle);
+    sd_GapNextConnEvtCounterGetRsp sd_gap_next_conn_evt_counter_get(uint16_t conn_handle);
+    sd_GapConnEvtTriggerStartRsp sd_gap_conn_evt_trigger_start(uint16_t conn_handle, bool has_params, sd_types_BleGapConnEventTrigger params);
+    sd_GapConnEvtTriggerStopRsp sd_gap_conn_evt_trigger_stop(uint16_t conn_handle);
+
+    // GATTC commands
+    sd_GattcPrimaryServicesDiscoverRsp sd_gattc_primary_services_discover(uint16_t conn_handle, uint16_t start_handle, bool has_srvc_uuid, sd_types_BleUuid srvc_uuid);
+    sd_GattcRelationshipsDiscoverRsp sd_gattc_relationships_discover(uint16_t conn_handle, bool has_handle_range, sd_types_BleGattcHandleRange handle_range);
+    sd_GattcCharacteristicsDiscoverRsp sd_gattc_characteristics_discover(uint16_t conn_handle, bool has_handle_range, sd_types_BleGattcHandleRange handle_range);
+    sd_GattcDescriptorsDiscoverRsp sd_gattc_descriptors_discover(uint16_t conn_handle, bool has_handle_range, sd_types_BleGattcHandleRange handle_range);
+    sd_GattcAttrInfoDiscoverRsp sd_gattc_attr_info_discover(uint16_t conn_handle, bool has_handle_range, sd_types_BleGattcHandleRange handle_range);
+    sd_GattcCharValueByUuidReadRsp sd_gattc_char_value_by_uuid_read(uint16_t conn_handle, bool has_uuid, sd_types_BleUuid uuid, bool has_handle_range, sd_types_BleGattcHandleRange handle_range);
+    sd_GattcReadRsp sd_gattc_read(uint16_t conn_handle, uint16_t handle, uint16_t offset);
+    sd_GattcCharValuesReadRsp sd_gattc_char_values_read(uint16_t conn_handle, pb_callback_t handles, uint8_t handle_count);
+    sd_GattcWriteRsp sd_gattc_write(uint16_t conn_handle, bool has_write_params, sd_types_BleGattcWriteParams write_params);
+    sd_GattcHvConfirmRsp sd_gattc_hv_confirm(uint16_t conn_handle, uint16_t handle);
+    sd_GattcExchangeMtuRequestRsp sd_gattc_exchange_mtu_request(uint16_t conn_handle, uint16_t client_rx_mtu);
+
+    // GATTS commands
+    sd_GattsServiceAddRsp sd_gatts_service_add(uint8_t type, bool has_uuid, sd_types_BleUuid uuid);
+    sd_GattsIncludeAddRsp sd_gatts_include_add(uint16_t service_handle, uint16_t inc_srvc_handle);
+    sd_GattsCharacteristicAddRsp sd_gatts_characteristic_add(uint16_t service_handle, bool has_char_md, sd_types_BleGattsCharMd char_md, bool has_attr_char_value, sd_types_BleGattsAttr attr_char_value);
+    sd_GattsDescriptorAddRsp sd_gatts_descriptor_add(uint16_t char_handle, bool has_attr, sd_types_BleGattsAttr attr);
+    sd_GattsValueSetRsp sd_gatts_value_set(uint16_t conn_handle, uint16_t handle, bool has_value, sd_types_BleGattsValue value);
+    sd_GattsValueGetRsp sd_gatts_value_get(uint16_t conn_handle, uint16_t handle);
+    sd_GattsHvxRsp sd_gatts_hvx(uint16_t conn_handle, bool has_hvx_params, sd_types_BleGattsHvxParams hvx_params);
+    sd_GattsServiceChangedRsp sd_gatts_service_changed(uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle);
+    sd_GattsRwAuthorizeReplyRsp sd_gatts_rw_authorize_reply(uint16_t conn_handle, bool has_rw_authorize_reply_params, sd_types_BleGattsRwAuthorizeReplyParams rw_authorize_reply_params);
+    sd_GattsSysAttrSetRsp sd_gatts_sys_attr_set(uint16_t conn_handle, sd_GattsSysAttrSetCmd_sys_attr_data_t sys_attr_data, uint16_t len, uint32_t flags);
+    sd_GattsSysAttrGetRsp sd_gatts_sys_attr_get(uint16_t conn_handle, uint32_t flags);
+    sd_GattsInitialUserHandleGetRsp sd_gatts_initial_user_handle_get();
+    sd_GattsAttrGetRsp sd_gatts_attr_get(uint16_t handle);
+    sd_GattsExchangeMtuReplyRsp sd_gatts_exchange_mtu_reply(uint16_t conn_handle, uint16_t server_rx_mtu);
+
+};
+
+}  // namespace Serial
+}  // namespace Dongl
+}  // namespace SimpleBLE

package/simpleble/src/backends/dongl/serial/ProtocolBase.cpp

@@ -0,0 +1,95 @@
+#include "ProtocolBase.h"
+
+using namespace SimpleBLE::Dongl::Serial;
+
+#include "nanopb/pb_decode.h"
+#include "nanopb/pb_encode.h"
+
+#include <fmt/core.h>
+
+ProtocolBase::ProtocolBase(const std::string& device_path) : _wire(std::make_unique<Wire>(device_path)) {
+    // Set up the Wire packet callback to handle incoming packets
+    _wire->set_packet_callback([this](const std::vector<uint8_t>& packet) {
+        dongl_D2H d2h;
+        pb_istream_t stream = pb_istream_from_buffer(packet.data(), packet.size());
+        if (!pb_decode(&stream, dongl_D2H_fields, &d2h)) {
+            // TODO: Handle decoding failure
+            fmt::print("Failed to decode D2H: {}\n", PB_GET_ERROR(&stream));
+            return;
+        }
+
+        if (d2h.which_type == dongl_D2H_rsp_tag) {
+            // First, try to fulfill any pending sync request
+            {
+                std::lock_guard<std::mutex> lock(_pending_mutex);
+                if (!_pending_response.has_value()) {
+                    _pending_response = d2h.type.rsp;
+                    _response_cv.notify_one();
+                }
+            }
+
+        } else if (d2h.which_type == dongl_D2H_evt_tag) {
+            if (_event_callback) {
+                _event_callback(d2h.type.evt);
+            }
+        }
+    });
+
+    _wire->set_error_callback([this](const Wire::Error& error) {
+        fmt::print("Error: {}\n", (int)error);
+    });
+}
+
+ProtocolBase::~ProtocolBase() {}
+
+dongl_Response ProtocolBase::exchange(const dongl_Command& command) {
+    // Check if there's already a pending sync operation
+    {
+        std::lock_guard<std::mutex> lock(_pending_mutex);
+        if (_pending_response.has_value()) {
+            throw std::runtime_error("Another sync command is already pending");
+        }
+    }
+
+    // Clear any previous response and send the command
+    {
+        std::unique_lock<std::mutex> lock(_pending_mutex);
+        _pending_response.reset();  // Ensure it's empty to indicate we're waiting
+    }
+
+    try {
+        size_t command_size = 0;
+        pb_get_encoded_size(&command_size, dongl_Command_fields, &command);
+
+        std::vector<uint8_t> tx_buffer_raw(command_size);
+        pb_ostream_t stream = pb_ostream_from_buffer(tx_buffer_raw.data(), tx_buffer_raw.size());
+        bool status = pb_encode(&stream, dongl_Command_fields, &command);
+        if (!status) {
+            // TODO: Handle encoding failure
+            throw std::runtime_error("Failed to encode command");
+        }
+
+        _wire->send_packet(tx_buffer_raw);
+    } catch (const std::runtime_error& e) {
+        // If sending fails, no cleanup needed since we didn't set pending_response
+        throw;
+    }
+
+    // Wait for the response with 1 second timeout
+    {
+        std::unique_lock<std::mutex> lock(_pending_mutex);
+        if (_response_cv.wait_for(lock, std::chrono::seconds(1), [this]() { return _pending_response.has_value(); })) {
+            dongl_Response response = *_pending_response;
+            _pending_response.reset();
+            return response;
+        } else {
+            // Timeout occurred, reset pending state
+            _pending_response.reset();
+            throw std::runtime_error("Timeout waiting for response");
+        }
+    }
+}
+
+void ProtocolBase::set_event_callback(std::function<void(const dongl_Event&)> callback) {
+    _event_callback = std::move(callback);
+}

package/simpleble/src/backends/dongl/serial/ProtocolBase.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <vector>
+
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+
+#include "Wire.h"
+
+#include "protocol/d2h.pb.h"
+#include "protocol/h2d.pb.h"
+
+namespace SimpleBLE {
+namespace Dongl {
+namespace Serial {
+
+class ProtocolBase {
+  public:
+    ProtocolBase(const std::string& device_path);
+    ~ProtocolBase();
+
+    /**
+     * @brief Sends a command synchronously and waits for the response.
+     * Only one exchange can be pending at a time.
+     *
+     * @param command The command to send.
+     * @return The response when it arrives.
+     * @throws std::runtime_error if another exchange is already pending or if timeout occurs.
+     */
+    dongl_Response exchange(const dongl_Command& command);
+
+    /**
+     * @brief Sets the callback for received events.
+     *
+     * @param callback Function to call when an event is received.
+     */
+    void set_event_callback(std::function<void(const dongl_Event&)> callback);
+
+  private:
+    std::unique_ptr<Wire> _wire;
+    std::function<void(const dongl_Event&)> _event_callback;
+
+    std::optional<dongl_Response> _pending_response;
+    std::condition_variable _response_cv;
+    std::mutex _pending_mutex;
+};
+
+}  // namespace Serial
+}  // namespace Dongl
+}  // namespace SimpleBLE

package/simpleble/src/backends/dongl/serial/Wire.cpp

@@ -0,0 +1,133 @@
+#include "Wire.h"
+
+#include <cstring>
+#include <kvn/kvn_bytearray.h>
+#include <fmt/core.h>
+
+using namespace SimpleBLE::Dongl::Serial;
+
+Wire::Wire(const std::string& device_path)
+    : _usb_helper(std::make_unique<USB::UsbHelper>(device_path))
+    , _state(State::IDLE)
+    , _length(0)
+    , _checksum(0)
+    , _buffer_index(0)
+    , _buffer(MAX_PAYLOAD_SIZE) {
+
+    // Set up the USB receive callback to process incoming bytes
+    _usb_helper->set_rx_callback([this](const kvn::bytearray& data) {
+        for (size_t i = 0; i < data.size(); ++i) {
+            process_byte(data[i]);
+        }
+    });
+}
+
+Wire::~Wire() {}
+
+void Wire::send_packet(const std::vector<uint8_t>& payload) {
+    send_packet(payload.data(), payload.size());
+}
+
+void Wire::send_packet(const uint8_t* data, size_t length) {
+    if (length > MAX_PAYLOAD_SIZE) {
+        throw std::runtime_error("Payload length exceeds maximum allowed");
+    }
+
+    // Create the encoded packet
+    std::vector<uint8_t> packet;
+    packet.reserve(5 + length);  // sync + length(2) + payload + crc(2)
+
+    packet.push_back(SYNC_BYTE);
+    packet.push_back(length & 0xFF);
+    packet.push_back((length >> 8) & 0xFF);
+    packet.insert(packet.end(), data, data + length);
+
+    uint16_t crc = crc16(data, length);
+    packet.push_back(crc & 0xFF);
+    packet.push_back((crc >> 8) & 0xFF);
+
+    // Send via USB
+    kvn::bytearray usb_data(packet.data(), packet.size());
+    _usb_helper->tx(usb_data);
+}
+
+void Wire::set_packet_callback(PacketCallback callback) {
+    _packet_callback = std::move(callback);
+}
+
+void Wire::set_error_callback(ErrorCallback callback) {
+    _error_callback = std::move(callback);
+}
+
+void Wire::process_byte(uint8_t byte) {
+    switch (_state) {
+        case State::IDLE:
+            if (byte == SYNC_BYTE) {
+                _state = State::HEADER_LOW;
+                _buffer_index = 0;
+            }
+            break;
+
+        case State::HEADER_LOW:
+            _length = byte;
+            _state = State::HEADER_HIGH;
+            break;
+
+        case State::HEADER_HIGH:
+            _length |= (uint16_t)byte << 8;
+            if (_length > MAX_PAYLOAD_SIZE) {
+                _state = State::IDLE;
+                if (_error_callback) {
+                    _error_callback(Error::INVALID_LENGTH);
+                }
+            } else if (_length == 0) {
+                _state = State::CHECKSUM_LOW;
+                _buffer_index = 0;
+            } else {
+                _state = State::PAYLOAD;
+                _buffer_index = 0;
+            }
+            break;
+
+        case State::PAYLOAD:
+            _buffer[_buffer_index++] = byte;
+            if (_buffer_index == _length) {
+                _state = State::CHECKSUM_LOW;
+            }
+            break;
+
+        case State::CHECKSUM_LOW:
+            _checksum = byte;
+            _state = State::CHECKSUM_HIGH;
+            break;
+
+        case State::CHECKSUM_HIGH:
+            _checksum |= (uint16_t)byte << 8;
+            uint16_t computed_crc = crc16(_buffer.data(), _length);
+            if (_checksum == computed_crc) {
+                if (_packet_callback) {
+                    std::vector<uint8_t> packet(_buffer.begin(), _buffer.begin() + _length);
+                    _packet_callback(packet);
+                }
+            } else if (_error_callback) {
+                _error_callback(Error::CRC_FAILURE);
+            }
+            _state = State::IDLE;
+            break;
+    }
+}
+
+uint16_t Wire::crc16(const uint8_t* data, size_t len) {
+    uint16_t crc = 0xFFFF;
+    for (size_t i = 0; i < len; i++) {
+        crc ^= (uint16_t)data[i] << 8;
+        for (uint8_t bit = 0; bit < 8; bit++) {
+            if (crc & 0x8000) {
+                crc = (crc << 1) ^ 0x8005;
+            } else {
+                crc <<= 1;
+            }
+        }
+    }
+    return crc;
+}

package/simpleble/src/backends/dongl/serial/Wire.h

@@ -0,0 +1,116 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <vector>
+
+#include "../usb/UsbHelper.h"
+
+namespace SimpleBLE {
+namespace Dongl {
+namespace Serial {
+
+class Wire {
+public:
+    /**
+     * @brief Error codes for the serial protocol.
+     */
+    enum class Error {
+        INVALID_LENGTH, /**< Length exceeds maximum payload size. */
+        CRC_FAILURE     /**< CRC-16 check failed. */
+    };
+
+    /**
+     * @brief State machine states.
+     */
+    enum class State {
+        IDLE,         /**< Waiting for sync byte. */
+        HEADER_LOW,   /**< Reading low byte of length. */
+        HEADER_HIGH,  /**< Reading high byte of length. */
+        PAYLOAD,      /**< Reading payload bytes. */
+        CHECKSUM_LOW, /**< Reading low byte of CRC-16. */
+        CHECKSUM_HIGH /**< Reading high byte of CRC-16. */
+    };
+
+    /**
+     * @brief Callback function type for received packets.
+     */
+    using PacketCallback = std::function<void(const std::vector<uint8_t>&)>;
+
+    /**
+     * @brief Callback function type for errors.
+     */
+    using ErrorCallback = std::function<void(Error)>;
+
+    /**
+     * @brief Maximum payload size in bytes.
+     */
+    static constexpr size_t MAX_PAYLOAD_SIZE = 571;
+
+    /**
+     * @brief Sync byte value marking packet start.
+     */
+    static constexpr uint8_t SYNC_BYTE = 0xAA;
+
+    Wire(const std::string& device_path);
+    ~Wire();
+
+    /**
+     * @brief Sends a payload as an encoded packet.
+     *
+     * @param payload The data to send.
+     */
+    void send_packet(const std::vector<uint8_t>& payload);
+
+    /**
+     * @brief Sends a payload as an encoded packet.
+     *
+     * @param data Pointer to the data to send.
+     * @param length Length of the data.
+     */
+    void send_packet(const uint8_t* data, size_t length);
+
+    /**
+     * @brief Sets the callback for received packets.
+     *
+     * @param callback Function to call when a valid packet is received.
+     */
+    void set_packet_callback(PacketCallback callback);
+
+    /**
+     * @brief Sets the callback for protocol errors.
+     *
+     * @param callback Function to call on protocol errors.
+     */
+    void set_error_callback(ErrorCallback callback);
+
+private:
+    /**
+     * @brief Processes a single incoming byte through the protocol state machine.
+     *
+     * @param byte The incoming byte to process.
+     */
+    void process_byte(uint8_t byte);
+
+    /**
+     * @brief Computes CRC-16 checksum.
+     *
+     * @param data Pointer to the data.
+     * @param len Length of the data.
+     * @return The computed CRC-16 value.
+     */
+    static uint16_t crc16(const uint8_t* data, size_t len);
+
+    std::unique_ptr<USB::UsbHelper> _usb_helper;
+    State _state;
+    uint16_t _length;
+    uint16_t _checksum;
+    size_t _buffer_index;
+    std::vector<uint8_t> _buffer;
+    PacketCallback _packet_callback;
+    ErrorCallback _error_callback;
+};
+
+}  // namespace Serial
+}  // namespace Dongl
+}  // namespace SimpleBLE

package/simpleble/src/backends/dongl/usb/UsbHelper.cpp

@@ -0,0 +1,53 @@
+#include "UsbHelper.h"
+
+#if SIMPLEBLE_BACKEND_LINUX
+#include "UsbHelperLinux.h"
+#elif SIMPLEBLE_BACKEND_WINDOWS
+#include "UsbHelperWindows.h"
+#elif SIMPLEBLE_BACKEND_MACOS
+#include "UsbHelperApple.h"
+#else
+#include "UsbHelperNull.h"
+#endif
+
+namespace SimpleBLE {
+namespace Dongl {
+namespace USB {
+
+UsbHelper::UsbHelper(const std::string& device_path) : _impl(nullptr) {
+#if SIMPLEBLE_BACKEND_LINUX
+    _impl = std::make_unique<UsbHelperLinux>(device_path);
+#elif SIMPLEBLE_BACKEND_WINDOWS
+    _impl = std::make_unique<UsbHelperWindows>(device_path);
+#elif SIMPLEBLE_BACKEND_MACOS
+    _impl = std::make_unique<UsbHelperApple>(device_path);
+#else
+    _impl = std::make_unique<UsbHelperNull>(device_path);
+#endif
+}
+
+UsbHelper::~UsbHelper() = default;
+
+void UsbHelper::tx(const kvn::bytearray& data) {
+    _impl->tx(data);
+}
+
+void UsbHelper::set_rx_callback(std::function<void(const kvn::bytearray&)> callback) {
+    _impl->set_rx_callback(callback);
+}
+
+std::vector<std::string> UsbHelper::get_dongl_devices() {
+#if SIMPLEBLE_BACKEND_LINUX
+    return UsbHelperLinux::get_dongl_devices();
+#elif SIMPLEBLE_BACKEND_WINDOWS
+    return UsbHelperWindows::get_dongl_devices();
+#elif SIMPLEBLE_BACKEND_MACOS
+    return UsbHelperApple::get_dongl_devices();
+#else
+    return UsbHelperNull::get_dongl_devices();
+#endif
+}
+
+}  // namespace USB
+}  // namespace Dongl
+}  // namespace SimpleBLE

package/simpleble/src/backends/dongl/usb/UsbHelper.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <vector>
+#include <string>
+#include <memory>
+
+#include <kvn/kvn_safe_callback.hpp>
+#include <kvn/kvn_bytearray.h>
+
+namespace SimpleBLE {
+namespace Dongl {
+namespace USB {
+
+class UsbHelperImpl;
+
+class UsbHelper {
+  public:
+    UsbHelper(const std::string& device_path);
+    ~UsbHelper();
+
+    void tx(const kvn::bytearray& data);
+    void set_rx_callback(std::function<void(const kvn::bytearray&)> callback);
+
+    static std::vector<std::string> get_dongl_devices();
+
+  protected:
+    std::unique_ptr<UsbHelperImpl> _impl;
+};
+
+}  // namespace USB
+}  // namespace Dongl
+}  // namespace SimpleBLE