Harden OFDM control path and disconnect handling

Author: secup

include/ultra/ofdm_link_adaptation.hpp

@@ -0,0 +1,86 @@
+#pragma once
+
+#include "types.hpp"
+#include <algorithm>
+
+namespace ultra {
+namespace ofdm_link_adaptation {
+
+inline bool isCoherentModulation(Modulation mod) {
+    switch (mod) {
+        case Modulation::BPSK:
+        case Modulation::QPSK:
+        case Modulation::QAM8:
+        case Modulation::QAM16:
+        case Modulation::QAM32:
+        case Modulation::QAM64:
+        case Modulation::QAM256:
+            return true;
+        default:
+            return false;
+    }
+}
+
+// Deterministic pilot profile (must be identical on TX and RX).
+// This intentionally uses only signaled mode/rate to avoid cross-station mismatch.
+inline int recommendedPilotSpacing(Modulation mod, CodeRate rate) {
+    const bool coherent = isCoherentModulation(mod);
+
+    if (coherent) {
+        switch (rate) {
+            case CodeRate::R3_4: return 8;
+            case CodeRate::R2_3:
+            case CodeRate::R1_2:
+            case CodeRate::R1_4:
+            case CodeRate::R1_3:
+            default:
+                return 5;
+        }
+    }
+
+    // Differential modes: keep DQPSK/DBPSK profile, densify D8PSK.
+    if (mod == Modulation::D8PSK) {
+        switch (rate) {
+            case CodeRate::R3_4: return 8;
+            case CodeRate::R2_3:
+            case CodeRate::R1_2: return 8;
+            case CodeRate::R1_4:
+            case CodeRate::R1_3:
+            default:
+                return 10;
+        }
+    }
+
+    switch (rate) {
+        case CodeRate::R3_4: return 15;
+        case CodeRate::R2_3:
+        case CodeRate::R1_2:
+        case CodeRate::R1_4:
+        case CodeRate::R1_3:
+        default:
+            return 10;
+    }
+}
+
+inline int pilotCount(int total_carriers, int pilot_spacing) {
+    if (pilot_spacing <= 0 || total_carriers <= 0) return 0;
+    return (total_carriers + pilot_spacing - 1) / pilot_spacing;
+}
+
+// Experimental burst interleaver group sizing helper.
+inline int recommendedBurstGroupSize(Modulation mod, CodeRate rate, float fading_index = 0.0f) {
+    if (mod == Modulation::D8PSK &&
+        (rate == CodeRate::R1_2 || rate == CodeRate::R2_3 || rate == CodeRate::R3_4)) {
+        if (fading_index >= 0.45f) return 6;
+        return 4;
+    }
+    return 4;
+}
+
+inline int sanitizeBurstGroupSize(int value) {
+    return std::clamp(value, 2, 8);
+}
+
+} // namespace ofdm_link_adaptation
+} // namespace ultra
+

src/gui/modem/modem_mode.cpp

@@ -2,6 +2,7 @@
 
 #include "modem_engine.hpp"
 #include "ultra/logging.hpp"
+#include "ultra/ofdm_link_adaptation.hpp"
 #include "protocol/frame_v2.hpp"
 #include <cstdio>
 
@@ -127,15 +128,8 @@ void ModemEngine::setConnected(bool connected) {
         config_.code_rate = data_code_rate_;
         config_.use_pilots = true;  // Always — must match OFDMChirpWaveform
 
-        // Pilot spacing based on code rate (matching OFDMChirpWaveform)
-        switch (data_code_rate_) {
-            case CodeRate::R3_4:
-                config_.pilot_spacing = 15;
-                break;
-            default:
-                config_.pilot_spacing = 10;
-                break;
-        }
+        config_.pilot_spacing =
+            ofdm_link_adaptation::recommendedPilotSpacing(data_modulation_, data_code_rate_);
 
         decoder_->setRate(data_code_rate_);
 
@@ -215,18 +209,8 @@ void ModemEngine::setDataMode(Modulation mod, CodeRate rate) {
     config_.code_rate = rate;
     config_.use_pilots = true;  // Always — must match OFDMChirpWaveform
 
-    // Configure pilot spacing based on code rate (matching OFDMChirpWaveform)
-    switch (rate) {
-        case CodeRate::R3_4:
-            config_.pilot_spacing = 15;  // ~4 pilots
-            break;
-        case CodeRate::R2_3:
-        case CodeRate::R1_2:
-        case CodeRate::R1_4:
-        default:
-            config_.pilot_spacing = 10;  // ~6 pilots
-            break;
-    }
+    config_.pilot_spacing =
+        ofdm_link_adaptation::recommendedPilotSpacing(mod, rate);
 
     // If already connected, update both TX and RX to match
     if (connected_) {

src/gui/modem/streaming_decoder.cpp

@@ -138,6 +138,10 @@ StreamingDecoder::~StreamingDecoder() {
     stop();
 }
 
+void StreamingDecoder::setBurstInterleaveGroupSize(int size) {
+    burst_group_size_ = std::clamp(size, 2, 8);
+}
+
 // ============================================================================
 // AUDIO THREAD - Just buffer samples, nothing else
 // ============================================================================
@@ -1975,16 +1979,20 @@ DecodeResult StreamingDecoder::decodeFrame(const std::vector<float>& soft_bits,
 // ============================================================================
 
 void StreamingDecoder::accumulateBurstFrames() {
+    const int burst_group_size = std::max(2, burst_group_size_);
+    const int burst_timeout_ms =
+        static_cast<int>(BURST_TIMEOUT_MS_BASE * (burst_group_size / 4.0f));
+
     // Timeout check
     auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
         std::chrono::steady_clock::now() - burst_start_time_).count();
-    if (elapsed > BURST_TIMEOUT_MS) {
+    if (elapsed > burst_timeout_ms) {
         LOG_MODEM(WARN, "[%s] Burst group timeout: got %zu/%d frames",
-                  log_prefix_.c_str(), burst_soft_buffer_.size(), BURST_GROUP_SIZE);
+                  log_prefix_.c_str(), burst_soft_buffer_.size(), burst_group_size);
         // Discard — TX used 4-frame interleaving, partial is undecodable
         {
             std::lock_guard<std::mutex> slock(stats_mutex_);
-            stats_.frames_failed += BURST_GROUP_SIZE;
+            stats_.frames_failed += burst_group_size;
         }
         burst_soft_buffer_.clear();
         {
@@ -2001,10 +2009,10 @@ void StreamingDecoder::accumulateBurstFrames() {
     if (result == BurstFrameResult::FAILED) {
         // Hard failure (energy lost or process error) — abort immediately
         LOG_MODEM(WARN, "[%s] Burst group aborted: hard failure at frame %zu/%d",
-                  log_prefix_.c_str(), burst_soft_buffer_.size() + 1, BURST_GROUP_SIZE);
+                  log_prefix_.c_str(), burst_soft_buffer_.size() + 1, burst_group_size);
         {
             std::lock_guard<std::mutex> slock(stats_mutex_);
-            stats_.frames_failed += BURST_GROUP_SIZE;
+            stats_.frames_failed += burst_group_size;
         }
         burst_soft_buffer_.clear();
         {
@@ -2020,7 +2028,7 @@ void StreamingDecoder::accumulateBurstFrames() {
     }
 
     // SUCCESS — check if group complete
-    if (static_cast<int>(burst_soft_buffer_.size()) == BURST_GROUP_SIZE) {
+    if (static_cast<int>(burst_soft_buffer_.size()) == burst_group_size) {
         finalizeBurstGroup();
         burst_soft_buffer_.clear();
         {
@@ -2033,6 +2041,8 @@ void StreamingDecoder::accumulateBurstFrames() {
 }
 
 StreamingDecoder::BurstFrameResult StreamingDecoder::tryDemodulateNextBurstFrame() {
+    const int burst_group_size = std::max(2, burst_group_size_);
+
     // Check available samples at burst_next_pos_
     size_t next_available;
     {
@@ -2071,7 +2081,7 @@ StreamingDecoder::BurstFrameResult StreamingDecoder::tryDemodulateNextBurstFrame
     if (next_rms < BURST_ENERGY_THRESHOLD) {
         LOG_MODEM(WARN, "[%s] Burst frame %zu/%d: energy lost (RMS=%.4f)",
                   log_prefix_.c_str(), burst_soft_buffer_.size() + 1,
-                  BURST_GROUP_SIZE, next_rms);
+                  burst_group_size, next_rms);
         burst_next_pos_ = (burst_next_pos_ + burst_min_block_) % MAX_BUFFER_SAMPLES;
         return BurstFrameResult::FAILED;
     }
@@ -2081,7 +2091,7 @@ StreamingDecoder::BurstFrameResult StreamingDecoder::tryDemodulateNextBurstFrame
     bool ok = waveform_->process(SampleSpan(block.data(), block.size()));
     if (!ok) {
         LOG_MODEM(WARN, "[%s] Burst frame %zu/%d: process() failed",
-                  log_prefix_.c_str(), burst_soft_buffer_.size() + 1, BURST_GROUP_SIZE);
+                  log_prefix_.c_str(), burst_soft_buffer_.size() + 1, burst_group_size);
         burst_next_pos_ = (burst_next_pos_ + burst_min_block_) % MAX_BUFFER_SAMPLES;
         return BurstFrameResult::FAILED;
     }
@@ -2109,17 +2119,18 @@ StreamingDecoder::BurstFrameResult StreamingDecoder::tryDemodulateNextBurstFrame
 
     LOG_MODEM(INFO, "[%s] Burst frame %zu/%d demodulated, RMS=%.4f",
               log_prefix_.c_str(), burst_soft_buffer_.size(),
-              BURST_GROUP_SIZE, next_rms);
+              burst_group_size, next_rms);
     return BurstFrameResult::SUCCESS;
 }
 
 void StreamingDecoder::finalizeBurstGroup() {
+    const int burst_group_size = std::max(2, burst_group_size_);
     LOG_MODEM(INFO, "[%s] Burst group complete (%d frames), deinterleaving...",
-              log_prefix_.c_str(), BURST_GROUP_SIZE);
+              log_prefix_.c_str(), burst_group_size);
 
     auto logical_soft = fec::BurstInterleaver::deinterleave(burst_soft_buffer_);
 
-    for (int i = 0; i < BURST_GROUP_SIZE; i++) {
+    for (int i = 0; i < burst_group_size; i++) {
         DecodeResult result = decodeFrame(logical_soft[i], burst_snr_, burst_cfo_);
 
         {
@@ -2137,7 +2148,7 @@ void StreamingDecoder::finalizeBurstGroup() {
         }
 
         LOG_MODEM(INFO, "[%s] Burst logical frame %d/%d: %s (%d/%d CWs)",
-                  log_prefix_.c_str(), i + 1, BURST_GROUP_SIZE,
+                  log_prefix_.c_str(), i + 1, burst_group_size,
                   result.success ? "OK" : "FAIL",
                   result.codewords_ok, result.codewords_ok + result.codewords_failed);
     }

src/gui/modem/streaming_decoder.hpp

@@ -148,9 +148,11 @@ class StreamingDecoder {
     void setChannelInterleave(bool enable) { use_channel_interleave_ = enable; }
     bool getChannelInterleave() const { return use_channel_interleave_; }
 
-    // Burst-level long interleaver (4-frame groups)
+    // Burst-level long interleaver (N-frame groups)
     void setBurstInterleave(bool enable) { use_burst_interleave_ = enable; }
     bool getBurstInterleave() const { return use_burst_interleave_; }
+    void setBurstInterleaveGroupSize(int size);
+    int getBurstInterleaveGroupSize() const { return burst_group_size_; }
 
     // Get current mode
     protocol::WaveformMode getMode() const { return mode_; }
@@ -366,8 +368,8 @@ class StreamingDecoder {
     float burst_snr_ = 0.0f;             // SNR from sync detection
     float burst_cfo_ = 0.0f;             // CFO (updated per frame from pilot tracking)
     std::chrono::steady_clock::time_point burst_start_time_;  // timeout reference
-    static constexpr int BURST_GROUP_SIZE = 4;
-    static constexpr int BURST_TIMEOUT_MS = 8000;  // 4 frames × ~0.7s + margin
+    int burst_group_size_ = 4;
+    static constexpr int BURST_TIMEOUT_MS_BASE = 8000;  // 4 frames × ~0.7s + margin
 
     // Pending frame state for multi-codeword frames
     // After reading header, if more codewords needed, wait for more samples

src/gui/modem/streaming_encoder.cpp

@@ -54,6 +54,10 @@ StreamingEncoder::StreamingEncoder() {
 
 StreamingEncoder::~StreamingEncoder() = default;
 
+void StreamingEncoder::setBurstInterleaveGroupSize(int size) {
+    burst_group_size_ = std::clamp(size, 2, 8);
+}
+
 // ============================================================================
 // MODE CONTROL
 // ============================================================================
@@ -241,9 +245,9 @@ std::vector<float> StreamingEncoder::encodeBurstLight(const std::vector<Bytes>&
         encoded_frames.push_back(encodeFrameBytes(fd));
     }
 
-    // Phase 2: Group into 4-frame subgroups, burst-interleave each group
+    // Phase 2: Group into N-frame subgroups, burst-interleave each group
     // Track which groups are burst-interleaved (for LTS marker)
-    constexpr int BURST_GROUP_SIZE = 4;
+    const int BURST_GROUP_SIZE = std::max(2, burst_group_size_);
     std::vector<bool> frame_is_group_start(encoded_frames.size(), false);
 
     if (use_burst_interleave_) {
@@ -542,9 +546,8 @@ Bytes StreamingEncoder::encodeFrameBytes(const Bytes& frame_data) {
     }
 
     // OFDM: Check if this is a control frame or data/connect frame
-    // Control frames (ACK, NACK, MODE_CHANGE, etc.) are 20 bytes = 1 CW, no interleaving
-    // Connect frames (DISCONNECT) in OFDM mode use 4-CW frame interleaving for fading protection
-    //   (CONNECT/CONNECT_ACK are always MC-DPSK, so only DISCONNECT reaches here)
+    // Control frames (ACK, NACK, MODE_CHANGE, DISCONNECT, etc.) are 20 bytes = 1 CW, no interleaving
+    // Connect handshake frames are always MC-DPSK and do not reach this path.
     // Data frames use 4-CW fixed frame encoding with frame interleaving
     bool is_variable_cw_frame = false;
     if (tx_data.size() >= 3) {
@@ -553,12 +556,12 @@ Bytes StreamingEncoder::encodeFrameBytes(const Bytes& frame_data) {
         if (v2::isControlFrame(ft)) {
             is_variable_cw_frame = true;
         }
-        // Connect frames (DISCONNECT) go through encodeFixedFrame() for 4-CW interleaving
+        // Non-control frames go through encodeFixedFrame() for 4-CW interleaving
     }
 
     if (is_variable_cw_frame) {
         // Variable-CW encoding (no frame interleaving needed)
-        // Control frames = 1 CW, Connect frames = 2 CWs at R1/2
+        // Control frames = 1 CW
         // Control frames always use R1/4: exact fit (20 bytes = 162 info bits / 8)
         // and maximum LDPC redundancy for fading resilience
         auto cws = v2::encodeFrameWithLDPC(tx_data, CodeRate::R1_4);
@@ -569,7 +572,9 @@ Bytes StreamingEncoder::encodeFrameBytes(const Bytes& frame_data) {
         // encoding may produce fewer CWs (e.g. 2 at R1/2 for 44-byte ConnectFrame)
         // ControlFrames (20 bytes) don't have total_cw field — parseHeader() returns 1
         auto ft = static_cast<v2::FrameType>(tx_data[2]);
-        if (v2::isConnectFrame(ft) && tx_data.size() > 16 && tx_data[12] != actual_cw) {
+        if (v2::isConnectFrame(ft) &&
+            tx_data.size() > v2::ControlFrame::SIZE &&
+            tx_data[12] != actual_cw) {
             LOG_MODEM(INFO, "[%s] OFDM: Patching ConnectFrame total_cw %d -> %d",
                       log_prefix_.c_str(), tx_data[12], actual_cw);
             tx_data[12] = actual_cw;

src/gui/modem/streaming_encoder.hpp

@@ -123,9 +123,11 @@ class StreamingEncoder {
     // Frame interleaving is always enabled for OFDM
     bool getFrameInterleave() const { return use_frame_interleave_; }
 
-    // Burst-level long interleaver (spreads CW bytes across 4-frame groups)
+    // Burst-level long interleaver (spreads CW bytes across N-frame groups)
     void setBurstInterleave(bool enable) { use_burst_interleave_ = enable; }
     bool getBurstInterleave() const { return use_burst_interleave_; }
+    void setBurstInterleaveGroupSize(int size);
+    int getBurstInterleaveGroupSize() const { return burst_group_size_; }
 
 private:
     // ========================================================================
@@ -165,7 +167,8 @@ class StreamingEncoder {
     std::unique_ptr<ChannelInterleaver> channel_interleaver_;
     bool use_channel_interleave_ = true;
     bool use_frame_interleave_ = true;     // Always on for OFDM
-    bool use_burst_interleave_ = false;    // Burst-level long interleaver (4-frame groups)
+    bool use_burst_interleave_ = false;    // Burst-level long interleaver (N-frame groups)
+    int burst_group_size_ = 4;
 
     // Logging
     std::string log_prefix_ = "StreamingEncoder";

src/main.cpp

@@ -139,9 +139,9 @@ int runProtocolTx(const char* message, const char* output_file,
         samples = modem.transmit(frame.serialize());
 
     } else if (strcmp(message, "disconnect") == 0) {
-        // DISCONNECT frame with full callsigns
+        // DISCONNECT control frame (hardened 1-CW profile)
         frame_type = "DISCONNECT";
-        auto frame = v2::ConnectFrame::makeDisconnect(src_call, dst_call);
+        auto frame = v2::ControlFrame::makeDisconnect(src_call, dst_call);
         samples = modem.transmit(frame.serialize());
 
     } else {