Feature/signal hunter (#3245)

2026-09-01 20:39:08 +00:00 · 2026-07-06 05:05:49 +02:00
parent fe2ba80a10
commit b99cec5111
12 changed files with 998 additions and 0 deletions
@@ -0,0 +1,189 @@
+/*
+ * Copyright (C) 2026 Matej Sochan
+ *
+ * This file is part of PortaPack.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "proc_signal_hunter.hpp"
+#include "event_m4.hpp"
+#include "portapack_shared_memory.hpp"
+#include "dsp_fir_taps.hpp"
+
+void SignalHunterProcessor::configure() {
+    decim_0.configure(taps_200k_decim_0.taps);
+
+    window_idx = 0;
+    window_sum = 0;
+    for (auto& v : window_buf) v = 0;
+
+    reset_hunt_state();
+    configured = true;
+}
+
+void SignalHunterProcessor::reset_hunt_state() {
+    iq_ring_idx = 0;
+    for (auto& v : iq_ring) v = complex16_t{0, 0};
+    hangtime_counter = 0;
+    hunt_state = HuntState::IDLE;
+    flush_pending = false;
+}
+
+void SignalHunterProcessor::execute(const buffer_c8_t& buffer) {
+    // Process stream closure.
+    // Deferred teardown ensures exclusive mutation of the hunt state by the BasebandThread,
+    // preventing data races with on_message().
+    if (stream_close_requested.exchange(false)) {
+        stream.reset();
+        reset_hunt_state();
+    }
+
+    // CRITICAL IPC FIX: If M0 is tearing down the capture thread, it needs one last buffer
+    // to unblock buffers.get() and exit gracefully. We MUST continue decimating and writing
+    // as long as the stream exists, even if hunting was set to false by a manual UI stop.
+    if (!hunting && !stream) return;
+
+    const auto out = decim_0.execute(buffer, dst_buffer);
+    feed_channel_stats(out);
+
+    // Pre-roll flush: first execute() call after CaptureConfigMessage creates stream.
+    if (flush_pending && stream_active && stream) {
+        // Write ring buffer from oldest to newest sample (2 chunks due to wrap-around)
+        size_t first = IQ_RING_SAMPLES - flush_start_idx;
+        stream->write(&iq_ring[flush_start_idx], first * sizeof(complex16_t));
+        if (flush_start_idx > 0)
+            stream->write(&iq_ring[0], flush_start_idx * sizeof(complex16_t));
+        flush_pending = false;
+    }
+
+    for (size_t i = 0; i < out.count; i++) {
+        auto s = out.p[i];
+
+        iq_ring[iq_ring_idx] = s;
+        iq_ring_idx = (iq_ring_idx + 1) % IQ_RING_SAMPLES;
+
+        uint32_t energy = ((int32_t)s.real() * s.real() + (int32_t)s.imag() * s.imag()) >> 16;
+        window_sum -= window_buf[window_idx];
+        window_buf[window_idx] = energy;
+        window_sum += energy;
+        window_idx = (window_idx + 1) % WINDOW_SIZE;
+
+        uint32_t avg = window_sum / WINDOW_SIZE;
+
+        switch (hunt_state.load()) {
+            case HuntState::IDLE:
+                // Only trigger new recordings if we are actively hunting.
+                // Prevents a stray trigger from starting a new capture right after manual STOP.
+                if (hunting && (avg > energy_threshold)) {
+                    HunterTriggerMessage msg{};
+                    msg.energy = avg;
+                    shared_memory.application_queue.push(msg);
+                    hunt_state = HuntState::AWAITING_STREAM;
+                }
+                break;
+
+            case HuntState::AWAITING_STREAM:
+                break;
+
+            case HuntState::RECORDING:
+                if (avg < energy_threshold) {
+                    hangtime_counter = hangtime_samples_limit;
+                    hunt_state = HuntState::HANGTIME;
+                }
+                break;
+
+            case HuntState::HANGTIME:
+                if (avg > energy_threshold) {
+                    hunt_state = HuntState::RECORDING;
+                } else if (--hangtime_counter == 0) {
+                    HunterStopMessage stop_msg{};
+                    shared_memory.application_queue.push(stop_msg);
+                    hunt_state = HuntState::AWAITING_CLOSE;
+                }
+                break;
+
+            case HuntState::AWAITING_CLOSE:
+                // Do not transition to IDLE by ourselves — wait for CaptureConfigMessage(nullptr)
+                // which arrives via BasebandCapture destructor after CaptureThread is destroyed.
+                break;
+        }
+    }
+
+    // CRITICAL: Continue writing to stream whenever it exists, even in AWAITING_CLOSE state,
+    // and even after a manual STOP — M0's CaptureThread needs this final data to unblock.
+    if (stream_active && stream) {
+        stream->write(out.p, sizeof(complex16_t) * out.count);
+    }
+}
+
+void SignalHunterProcessor::on_message(const Message* const message) {
+    switch (message->id) {
+        case Message::ID::HunterConfig: {
+            const auto& m = *reinterpret_cast<const HunterConfigMessage*>(message);
+            energy_threshold = m.energy_threshold;
+
+            // Convert hangtime to post-decimation samples:
+            // 1 ms = 250 samples @ 250 kHz post-decimation rate (from 2 MHz baseband / 8x decimator)
+            // This dynamic hangtime allows configurable silence tolerance (e.g., 500 ms)
+            hangtime_samples_limit = m.hangtime_ms * 250;
+
+            // Addresses "WHAT-IF" integer underflow
+            if (hangtime_samples_limit == 0) {
+                hangtime_samples_limit = 1;
+            }
+
+            if (!configured) configure();
+
+            // DO NOT close the stream here if (!m.start).
+            // M4 must keep producing buffers until M0 explicitly sends CaptureConfig(nullptr)
+            // to prevent the M0 CaptureThread from deadlocking in buffers.get().
+            hunting = m.start;
+            break;
+        }
+
+        case Message::ID::CaptureConfig: {
+            const auto& m = *reinterpret_cast<const CaptureConfigMessage*>(message);
+
+            if (m.config) {
+                // Synchronous allocation guarantees validity of m.config pointer
+                // (must not be deferred into execute(), see prior HardFault).
+                stream = std::make_unique<StreamInput>(m.config);
+                flush_start_idx = iq_ring_idx;  // Snapshot: current write position
+                flush_pending = true;           // execute() will process ring buffer pre-roll
+                stream_active = true;
+                hunt_state = HuntState::RECORDING;
+            } else {
+                // This is the ONLY safe place to initiate stream teardown —
+                // it arrives after M0's CaptureThread has already fully drained
+                // and exited, so it's safe for execute() to reset() the stream.
+                stream_active = false;
+                stream_close_requested = true;
+            }
+
+            break;
+        }
+
+        default:
+            break;
+    }
+}
+
+int main() {
+    EventDispatcher event_dispatcher{std::make_unique<SignalHunterProcessor>()};
+    event_dispatcher.run();
+    return 0;
+}