mirror of
https://github.com/torlando-tech/pyxis.git
synced 2026-03-29 13:19:55 +00:00
ac6ceca9f8
Split T-Deck firmware from microReticulum examples/lxmf_tdeck/ into its own repo. microReticulum is consumed as a git submodule dependency pinned to feat/t-deck. All include paths updated from relative symlinks to bare includes resolved via library build flags. Both tdeck (NimBLE) and tdeck-bluedroid environments compile successfully. Licensed under AGPLv3. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
126 lines
3.9 KiB
C++
126 lines
3.9 KiB
C++
/**
|
|
* @file BLEFragmenter.h
|
|
* @brief BLE-Reticulum Protocol v2.2 packet fragmenter
|
|
*
|
|
* Fragments outgoing Reticulum packets into BLE-sized chunks with the v2.2
|
|
* 5-byte header format. This class has no BLE dependencies and can be used
|
|
* for testing on native builds.
|
|
*
|
|
* Fragment Header Format (5 bytes):
|
|
* Byte 0: Type (0x01=START, 0x02=CONTINUE, 0x03=END)
|
|
* Bytes 1-2: Sequence number (big-endian uint16_t)
|
|
* Bytes 3-4: Total fragments (big-endian uint16_t)
|
|
* Bytes 5+: Payload data
|
|
*/
|
|
#pragma once
|
|
|
|
#include "BLETypes.h"
|
|
#include "Bytes.h"
|
|
|
|
#include <vector>
|
|
#include <cstdint>
|
|
|
|
namespace RNS { namespace BLE {
|
|
|
|
class BLEFragmenter {
|
|
public:
|
|
/**
|
|
* @brief Construct a fragmenter with specified MTU
|
|
* @param mtu The negotiated BLE MTU (default: minimum BLE MTU of 23)
|
|
*/
|
|
explicit BLEFragmenter(size_t mtu = MTU::MINIMUM);
|
|
|
|
/**
|
|
* @brief Set the MTU for fragmentation calculations
|
|
*
|
|
* Call this when MTU is renegotiated with a peer.
|
|
* @param mtu The new MTU value
|
|
*/
|
|
void setMTU(size_t mtu);
|
|
|
|
/**
|
|
* @brief Get the current MTU
|
|
*/
|
|
size_t getMTU() const { return _mtu; }
|
|
|
|
/**
|
|
* @brief Get the maximum payload size per fragment (MTU - HEADER_SIZE)
|
|
*/
|
|
size_t getPayloadSize() const { return _payload_size; }
|
|
|
|
/**
|
|
* @brief Check if a packet needs fragmentation
|
|
* @param data The packet to check
|
|
* @return true if packet exceeds single fragment payload capacity
|
|
*/
|
|
bool needsFragmentation(const Bytes& data) const;
|
|
|
|
/**
|
|
* @brief Calculate number of fragments needed for a packet
|
|
* @param data_size Size of the data to fragment
|
|
* @return Number of fragments needed (minimum 1)
|
|
*/
|
|
uint16_t calculateFragmentCount(size_t data_size) const;
|
|
|
|
/**
|
|
* @brief Fragment a packet into BLE-sized chunks
|
|
*
|
|
* @param data The complete packet to fragment
|
|
* @param sequence_base Starting sequence number (default 0)
|
|
* @return Vector of fragments, each with the 5-byte header prepended
|
|
*
|
|
* For a single-fragment packet, returns one fragment with type=END.
|
|
* For multi-fragment packets:
|
|
* - First fragment has type=START
|
|
* - Middle fragments have type=CONTINUE
|
|
* - Last fragment has type=END
|
|
*/
|
|
std::vector<Bytes> fragment(const Bytes& data, uint16_t sequence_base = 0);
|
|
|
|
/**
|
|
* @brief Create a single fragment with proper header
|
|
*
|
|
* @param type Fragment type (START, CONTINUE, END)
|
|
* @param sequence Sequence number for this fragment
|
|
* @param total_fragments Total number of fragments in this message
|
|
* @param payload The fragment payload data
|
|
* @return Complete fragment with 5-byte header prepended
|
|
*/
|
|
static Bytes createFragment(Fragment::Type type, uint16_t sequence,
|
|
uint16_t total_fragments, const Bytes& payload);
|
|
|
|
/**
|
|
* @brief Parse the header from a received fragment
|
|
*
|
|
* @param fragment The received fragment data (must be at least HEADER_SIZE bytes)
|
|
* @param type Output: fragment type
|
|
* @param sequence Output: sequence number
|
|
* @param total_fragments Output: total fragment count
|
|
* @return true if header is valid and was parsed successfully
|
|
*/
|
|
static bool parseHeader(const Bytes& fragment, Fragment::Type& type,
|
|
uint16_t& sequence, uint16_t& total_fragments);
|
|
|
|
/**
|
|
* @brief Extract payload from a fragment (removes header)
|
|
*
|
|
* @param fragment The complete fragment with header
|
|
* @return The payload portion (empty if fragment is too small)
|
|
*/
|
|
static Bytes extractPayload(const Bytes& fragment);
|
|
|
|
/**
|
|
* @brief Validate a fragment header
|
|
*
|
|
* @param fragment The fragment to validate
|
|
* @return true if the fragment has a valid header
|
|
*/
|
|
static bool isValidFragment(const Bytes& fragment);
|
|
|
|
private:
|
|
size_t _mtu;
|
|
size_t _payload_size;
|
|
};
|
|
|
|
}} // namespace RNS::BLE
|