rigplane 2.7.0__tar.gz → 2.7.2__tar.gz

{rigplane-2.7.0 → rigplane-2.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rigplane
-Version: 2.7.0
+Version: 2.7.2
 Summary: Multi-vendor radio control library and Web UI with native providers and planned Hamlib-backed CAT coverage
 Project-URL: Homepage, https://rigplane.dev/
 Project-URL: Documentation, https://rigplane.dev/

{rigplane-2.7.0 → rigplane-2.7.2}/docs/CHANGELOG.md

@@ -11,6 +11,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.7.2] — 2026-05-30
+
+### Fixed
+
+- Desktop RX audio: resume the `AudioContext` from the LIVE user-gesture so streamed RX audio plays under WKWebView/autoplay-restricted contexts, and recover from suspended-context frame drops instead of silently dropping them (MOR-239, #1694, 921f4c88)
+- Audio scope: dispatch audio-FFT frames to `/api/v1/audio-scope` for radios without a hardware scope (e.g. Xiegu X6200), fixing the blank AUDIO SCOPE panel; hardware-scope radios (IC-7610) are unchanged (MOR-241, #1695, 4e98ab0d)
+- Serial USB-audio TX: arm the PCM TX path in the shared serial Icom base so bridge TX reaches the radio (IC-705/IC-7300/IC-9700/X6200) instead of raising "PCM TX not started" per frame; the audio bridge now degrades to RX-only on TX failure instead of spamming (MOR-242, #1696, 37fe3d0a)
+
+## [2.7.1] — 2026-05-29
+
+### Fixed
+- USB audio now clamps the requested channel count to the device's real
+  capability (`input_channels` for RX, `output_channels` for TX) at stream
+  open, mirroring the existing sample-rate negotiation. Any mono USB codec
+  self-heals instead of failing the global stereo default with PortAudio
+  `-9998` ("Invalid number of channels") and starving the stream; the Xiegu
+  X6200 mono RX path no longer depends on its profile `codec_preference`
+  entry (verified on hardware). The effective channel count and its source
+  are recorded on the stream contract for diagnostics (#1692).
+
 ## [2.7.0] — 2026-05-29
 
 ### Added
@@ -1523,7 +1543,9 @@ These deprecation closures were announced in v0.19 and dropped on schedule.
 - Transport layer, authentication, CI-V commands, meters, PTT, keep-alive.
 - Clean-room Icom LAN UDP protocol implementation.
 
-[Unreleased]: https://github.com/rigplane/rigplane-core/compare/v2.7.0...HEAD
+[Unreleased]: https://github.com/rigplane/rigplane-core/compare/v2.7.2...HEAD
+[2.7.2]: https://github.com/rigplane/rigplane-core/compare/v2.7.1...v2.7.2
+[2.7.1]: https://github.com/rigplane/rigplane-core/compare/v2.7.0...v2.7.1
 [2.7.0]: https://github.com/rigplane/rigplane-core/compare/v2.6.0...v2.7.0
 [2.6.0]: https://github.com/rigplane/rigplane-core/compare/v2.5.1...v2.6.0
 [2.5.1]: https://github.com/rigplane/rigplane-core/compare/v2.5.0...v2.5.1

{rigplane-2.7.0 → rigplane-2.7.2}/frontend/src/lib/audio/__tests__/rx-player.test.ts

@@ -248,3 +248,79 @@ describe('RxPlayer jitter bounds (#1363)', () => {
     p.stop();
   });
 });
+
+describe('RxPlayer suspended-context recovery (MOR-239)', () => {
+  it('start() resumes a context that is created suspended (WKWebView autoplay)', () => {
+    ctx.state = 'suspended';
+    const p = new RxPlayer();
+    p.start();
+    expect(ctx.resume).toHaveBeenCalled();
+    p.stop();
+  });
+
+  it('drops the frame while suspended but re-attempts resume and warns (not silent)', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    ctx.state = 'suspended';
+    const p = new RxPlayer();
+    p.start();
+    ctx.resume.mockClear();
+
+    p.feed(pcm16(480));
+
+    // Frame can't play on a suspended ctx, but instead of a silent return
+    // we re-attempt resume() and surface a warning so it's observable.
+    expect(ctx.createBufferSource).not.toHaveBeenCalled();
+    expect(ctx.resume).toHaveBeenCalled();
+    expect(warn).toHaveBeenCalled();
+    p.stop();
+    warn.mockRestore();
+  });
+
+  it('plays frames once the context has resumed to running', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    ctx.state = 'suspended';
+    const p = new RxPlayer();
+    p.start();
+    p.feed(pcm16(480));           // dropped — suspended
+    expect(ctx._lastSrc).toBeNull();
+
+    ctx.state = 'running';        // resume() honoured by the gesture
+    p.feed(pcm16(480));           // now audible
+    expect(ctx.createBufferSource).toHaveBeenCalled();
+    expect(ctx._lastSrc.start).toHaveBeenCalled();
+    p.stop();
+    warn.mockRestore();
+  });
+
+  it('re-attempts resume on focus/visibility regain (WKWebView re-suspend)', () => {
+    ctx.state = 'suspended';
+    const p = new RxPlayer();
+    p.start();
+    ctx.resume.mockClear();
+    window.dispatchEvent(new Event('focus'));
+    expect(ctx.resume).toHaveBeenCalled();
+    p.stop();
+    // After stop the listener must be gone — no further resume calls.
+    ctx.resume.mockClear();
+    window.dispatchEvent(new Event('focus'));
+    expect(ctx.resume).not.toHaveBeenCalled();
+  });
+});
+
+describe('RxPlayer mono routing (MOR-239)', () => {
+  it('routes a mono (1-ch) PCM16 buffer to the audible MAIN channel', () => {
+    const p = new RxPlayer();
+    p.start();                    // default focus='both' → MAIN gain audible
+    p.feed(pcm16(480));           // header marks 1 channel
+
+    // Mono buffer allocated as 1 channel...
+    expect(ctx.createBuffer).toHaveBeenCalledWith(1, 480, SAMPLE_RATE);
+    // ...fed into preGain (→ splitter[0] → mainGain → mainPanner → destination).
+    const [preGain, mainGain] = ctx._gains;
+    expect(ctx._lastSrc.connect).toHaveBeenCalledWith(preGain);
+    // MAIN channel must carry audible gain so mono lands on an output, not
+    // only on the silenced SUB (channel 1) of the splitter.
+    expect(mainGain.gain.value).toBeGreaterThan(0);
+    p.stop();
+  });
+});

{rigplane-2.7.0 → rigplane-2.7.2}/frontend/src/lib/audio/audio-manager.ts

@@ -228,6 +228,10 @@ class AudioManager {
       setAudioConnected(true);
       console.log('[audio-ws] connected');
       if (this._rxEnabled) {
+        // Idempotent resume nudge: if the AudioContext re-entered
+        // 'suspended' while the WS was down (WKWebView backgrounding), wake
+        // it as we resubscribe so streamed frames are not dropped.
+        this.rxPlayer.start();
         ws.send(JSON.stringify({
           type: 'audio_start',
           direction: 'rx',

{rigplane-2.7.0 → rigplane-2.7.2}/frontend/src/lib/audio/rx-player.ts

@@ -51,6 +51,12 @@ export class RxPlayer {
   private _floorSec = 0.05;
   private _ceilingSec = 0.30;
 
+  // Count of frames dropped because the context was suspended (autoplay
+  // policy). Surfaced via console.warn so a silent no-audio state is
+  // observable instead of invisible. Reset once the context resumes.
+  private _droppedSuspendedFrames = 0;
+  private _resumeListenersAttached = false;
+
   get volume(): number {
     return this._volume;
   }
@@ -104,9 +110,18 @@ export class RxPlayer {
     return this.ctx !== null && this.ctx.state !== 'closed';
   }
 
+  /** Start (or resume) playback.
+   *
+   * MUST be called synchronously from a user-gesture handler (e.g. the LIVE
+   * button click): WKWebView / mobile-Safari autoplay policy only honours
+   * ``AudioContext.resume()`` when it runs inside the gesture's call stack.
+   * Calling again on an existing context is a cheap idempotent resume — the
+   * AudioManager re-invokes start() on ``audio_start`` and reconnect to keep
+   * nudging a context that re-entered ``suspended``.
+   */
   start(): void {
     if (this.ctx) {
-      if (this.ctx.state === 'suspended') this.ctx.resume();
+      this._resume();
       return;
     }
     const Ctx = globalThis.AudioContext ?? (globalThis as any).webkitAudioContext;
@@ -129,9 +144,8 @@ export class RxPlayer {
     this.subPanner.connect(this.ctx.destination);
     this._applyGraphState();
     this.nextPlayTime = 0;
-    if (this.ctx.state === 'suspended') {
-      this.ctx.resume().catch(() => {});
-    }
+    this._attachResumeListeners();
+    this._resume();
   }
 
   stop(): void {
@@ -139,6 +153,7 @@ export class RxPlayer {
       try { this.decoder.close(); } catch { /* ok */ }
       this.decoder = null;
     }
+    this._detachResumeListeners();
     if (this.ctx) {
       this.ctx.close().catch(() => {});
       this.ctx = null;
@@ -151,6 +166,66 @@ export class RxPlayer {
     }
     this.nextPlayTime = 0;
     this.opusTs = 0;
+    this._droppedSuspendedFrames = 0;
+  }
+
+  /** Best-effort resume of a suspended context. Safe to call repeatedly. */
+  private _resume(): void {
+    if (this.ctx && this.ctx.state === 'suspended') {
+      this.ctx.resume().catch(() => {});
+    }
+  }
+
+  /** Resume-on-regain-focus handler: WKWebView re-suspends an AudioContext
+   *  when the webview is backgrounded; resume it when we come back. Bound as
+   *  an arrow property so add/removeEventListener see a stable reference. */
+  private _onResumeEvent = (): void => {
+    this._resume();
+  };
+
+  private _attachResumeListeners(): void {
+    if (this._resumeListenersAttached) return;
+    if (typeof document !== 'undefined') {
+      document.addEventListener('visibilitychange', this._onResumeEvent);
+    }
+    if (typeof window !== 'undefined') {
+      window.addEventListener('focus', this._onResumeEvent);
+    }
+    this._resumeListenersAttached = true;
+  }
+
+  private _detachResumeListeners(): void {
+    if (!this._resumeListenersAttached) return;
+    if (typeof document !== 'undefined') {
+      document.removeEventListener('visibilitychange', this._onResumeEvent);
+    }
+    if (typeof window !== 'undefined') {
+      window.removeEventListener('focus', this._onResumeEvent);
+    }
+    this._resumeListenersAttached = false;
+  }
+
+  /** Returns true when frames can be scheduled (context running). When the
+   *  context is suspended this re-attempts resume() and warns — rather than
+   *  silently dropping every frame, which previously made a stuck-suspended
+   *  context (no sound, blank scope) impossible to diagnose. */
+  private _ensureRunning(): boolean {
+    if (!this.ctx) return false;
+    if (this.ctx.state === 'running') {
+      this._droppedSuspendedFrames = 0;
+      return true;
+    }
+    if (this.ctx.state === 'suspended') {
+      this._resume();
+      this._droppedSuspendedFrames++;
+      if (this._droppedSuspendedFrames <= 3 || this._droppedSuspendedFrames % 200 === 0) {
+        console.warn(
+          `RxPlayer: AudioContext suspended — dropped ${this._droppedSuspendedFrames} ` +
+          `frame(s), retrying resume(). Audio needs a user gesture (click LIVE).`,
+        );
+      }
+    }
+    return false;
   }
 
   /** Feed a raw binary frame from WS */
@@ -174,7 +249,7 @@ export class RxPlayer {
 
   private playPcm16(payload: Uint8Array, sr: number, ch: number): void {
     if (!this.ctx || !this.preGain) return;
-    if (this.ctx.state === 'suspended') return;
+    if (!this._ensureRunning()) return;
     const channels = ch === 2 ? 2 : 1;
     const frameCount = Math.floor(payload.byteLength / (2 * channels));
     if (frameCount <= 0) return;
@@ -194,7 +269,7 @@ export class RxPlayer {
 
   private decodeOpus(payload: Uint8Array, sr: number, ch: number): void {
     if (!this.ctx || !this.preGain) return;
-    if (this.ctx.state === 'suspended') return;
+    if (!this._ensureRunning()) return;
     if (typeof AudioDecoder === 'undefined') return;
 
     if (!this.decoder) {

{rigplane-2.7.0 → rigplane-2.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rigplane"
-version = "2.7.0"
+version = "2.7.2"
 description = "Multi-vendor radio control library and Web UI with native providers and planned Hamlib-backed CAT coverage"
 readme = "README.md"
 license = "MIT"

{rigplane-2.7.0 → rigplane-2.7.2}/src/rigplane/audio/bridge.py

@@ -478,11 +478,25 @@ class AudioBridge:
 
         # --- TX path: virtual device input → radio ---
         if self._tx_enabled:
-            await self._radio.start_audio_tx_pcm(
-                sample_rate=self._sample_rate,
-                channels=self._channels,
-                frame_ms=self._frame_ms,
-            )
+            try:
+                await self._radio.start_audio_tx_pcm(
+                    sample_rate=self._sample_rate,
+                    channels=self._channels,
+                    frame_ms=self._frame_ms,
+                )
+            except (RuntimeError, NotImplementedError) as exc:
+                # The radio cannot arm a PCM TX stream (e.g. a serial backend
+                # that never set up its USB-audio TX path). Degrade to RX-only
+                # instead of spinning a _tx_loop that would reject — and log —
+                # every captured frame (MOR-242).
+                self._tx_enabled = False
+                self._tx_started = False
+                logger.warning(
+                    "%s: radio rejected TX start (%s); running RX-only",
+                    self._label,
+                    exc,
+                )
+                return
             self._tx_started = True
 
             tx_dev_id = dev_id
@@ -829,6 +843,17 @@ class AudioBridge:
 
                 try:
                     await self._radio.push_audio_tx_pcm(pcm_bytes)
+                except (RuntimeError, NotImplementedError) as exc:
+                    # The radio cannot accept PCM TX frames (TX path not armed).
+                    # Degrade to RX-only and stop the loop instead of rejecting
+                    # — and logging — every captured frame (MOR-242).
+                    self._tx_enabled = False
+                    logger.warning(
+                        "%s: radio rejected TX frame (%s); switching to RX-only",
+                        self._label,
+                        exc,
+                    )
+                    return
                 except Exception:
                     if self._tx_frames <= 5:
                         logger.warning("%s: TX push error", self._label, exc_info=True)

{rigplane-2.7.0 → rigplane-2.7.2}/src/rigplane/audio/usb_driver.py

@@ -111,6 +111,7 @@ class UsbAudioStreamContract:
     channels: int
     frame_ms: int
     sample_rate_source: str
+    channel_source: str = "requested"
     fallback_reason: str | None = None
 
     def to_dict(self) -> dict[str, object]:
@@ -121,6 +122,7 @@ class UsbAudioStreamContract:
             "channels": self.channels,
             "frame_ms": self.frame_ms,
             "sample_rate_source": self.sample_rate_source,
+            "channel_source": self.channel_source,
         }
         if self.fallback_reason:
             payload["fallback_reason"] = self.fallback_reason
@@ -480,6 +482,35 @@ class UsbAudioDriver:
     def _sample_rate_candidates(self, requested: int) -> tuple[int, ...]:
         return tuple(dict.fromkeys((requested, *_DEFAULT_SAMPLE_RATE_CANDIDATES)))
 
+    def _clamp_channels(
+        self,
+        *,
+        direction: str,
+        device: UsbAudioDevice,
+        requested_channels: int,
+    ) -> tuple[int, str, str | None]:
+        """Clamp requested channels to the device's real capability (MOR-238).
+
+        A profile / codec may request stereo from a device that only exposes a
+        mono capture (or playback) endpoint. PortAudio rejects that open with
+        PaErrorCode -9998 ("Invalid number of channels"). Mirroring the
+        sample-rate negotiation, the effective channel count is clamped down to
+        what the device advertises so any mono/stereo USB codec self-heals
+        without a per-profile ``codec_preference`` entry. Downstream DSP is
+        48 kHz mono, so a 1-channel capture feeds the broadcaster cleanly.
+        """
+
+        device_max = (
+            device.input_channels if direction == "rx" else device.output_channels
+        )
+        # A device advertising zero channels for this direction is a selection
+        # bug, not a clamp target — leave the request untouched and let the
+        # open surface the real error.
+        if device_max >= 1 and requested_channels > device_max:
+            reason = f"channels-{requested_channels}-clamped-to-device-{device_max}"
+            return device_max, "device-clamp", reason
+        return requested_channels, "requested", None
+
     def _resolve_stream_contract(
         self,
         *,
@@ -491,6 +522,11 @@ class UsbAudioDriver:
         allow_sample_rate_fallback: bool,
     ) -> UsbAudioStreamContract:
         device_id = AudioDeviceId(device.index)
+        effective_channels, channel_source, channel_reason = self._clamp_channels(
+            direction=direction,
+            device=device,
+            requested_channels=channels,
+        )
         if self._backend.check_sample_rate(
             device_id,
             requested_sample_rate,
@@ -501,9 +537,11 @@ class UsbAudioDriver:
                 direction=direction,
                 device=device,
                 sample_rate_hz=requested_sample_rate,
-                channels=channels,
+                channels=effective_channels,
                 frame_ms=frame_ms,
                 sample_rate_source=source,
+                channel_source=channel_source,
+                fallback_reason=channel_reason,
             )
 
         if not allow_sample_rate_fallback:
@@ -521,16 +559,21 @@ class UsbAudioDriver:
                 candidate,
                 direction=direction,
             ):
+                sample_reason = f"sample-rate-{requested_sample_rate}-unsupported"
+                fallback_reason = (
+                    f"{sample_reason}; {channel_reason}"
+                    if channel_reason
+                    else sample_reason
+                )
                 return UsbAudioStreamContract(
                     direction=direction,
                     device=device,
                     sample_rate_hz=candidate,
-                    channels=channels,
+                    channels=effective_channels,
                     frame_ms=frame_ms,
                     sample_rate_source="fallback",
-                    fallback_reason=(
-                        f"sample-rate-{requested_sample_rate}-unsupported"
-                    ),
+                    channel_source=channel_source,
+                    fallback_reason=fallback_reason,
                 )
 
         raise AudioDriverLifecycleError(
@@ -595,18 +638,21 @@ class UsbAudioDriver:
             # RX frames reaching the browser.
             logger.info(
                 "usb-audio: opening RX capture — device=[%d] %s, %d Hz, "
-                "%d ch, %d ms (device input_channels=%d)",
+                "%d ch (requested %d, source=%s), %d ms "
+                "(device input_channels=%d)",
                 selected_rx.index,
                 selected_rx.name,
                 contract.sample_rate_hz,
+                contract.channels,
                 ch,
+                contract.channel_source,
                 fm,
                 selected_rx.input_channels,
             )
             self._rx_stream = self._backend.open_rx(
                 AudioDeviceId(selected_rx.index),
                 sample_rate=contract.sample_rate_hz,
-                channels=ch,
+                channels=contract.channels,
                 frame_ms=fm,
             )
             await self._rx_stream.start(callback)
@@ -657,7 +703,7 @@ class UsbAudioDriver:
             self._tx_stream = self._backend.open_tx(
                 AudioDeviceId(selected_tx.index),
                 sample_rate=contract.sample_rate_hz,
-                channels=ch,
+                channels=contract.channels,
                 frame_ms=fm,
             )
             await self._tx_stream.start()

{rigplane-2.7.0 → rigplane-2.7.2}/src/rigplane/backends/_icom_serial_base.py

@@ -454,7 +454,38 @@ class _IcomSerialRadioBase(CoreRadio):
         await self._serial_audio_driver.stop_rx()
 
     # ------------------------------------------------------------------
-    # Audio TX
+    # Audio TX (Opus)
+    # ------------------------------------------------------------------
+
+    async def start_audio_tx_opus(self) -> None:
+        self._check_connected()
+        await self._serial_audio_driver.start_tx(
+            sample_rate=self.audio_sample_rate,
+            channels=self._serial_audio_channels_for_codec(),
+            frame_ms=20,
+        )
+
+    async def push_audio_tx_opus(self, opus_data: bytes) -> None:
+        self._check_connected()
+        if not self._serial_audio_driver.tx_running:
+            raise RuntimeError("Audio TX not started")
+        payload = bytes(opus_data)
+        if self._serial_codec_is_opus():
+            transcoder = self._get_pcm_transcoder(
+                sample_rate=self.audio_sample_rate,
+                channels=self._serial_audio_channels_for_codec(),
+                frame_ms=20,
+            )
+            payload = transcoder.opus_to_pcm(payload)
+        await self._serial_audio_driver._push_tx_pcm(payload)
+
+    async def stop_audio_tx_opus(self) -> None:
+        await self._serial_audio_driver.stop_tx()
+        self._pcm_tx_fmt = None
+
+    # ------------------------------------------------------------------
+    # Audio TX (PCM) — arms ``_pcm_tx_fmt`` so ``push_audio_tx_pcm`` works
+    # over the serial USB CODEC path (MOR-242).
     # ------------------------------------------------------------------
 
     async def start_audio_tx_pcm(
@@ -485,15 +516,51 @@ class _IcomSerialRadioBase(CoreRadio):
                 "sample_rate * frame_ms must produce an integer frame size."
             )
 
+        # Icom USB CODEC mic input is mono-only by hardware; the LAN path
+        # enforces this by forcing txcodec to a mono value in _send_conninfo
+        # (issue #794).  For the serial path we clamp channels to 1 here so
+        # that PortAudio always opens the USB CODEC as a mono output stream.
+        # Opening with channels=2 causes the radio ALC to behave erratically
+        # for the first 5-10 seconds of TX (GH#1382 regression; consistent with
+        # the MOR-238 RX clamp).
+        tx_channels = 1
+
         self._check_connected()
         await self._serial_audio_driver.start_tx(
             sample_rate=sample_rate,
-            channels=channels,
+            channels=tx_channels,
             frame_ms=frame_ms,
         )
+        self._pcm_tx_fmt = (sample_rate, tx_channels, frame_ms)
+
+    async def push_audio_tx_pcm(
+        self,
+        pcm_bytes: bytes | bytearray | memoryview,
+    ) -> None:
+        self._check_connected()
+        if self._pcm_tx_fmt is None:
+            raise RuntimeError(
+                "PCM TX not started; call start_audio_tx_pcm() before push_audio_tx_pcm()."
+            )
+        if not isinstance(pcm_bytes, (bytes, bytearray, memoryview)):
+            raise AudioFormatError("PCM input must be bytes-like.")
+        sample_rate, channels, frame_ms = self._pcm_tx_fmt
+        if (sample_rate * frame_ms) % 1000 != 0:
+            raise AudioFormatError(
+                "sample_rate * frame_ms must produce an integer frame size."
+            )
+        frame_samples = (sample_rate * frame_ms) // 1000
+        expected = frame_samples * channels * 2
+        frame = bytes(pcm_bytes)
+        if len(frame) != expected:
+            raise AudioFormatError(
+                f"PCM frame size mismatch: expected {expected} bytes "
+                f"({frame_ms}ms at {sample_rate}Hz, {channels}ch s16le), got {len(frame)}."
+            )
+        await self._serial_audio_driver._push_tx_pcm(frame)
 
     async def stop_audio_tx_pcm(self) -> None:
-        await self._serial_audio_driver.stop_tx()
+        await self.stop_audio_tx_opus()
 
     async def _push_pcm_tx(self, frame: bytes) -> None:
         if not isinstance(frame, bytes):
@@ -613,8 +680,17 @@ class _IcomSerialRadioBase(CoreRadio):
     # ------------------------------------------------------------------
 
     async def _stop_serial_audio_driver(self) -> None:
-        await self._serial_audio_driver.stop_rx()
-        await self._serial_audio_driver.stop_tx()
+        self._pcm_tx_fmt = None
+        self._pcm_rx_user_callback = None
+        self._opus_rx_user_callback = None
+        try:
+            await self._serial_audio_driver.stop_tx()
+        except Exception:
+            logger.debug("serial-audio: failed to stop TX path", exc_info=True)
+        try:
+            await self._serial_audio_driver.stop_rx()
+        except Exception:
+            logger.debug("serial-audio: failed to stop RX path", exc_info=True)
 
     def _ensure_scope_baud_guardrail(self) -> None:
         if self._serial_baudrate >= _SERIAL_SCOPE_MIN_BAUD:

rigplane-2.7.2/src/rigplane/backends/icom7610/serial.py

@@ -0,0 +1,52 @@
+"""Serial adaptation layer for the IC-7610 backend."""
+
+from __future__ import annotations
+
+import logging
+
+from ...exceptions import CommandError
+from .._icom_serial_base import _IcomSerialRadioBase, _SERIAL_SCOPE_MIN_BAUD
+
+logger = logging.getLogger(__name__)
+
+__all__ = ["Icom7610SerialRadio"]
+
+
+class Icom7610SerialRadio(_IcomSerialRadioBase):
+    """IC-7610 backend wired to shared core over serial CI-V session driver.
+
+    The audio TX (Opus + PCM) path and audio-driver teardown live in
+    ``_IcomSerialRadioBase`` (lifted there in MOR-242); this subclass only
+    carries the IC-7610-specific RX-PCM delegation and the scope baud
+    guardrail that raises ``CommandError``.
+    """
+
+    _DEFAULT_MODEL = ""
+
+    # ------------------------------------------------------------------
+    # IC-7610 specific: stop_audio_rx_pcm delegates to stop_audio_rx_opus
+    # ------------------------------------------------------------------
+
+    async def stop_audio_rx_pcm(self) -> None:
+        self._pcm_rx_user_callback = None
+        await self.stop_audio_rx_opus()
+
+    # ------------------------------------------------------------------
+    # IC-7610 specific: scope guardrail uses CommandError
+    # ------------------------------------------------------------------
+
+    def _ensure_scope_baud_guardrail(self) -> None:
+        if self._serial_baudrate >= _SERIAL_SCOPE_MIN_BAUD:
+            return
+
+        msg = (
+            "Scope over serial requires baudrate >= "
+            f"{_SERIAL_SCOPE_MIN_BAUD} for stable command path; got baudrate="
+            f"{self._serial_baudrate}. Set allow_low_baud_scope=True to override."
+        )
+        if not self._allow_low_baud_scope:
+            raise CommandError(msg)
+
+        if not self._low_baud_scope_warned:
+            logger.warning("%s Running with override may increase timeout risk.", msg)
+            self._low_baud_scope_warned = True

{rigplane-2.7.0 → rigplane-2.7.2}/src/rigplane/web/server.py

@@ -413,10 +413,12 @@ class WebServer:
         _has_scope = (CAP_SCOPE in radio.capabilities) if radio is not None else False
         if radio is not None and _has_audio:
             self._audio_fft_scope = AudioFftScope(fft_size=2048, fps=20, avg_count=2)
-            self._audio_fft_scope.on_frame(self._broadcast_audio_scope)
+            # AudioFftScope.on_frame() is a single-slot setter: register one
+            # dispatch method that fans out to BOTH broadcasters. Registering
+            # twice would clobber the first callback (MOR-241).
+            self._audio_fft_scope.on_frame(self._dispatch_audio_fft_frame)
             if not _has_scope:
-                # No hardware scope — audio FFT also feeds /api/v1/scope
-                self._audio_fft_scope.on_frame(self._broadcast_scope)
+                # No hardware scope — audio FFT also feeds /api/v1/scope.
                 self._audio_broadcaster.set_pcm_tap(self._audio_fft_scope.feed_audio)
             logger.info(
                 "Audio FFT scope available (has_audio=%s, has_hw_scope=%s)",
@@ -609,6 +611,24 @@ class WebServer:
             if self._radio is not None:
                 self._set_scope_data_callback(self._broadcast_scope)
 
+    def _dispatch_audio_fft_frame(self, frame: Any) -> None:
+        """Fan out an audio FFT frame to the relevant scope channels.
+
+        Single registered callback for :class:`AudioFftScope` (whose
+        ``on_frame`` is a single-slot setter). Always feeds the dedicated
+        ``/api/v1/audio-scope`` channel. For radios WITHOUT a hardware scope
+        the same frame also drives ``/api/v1/scope`` (the main panadapter),
+        since those radios derive their spectrum from RX audio. Hardware-scope
+        radios (e.g. IC-7610) keep ``/api/v1/scope`` sourced exclusively from
+        the real scope, so the audio FFT never touches it (MOR-241).
+        """
+        self._broadcast_audio_scope(frame)
+        _has_scope = (
+            CAP_SCOPE in self._radio.capabilities if self._radio is not None else False
+        )
+        if not _has_scope:
+            self._broadcast_scope(frame)
+
     def _broadcast_scope(self, frame: Any) -> None:
         """Broadcast scope frame to all registered handlers.