Harden OFDM light sync transition and add simulator regression sweep

Author: secup

src/gui/modem/modem_mode.cpp

@@ -50,14 +50,22 @@ void ModemEngine::setWaveformMode(protocol::WaveformMode mode) {
     // When disconnected, always use MC_DPSK for PING detection (chirp-based sync)
     if (streaming_decoder_) {
         protocol::WaveformMode decoder_mode = connected_ ? mode : protocol::WaveformMode::MC_DPSK;
-        streaming_decoder_->setMode(decoder_mode, connected_);
-
-        // For OFDM modes, propagate the current config (for custom FFT/carriers like NVIS mode)
-        if (mode == protocol::WaveformMode::OFDM_COX ||
-            mode == protocol::WaveformMode::OFDM_CHIRP) {
-            streaming_decoder_->setOFDMConfig(config_);
-            LOG_MODEM(INFO, "setWaveformMode: StreamingDecoder OFDM config set (FFT=%d, carriers=%d)",
+        if (connected_ &&
+            (mode == protocol::WaveformMode::OFDM_COX ||
+             mode == protocol::WaveformMode::OFDM_CHIRP)) {
+            streaming_decoder_->setConnectedOFDMMode(mode, config_, data_modulation_, data_code_rate_);
+            LOG_MODEM(INFO, "setWaveformMode: StreamingDecoder connected OFDM config set (FFT=%d, carriers=%d)",
                       config_.fft_size, config_.num_carriers);
+        } else {
+            streaming_decoder_->setMode(decoder_mode, connected_);
+
+            // For OFDM modes, propagate the current config (for custom FFT/carriers like NVIS mode)
+            if (mode == protocol::WaveformMode::OFDM_COX ||
+                mode == protocol::WaveformMode::OFDM_CHIRP) {
+                streaming_decoder_->setOFDMConfig(config_);
+                LOG_MODEM(INFO, "setWaveformMode: StreamingDecoder OFDM config set (FFT=%d, carriers=%d)",
+                          config_.fft_size, config_.num_carriers);
+            }
         }
     }
 
@@ -141,8 +149,8 @@ void ModemEngine::setConnected(bool connected) {
             // For OFDM modes, propagate the correct config (with proper pilot settings)
             if (waveform_mode_ == protocol::WaveformMode::OFDM_COX ||
                 waveform_mode_ == protocol::WaveformMode::OFDM_CHIRP) {
-                streaming_decoder_->setOFDMConfig(config_);
-                streaming_decoder_->setDataMode(data_modulation_, data_code_rate_);
+                streaming_decoder_->setConnectedOFDMMode(
+                    waveform_mode_, config_, data_modulation_, data_code_rate_);
             }
 
             // Propagate known CFO from handshake to StreamingDecoder
@@ -224,10 +232,17 @@ void ModemEngine::setDataMode(Modulation mod, CodeRate rate) {
     // Update StreamingDecoder's waveform configuration
     // CRITICAL: Set OFDM config BEFORE setDataMode so decoder has correct pilot layout
     if (streaming_decoder_) {
-        if (waveform_mode_ != protocol::WaveformMode::MC_DPSK) {
-            streaming_decoder_->setOFDMConfig(config_);
+        if (connected_ &&
+            (waveform_mode_ == protocol::WaveformMode::OFDM_CHIRP ||
+             waveform_mode_ == protocol::WaveformMode::OFDM_COX)) {
+            streaming_decoder_->setConnectedOFDMMode(
+                waveform_mode_, config_, mod, rate);
+        } else {
+            if (waveform_mode_ != protocol::WaveformMode::MC_DPSK) {
+                streaming_decoder_->setOFDMConfig(config_);
+            }
+            streaming_decoder_->setDataMode(mod, rate);
         }
-        streaming_decoder_->setDataMode(mod, rate);
     }
 
     // Update StreamingEncoder to match

src/gui/modem/streaming_decoder.cpp

@@ -509,23 +509,23 @@ void StreamingDecoder::searchForSync() {
                               current_modulation_ == Modulation::BPSK);
     const float fading_hint = last_fading_index_.load();
     const float snr_hint = last_snr_.load();
-    float light_sync_min_confidence = is_coherent ? 0.88f : 0.70f;
-    float weak_sync_floor = is_coherent ? 0.80f : 0.30f;
+    float light_sync_min_confidence = is_coherent ? 0.90f : 0.72f;
+    float weak_sync_floor = is_coherent ? 0.85f : 0.55f;
     if (!is_coherent) {
         // OTA HF can produce valid LTS peaks in the 0.55-0.65 range during
         // fades. Start conservative, but avoid hard-locking to 0.70.
         if (fading_hint >= 1.00f || snr_hint < 10.0f) {
-            light_sync_min_confidence = 0.55f;
+            light_sync_min_confidence = 0.62f;
         } else if (fading_hint >= 0.70f || snr_hint < 14.0f) {
-            light_sync_min_confidence = 0.58f;
+            light_sync_min_confidence = 0.65f;
         } else if (fading_hint >= 0.50f || snr_hint < 18.0f) {
-            light_sync_min_confidence = 0.62f;
+            light_sync_min_confidence = 0.68f;
         }
 
         if (connected_ && sync_reject_streak_ >= 8) {
-            float extra_relax = std::min(0.18f,
+            float extra_relax = std::min(0.12f,
                                          0.015f * static_cast<float>(sync_reject_streak_ - 7));
-            light_sync_min_confidence = std::max(0.45f, light_sync_min_confidence - extra_relax);
+            light_sync_min_confidence = std::max(0.56f, light_sync_min_confidence - extra_relax);
         }
     }
 
@@ -540,8 +540,9 @@ void StreamingDecoder::searchForSync() {
         if (found && sync_result.correlation < light_sync_min_confidence) {
             bool allow_weak_accept = !is_coherent &&
                                      connected_ &&
-                                     sync_reject_streak_ >= 4 &&
-                                     sync_result.correlation >= weak_sync_floor;
+                                     sync_reject_streak_ >= 3 &&
+                                     sync_result.correlation >= std::max(weak_sync_floor,
+                                                                          light_sync_min_confidence - 0.08f);
             if (allow_weak_accept) {
                 weak_accept = true;
                 LOG_MODEM(INFO, "[%s] DATA sync weak-accepted (corr=%.2f < %.2f, streak=%llu)",
@@ -839,8 +840,10 @@ void StreamingDecoder::decodeCurrentFrame() {
     if (mode_ == protocol::WaveformMode::MC_DPSK) {
         training_skip = 4608;  // training + ref samples
     } else {
-        // OFDM: check after preamble (2 LTS = ~1024 samples)
-        training_skip = 1024;
+        // OFDM: check after light preamble (training symbols)
+        // Must be waveform/config dependent (FFT/CP/carriers).
+        int data_preamble = waveform_->getDataPreambleSamples();
+        training_skip = (data_preamble > 0) ? static_cast<size_t>(data_preamble) : size_t(1024);
     }
 
     // Compute training region RMS (signal + noise)
@@ -1493,6 +1496,55 @@ void StreamingDecoder::setOFDMConfig(const ModemConfig& config) {
     interleaver_ = std::make_unique<ChannelInterleaver>(bps, v2::LDPC_CODEWORD_BITS);
 }
 
+void StreamingDecoder::setConnectedOFDMMode(protocol::WaveformMode mode,
+                                            const ModemConfig& config,
+                                            Modulation mod,
+                                            CodeRate rate) {
+    std::lock_guard<std::mutex> lock(buffer_mutex_);
+
+    mode_ = mode;
+    connected_ = true;
+    code_rate_ = rate;
+    current_modulation_ = mod;
+    ofdm_carriers_ = config.num_carriers;
+    ofdm_data_carriers_ = config.getDataCarriers();
+
+    if (mode_ == protocol::WaveformMode::OFDM_CHIRP) {
+        waveform_ = std::make_unique<OFDMChirpWaveform>(config);
+    } else {
+        waveform_ = std::make_unique<OFDMNvisWaveform>(config);
+    }
+
+    if (waveform_) {
+        waveform_->configure(mod, rate);
+    }
+
+    // Query waveform for effective pilot layout after configure().
+    int pilot_spacing = waveform_ ? waveform_->getPilotSpacing() : 0;
+    if (pilot_spacing > 0) {
+        int pilot_count = (ofdm_carriers_ + pilot_spacing - 1) / pilot_spacing;
+        ofdm_data_carriers_ = ofdm_carriers_ - pilot_count;
+    } else {
+        ofdm_data_carriers_ = ofdm_carriers_;
+    }
+
+    size_t bps = ofdm_data_carriers_ * getBitsPerSymbol(mod);
+    interleaver_ = std::make_unique<ChannelInterleaver>(bps, v2::LDPC_CODEWORD_BITS);
+
+    state_ = DecoderState::SEARCHING;
+    pending_total_cw_ = 0;
+    sync_reject_streak_ = 0;
+    constellation_cache_.clear();
+    constellation_cache_time_ = std::chrono::steady_clock::time_point{};
+    burst_soft_buffer_.clear();
+    correlation_pos_ = write_pos_;
+
+    LOG_MODEM(INFO, "StreamingDecoder: connected OFDM mode=%s, mod=%s, rate=%s, carriers=%d data=%d bps=%zu",
+              protocol::waveformModeToString(mode_),
+              modulationToString(mod), codeRateToString(rate),
+              ofdm_carriers_, ofdm_data_carriers_, bps);
+}
+
 void StreamingDecoder::setDataMode(Modulation mod, CodeRate rate) {
     std::lock_guard<std::mutex> lock(buffer_mutex_);
     code_rate_ = rate;

src/gui/modem/streaming_decoder.hpp

@@ -143,6 +143,13 @@ class StreamingDecoder {
     // Use this for NVIS mode (1024 FFT, 59 carriers) or custom OFDM settings
     void setOFDMConfig(const ModemConfig& config);
 
+    // Atomically apply OFDM connected-mode settings to avoid transient
+    // mode/config mismatches during handshake transitions.
+    void setConnectedOFDMMode(protocol::WaveformMode mode,
+                              const ModemConfig& config,
+                              Modulation mod,
+                              CodeRate rate);
+
     // Set data mode (modulation and code rate) for the waveform
     // Called when connection is established with negotiated settings
     void setDataMode(Modulation mod, CodeRate rate);

src/ofdm/demodulator.cpp

@@ -865,8 +865,6 @@ bool OFDMDemodulator::process(SampleSpan samples) {
             LOG_SYNC(INFO, "SYNC: offset=%zu, corr=%.3f, CFO=%.1f Hz, buffer=%zu",
                      sync_offset, sync_corr, coarse_cfo, impl_->rx_buffer.size());
 
-            impl_->last_sync_offset = sync_offset;
-
             // LTS fine timing
             size_t sts_start = sync_offset;
             size_t refined_lts_start = impl_->refineLTSTiming(sts_start);
@@ -886,18 +884,28 @@ bool OFDMDemodulator::process(SampleSpan samples) {
                 LOG_SYNC(INFO, "LTS fine timing: coarse_lts=%zu, refined=%zu, delta=%+d samples",
                          coarse_lts_pos, refined_lts_start, timing_refinement);
 
+                // Report true preamble start for diagnostics/tests.
+                // In practice the Schmidl-Cox coarse peak tends to land one symbol late,
+                // so refined_lts_start is commonly the SECOND LTS symbol.
+                // Preamble layout: 4 STS + 2 LTS.
+                if (refined_lts_start >= 5 * preamble_symbol_len) {
+                    impl_->last_sync_offset = refined_lts_start - 5 * preamble_symbol_len;
+                } else {
+                    impl_->last_sync_offset = 0;
+                }
+
                 // Check if differential mode for LTS phase extraction
                 bool is_differential = (impl_->config.modulation == Modulation::DQPSK ||
                                         impl_->config.modulation == Modulation::D8PSK ||
                                         impl_->config.modulation == Modulation::DBPSK);
                 LOG_SYNC(DEBUG, "LTS phase check: is_differential=%d, use_pilots=%d",
                         is_differential, impl_->config.use_pilots);
 
-                // Consume preamble: from start up through LTS
-                // Data starts after: refined_lts_start + 2 LTS symbols
-                size_t consume = refined_lts_start + 2 * preamble_symbol_len + impl_->manual_timing_offset;
-                LOG_SYNC(DEBUG, "Consume calc: refined_lts=%zu + 2*preamble_sym=%zu + offset=%d = %zu",
-                        refined_lts_start, 2 * preamble_symbol_len, impl_->manual_timing_offset, consume);
+                // Consume preamble up through last LTS. With second-LTS lock, data starts
+                // one symbol after refined_lts_start.
+                size_t consume = refined_lts_start + preamble_symbol_len + impl_->manual_timing_offset;
+                LOG_SYNC(DEBUG, "Consume calc: refined_lts=%zu + preamble_sym=%zu + offset=%d = %zu",
+                        refined_lts_start, preamble_symbol_len, impl_->manual_timing_offset, consume);
                 impl_->rx_buffer.erase(impl_->rx_buffer.begin(),
                                        impl_->rx_buffer.begin() + consume);
 
@@ -945,14 +953,19 @@ bool OFDMDemodulator::process(SampleSpan samples) {
     if (impl_->state.load() == Impl::State::SYNCED) {
         // Check for new preamble (mid-frame detection)
         bool should_check_preamble = impl_->synced_symbol_count.load() > 0 &&
-                                      impl_->idle_call_count.load() >= 2;
+                                      impl_->idle_call_count.load() >= 2 &&
+                                      impl_->soft_bits.empty();
 
         if (should_check_preamble && impl_->rx_buffer.size() >= preamble_total_len) {
             size_t search_limit = std::min(impl_->rx_buffer.size() - preamble_total_len,
                                            impl_->symbol_samples * 2);
             constexpr size_t STEP = 8;
 
             for (size_t offset = 0; offset <= search_limit; offset += STEP) {
+                if (!impl_->hasMinimumEnergy(offset, correlation_window)) {
+                    continue;
+                }
+
                 float corr = impl_->measureCorrelation(offset);
                 if (corr > impl_->sync_threshold) {
                     size_t sts_start = offset;
@@ -963,7 +976,7 @@ bool OFDMDemodulator::process(SampleSpan samples) {
                         continue;
                     }
 
-                    size_t consume = refined_lts_start + 2 * preamble_symbol_len;
+                    size_t consume = refined_lts_start + preamble_symbol_len;
 
                     LOG_SYNC(INFO, "SYNCED preamble: sts=%zu, refined_lts=%zu, consume=%zu",
                              sts_start, refined_lts_start, consume);
@@ -1462,6 +1475,7 @@ bool OFDMDemodulator::searchForSync(SampleSpan samples, size_t& out_position, fl
     // Search for preamble
     bool found_sync = false;
     size_t sync_offset = 0;
+    size_t refined_lts_offset = 0;
     float sync_cfo = 0.0f;
 
     size_t search_end = impl_->rx_buffer.size() - preamble_total_len - correlation_window;
@@ -1501,10 +1515,11 @@ bool OFDMDemodulator::searchForSync(SampleSpan samples, size_t& out_position, fl
                 if (refined_lts != SIZE_MAX) {
                     found_sync = true;
                     sync_offset = peak_pos;
+                    refined_lts_offset = refined_lts;
                     sync_cfo = impl_->estimateCoarseCFO(peak_pos);
 
-                    LOG_SYNC(INFO, "searchForSync: found at %zu, corr=%.3f, CFO=%.1f Hz",
-                             sync_offset, peak_corr, sync_cfo);
+                    LOG_SYNC(INFO, "searchForSync: found at %zu (LTS=%zu), corr=%.3f, CFO=%.1f Hz",
+                             sync_offset, refined_lts_offset, peak_corr, sync_cfo);
                     break;
                 }
             }
@@ -1517,12 +1532,10 @@ bool OFDMDemodulator::searchForSync(SampleSpan samples, size_t& out_position, fl
     if (found_sync) {
         out_cfo_hz = sync_cfo;
 
-        // Calculate where LTS (training) starts
-        // Preamble: 4 STS + 2 LTS = 6 symbols
-        // processPresynced expects samples starting at LTS (it needs training for channel est)
-        // So we return position of LTS start (after 4 STS symbols)
-        size_t sts_symbols = 4;
-        out_position = sync_offset + sts_symbols * preamble_symbol_len;
+        // processPresynced expects samples starting at FIRST LTS.
+        out_position = (refined_lts_offset >= preamble_symbol_len)
+            ? (refined_lts_offset - preamble_symbol_len)
+            : refined_lts_offset;
     }
 
     return found_sync;

src/ofdm/ofdm_sync.cpp

@@ -410,11 +410,13 @@ size_t OFDMDemodulator::Impl::refineLTSTiming(size_t coarse_sts_start) {
     }
     energy_ref *= 0.5f;
 
-    size_t expected_lts = 4 * preamble_sym_len;
+    size_t expected_lts = coarse_lts_start;
     float corr_at_expected = 0.0f;
 
-    for (int delta = -SEARCH_BACK; delta <= SEARCH_FWD; ++delta) {
-        size_t offset = coarse_lts_start + delta;
+    auto compute_lts_corr = [&](size_t offset) -> float {
+        if (offset + lts_passband_I.size() > rx_buffer.size()) {
+            return 0.0f;
+        }
 
         float corr_I = 0.0f;
         float corr_Q = 0.0f;
@@ -429,7 +431,12 @@ size_t OFDMDemodulator::Impl::refineLTSTiming(size_t coarse_sts_start) {
 
         float corr_mag = std::sqrt(corr_I * corr_I + corr_Q * corr_Q);
         float norm = std::sqrt(energy_rx * energy_ref);
-        float corr = (norm > 1e-6f) ? corr_mag / norm : 0.0f;
+        return (norm > 1e-6f) ? corr_mag / norm : 0.0f;
+    };
+
+    for (int delta = -SEARCH_BACK; delta <= SEARCH_FWD; ++delta) {
+        size_t offset = coarse_lts_start + delta;
+        float corr = compute_lts_corr(offset);
 
         if (corr > best_corr) {
             best_corr = corr;
@@ -445,6 +452,22 @@ size_t OFDMDemodulator::Impl::refineLTSTiming(size_t coarse_sts_start) {
              expected_lts, corr_at_expected, best_offset, best_corr,
              (int)best_offset - (int)expected_lts);
 
+    // LTS appears twice with near-identical correlation. If we lock onto the second
+    // one, data extraction starts one symbol late and decode reliability drops sharply.
+    // Prefer the previous-symbol candidate when it's close in correlation.
+    if (best_offset >= preamble_sym_len) {
+        size_t prev_lts = best_offset - preamble_sym_len;
+        if (prev_lts >= coarse_lts_start - SEARCH_BACK) {
+            float prev_corr = compute_lts_corr(prev_lts);
+            if (prev_corr >= best_corr * 0.92f) {
+                LOG_SYNC(DEBUG, "LTS ambiguity: prefer earlier LTS %zu (corr=%.3f) over %zu (corr=%.3f)",
+                         prev_lts, prev_corr, best_offset, best_corr);
+                best_offset = prev_lts;
+                best_corr = prev_corr;
+            }
+        }
+    }
+
     int timing_correction = (int)best_offset - (int)coarse_lts_start;
     LOG_SYNC(DEBUG, "LTS fine timing: coarse=%zu, refined=%zu, correction=%+d samples, corr=%.3f",
              coarse_lts_start, best_offset, timing_correction, best_corr);

src/waveform/ofdm_chirp_waveform.cpp

@@ -267,10 +267,10 @@ bool OFDMChirpWaveform::detectDataSync(SampleSpan samples, SyncResult& result,
     int best_offset = 0;
     Complex best_p(0.0f, 0.0f);
 
-    // When buffer starts with signal (burst continuation), use wider search window
-    // to find the LTS peak anywhere in the buffer. LTS autocorrelation (~0.99) is
-    // much higher than random data autocorrelation (~0.2-0.4).
-    int actual_search_window = signal_in_noise ? search_window : static_cast<int>(samples.size());
+    // Keep search local to expected frame start. Scanning the full buffer makes
+    // payload autocorrelation peaks compete with LTS and increases false locks.
+    int max_connected_search = std::max(search_window, symbol_samples * 8);
+    int actual_search_window = signal_in_noise ? search_window : max_connected_search;
     int search_end = std::min(static_cast<int>(signal_start) + actual_search_window,
                               static_cast<int>(samples.size()) - symbol_samples * 2);