rigplane 2.0.2__tar.gz → 2.0.3__tar.gz

{rigplane-2.0.2 → rigplane-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rigplane
-Version: 2.0.2
+Version: 2.0.3
 Summary: Python library for controlling Icom transceivers over LAN (UDP) — no wfview/hamlib required
 Project-URL: Homepage, https://rigplane.dev/
 Project-URL: Documentation, https://rigplane.dev/

{rigplane-2.0.2 → rigplane-2.0.3}/docs/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.0.3] — 2026-05-07
+
+### Fixed
+- WSJT-X LAN TX audio on direct Icom LAN: send raw PCM when conninfo negotiates `PCM_1CH_16BIT` instead of pushing Opus bytes into the radio's PCM TX stream (#1430, #1448, 999953e2). Adds explicit TX codec tracking; routes WSJT-X packet modes to DATA2/LAN only for direct Icom multi-DATA radios; keeps DATA1 user-owned (prewarm/profile-apply/state-restore no longer rewrite DATA1 MOD input). Validated on IC-7610 LAN — continuous TX audio reaches the radio.
+
+### Other
+- Align `tests/test_pcm_e2e.py` with the new PCM-passthrough TX path: pin `_audio_tx_codec = AudioCodec.OPUS_1CH` on the test radio so the dummy transcoder is exercised, and use a properly-sized 1920-byte synthetic frame for loopback TX (6ad40e91, #1448 follow-up).
+
 ## [2.0.2] — 2026-05-06
 
 ### Added
@@ -1223,7 +1231,8 @@ 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.0.2...HEAD
+[Unreleased]: https://github.com/rigplane/rigplane-core/compare/v2.0.3...HEAD
+[2.0.3]: https://github.com/rigplane/rigplane-core/compare/v2.0.2...v2.0.3
 [2.0.2]: https://github.com/rigplane/rigplane-core/compare/v2.0.1...v2.0.2
 [2.0.1]: https://github.com/rigplane/rigplane-core/compare/v2.0.0...v2.0.1
 [2.0.0]: https://github.com/rigplane/rigplane-core/compare/v1.1.0...v2.0.0

{rigplane-2.0.2 → rigplane-2.0.3}/docs/api/audio.md

@@ -144,17 +144,18 @@ limit is undocumented but observed empirically and matches the wfview source:
 // wfview: audio.data.mid(len, 1364)
 ```
 
-`push_tx()` (and the high-level `push_audio_tx_pcm()`) automatically chunk oversized payloads:
+`push_tx()` automatically chunks oversized payloads:
 
 ```
-push_audio_tx_pcm(pcm_frame)  # 1920-byte 20ms PCM frame @ 48kHz/16-bit
+push_tx(pcm_frame)  # 1920-byte 20ms PCM frame @ 48kHz/16-bit
   → chunk 0: bytes [0 : 1364]    → 1364-byte UDP payload  ✓
   → chunk 1: bytes [1364 : 1920] →  556-byte UDP payload  ✓
 ```
 
 The two chunk sizes — 1364 and 556 bytes — correspond to the fixed audio payload sizes
-documented in wfview for the IC-7610. Callers do not need to pre-chunk frames; any frame size
-is accepted.
+documented in wfview for the IC-7610. Low-level callers do not need to pre-chunk payloads.
+The high-level `push_audio_tx_pcm()` API still requires one complete PCM frame at the
+configured sample rate, channel count, and frame duration.
 
 ## Usage
 
@@ -204,10 +205,15 @@ async with create_radio(config) as radio:
 config = LanBackendConfig(host="192.168.1.100", username="u", password="p")
 async with create_radio(config) as radio:
     await radio.start_audio_tx_opus()
-    await radio.push_audio_tx_opus(opus_frame)
+    await radio.push_audio_tx_opus(audio_payload)
     await radio.stop_audio_tx_opus()
 ```
 
+The low-level method names are historical. For direct Icom LAN sessions,
+rigplane currently negotiates TX as `PCM_1CH_16BIT`, so the TX payload sent to
+the radio is raw PCM16LE. Opus TX payloads are only valid for endpoints that
+negotiate an Opus TX codec, such as wfview-compatible server paths.
+
 ### TX Audio (high-level PCM)
 
 ```python
@@ -294,5 +300,6 @@ For RX PCM, migrate callback-side decoding to the built-in API:
 
 For TX PCM, migrate manual Opus encoding to the built-in API:
 
-- Before: encode PCM to Opus yourself, then `push_audio_tx_opus()`.
+- Before: manually prepare the low-level negotiated-codec payload and call
+  `push_audio_tx_opus()`.
 - Now: `start_audio_tx_pcm()` and `push_audio_tx_pcm()` with fixed-size PCM frames.

{rigplane-2.0.2 → rigplane-2.0.3}/docs/guide/profiles.md

@@ -47,7 +47,7 @@ async with create_radio(config) as radio:
 | `vfo` | `str \| None` | `None` | Select VFO: `"A"` or `"B"` |
 | `data_mode` | `bool \| None` | `None` | `True` = enable DATA mode, `False` = disable |
 | `data_off_mod_input` | `int \| None` | `None` | DATA-OFF modulation input source index |
-| `data1_mod_input` | `int \| None` | `None` | DATA-1 modulation input source index |
+| `data1_mod_input` | `int \| None` | `None` | DATA-1 modulation input source index. Captured for compatibility; apply/restore do not rewrite it because DATA1 is user-owned. |
 | `squelch_level` | `int \| None` | `None` | Squelch level (0 = open) |
 | `equalize_vfo` | `bool` | `False` | Copy active VFO to both VFOs |
 | `scope_enabled` | `bool \| None` | `None` | `True` = enable spectrum scope |

{rigplane-2.0.2 → rigplane-2.0.3}/docs/guide/wsjtx-setup.md

@@ -97,6 +97,18 @@ When a CAT client connects for the first time:
 - This eliminates a known first-TX latency when WSJT-X switches
   from plain SSB to packet mode (PKTUSB).
 
+When `--wsjtx-compat` is used with a direct Icom LAN radio connection on a
+radio profile with multiple DATA sub-modes such as the IC-7610, rigplane treats
+WSJT-X packet-mode requests as LAN audio operation:
+
+- `PKTUSB`, `PKTLSB`, and `PKTRTTY` are mapped to DATA2 instead of DATA1.
+- DATA2 modulation input is set to LAN.
+- DATA1 modulation input is not changed.
+
+For USB/serial radio connections, including cases where rigplane bridges local
+USB audio devices for remote use, the compatibility mapping remains the legacy
+DATA1 behavior.
+
 ### When to use it
 
 - **Use** `--wsjtx-compat` if you run WSJT-X, JTDX, or JS8Call
@@ -106,8 +118,10 @@ When a CAT client connects for the first time:
 
 ### What it changes on the radio
 
-Only the DATA mode flag (CI-V `0x1A 0x06`). It does **not** change
-frequency, power, filter, or any other setting.
+In USB/serial CAT operation, only the DATA mode flag (CI-V `0x1A 0x06`) is
+changed. In direct Icom LAN operation on multi-DATA radios, rigplane may also
+set the selected LAN DATA sub-mode's modulation input to LAN. DATA1 is treated
+as user-owned and is not rewritten by prewarm, profile apply, or state restore.
 
 ## Known Behavior
 

rigplane-2.0.3/docs/plans/2026-05-07-audio-route-resolver-design.md

@@ -0,0 +1,120 @@
+# Audio Route Resolver Design
+
+**Date:** 2026-05-07
+**Status:** design
+**Scope:** rigplane-core route contract, with rigplane-pro integration notes
+
+## Problem
+
+`--bridge` is an implementation mechanism, not enough information to decide how
+CAT packet modes should be mapped on the radio.
+
+Two valid setups both use a bridge but need different radio policies:
+
+- Direct Icom LAN radio: TX audio is streamed to the radio over the Icom LAN
+  audio session. WSJT-X packet modes should use DATA2 with DATA2 MOD input LAN
+  on multi-DATA radios such as the IC-7610.
+- USB/serial radio with local or remote audio bridge: TX audio reaches the radio
+  through the radio's USB audio device or another local input. WSJT-X packet
+  modes should keep the legacy DATA1 behavior, usually with DATA1 MOD input USB.
+
+The route decision must therefore come from the actual radio transport and audio
+capabilities, not from whether a local loopback bridge is enabled.
+
+## Design Principle
+
+`bridge` means "local audio loopback mechanism".
+
+`audio route` means "source of truth for radio audio and DATA-mode policy".
+
+DATA2/LAN is only valid when TX audio really enters the radio over direct Icom
+LAN audio. DATA1 remains user-owned unless a future explicit USB route policy
+chooses to manage DATA1 MOD input.
+
+## Core Route Model
+
+Add a small route model in core:
+
+```python
+@dataclass(frozen=True)
+class AudioRoute:
+    radio_transport: Literal["lan", "serial", "remote"]
+    tx_audio_source: Literal["lan", "usb", "acc", "unavailable"]
+    rx_audio_source: Literal["lan", "usb", "acc", "unavailable"]
+    data_mode_policy: Literal["data2_lan", "data1_usb", "legacy"]
+    bridge_required: bool
+```
+
+Initial policy mapping:
+
+| Condition | Route | DATA policy |
+| --- | --- | --- |
+| direct Icom LAN backend, native LAN audio, multi-DATA radio | `tx_audio_source="lan"` | `data2_lan` |
+| direct Icom LAN backend, single-DATA radio | `tx_audio_source="lan"` | `legacy` |
+| Icom serial/USB backend with local USB audio bridge | `tx_audio_source="usb"` | `data1_usb` or legacy DATA1 |
+| remote/pro server | declared by server capabilities | route decided from server declaration |
+| no usable audio route | `tx_audio_source="unavailable"` | no automatic DATA source changes |
+
+## Core Responsibilities
+
+Core should:
+
+- expose backend identity and audio capabilities in a machine-readable form;
+- resolve `AudioRoute` from the active radio/backend/profile;
+- derive `RigctldConfig.wsjtx_data_mode` and `wsjtx_data_mod_input` from
+  `AudioRoute.data_mode_policy`;
+- keep `push_audio_tx_pcm()` aligned with the negotiated TX codec, not method
+  names such as `push_audio_tx_opus`;
+- avoid automatic DATA1 MOD writes in prewarm, profile apply, and state restore.
+
+Core should not:
+
+- treat `--bridge` as proof of LAN audio;
+- infer USB vs LAN from a virtual audio device name;
+- make proprietary product decisions about always-on bridge UX.
+
+## Pro Responsibilities
+
+Pro should start with `audio_route=auto` by default:
+
+1. connect to the radio or remote server;
+2. read backend/capability information;
+3. resolve the audio route;
+4. start the required LAN session, USB bridge, virtual device, or remote bridge;
+5. configure embedded rigctld from the route policy;
+6. show a user-facing route status such as:
+   - `Audio: LAN direct`
+   - `Audio: USB via local bridge`
+   - `Audio: USB via remote server`
+   - `Audio unavailable: <reason>`
+
+Pro should preserve explicit override controls for support and debugging, but
+the default commercial experience should not require the user to know whether to
+pass `--bridge`.
+
+## Testing Strategy
+
+Core tests should cover:
+
+- direct LAN route resolves to DATA2/LAN on multi-DATA profiles;
+- direct LAN route falls back on single-DATA profiles;
+- serial/USB route with bridge does not select DATA2/LAN;
+- rigctld packet mode mapping follows route-derived config;
+- profile apply and restore never rewrite DATA1 MOD automatically;
+- codec contract sends PCM as raw PCM when negotiated TX codec is PCM.
+
+Pro tests should cover:
+
+- startup auto-routes direct LAN, serial/USB, and remote server scenarios;
+- bridge lifecycle follows the resolved route, not user-visible flags;
+- diagnostics and UI expose the selected route and failure reason;
+- explicit overrides can force or disable bridge behavior for support cases.
+
+## Migration Plan
+
+1. Keep the current backend-based guard as a short-term safety patch.
+2. Add `AudioRoute` and a resolver in core.
+3. Replace direct `backend_id` checks in CLI/rigctld wiring with route-derived
+   policy.
+4. Expose route information through diagnostics/status APIs.
+5. Update pro to default to auto route and consume the core resolver/status.

rigplane-2.0.3/docs/plans/issue-drafts/2026-05-07-core-audio-pipeline-test-harness.md

@@ -0,0 +1,98 @@
+# Core Issue Draft: Build automated audio pipeline harness for WSJT-X/LAN/USB routing
+
+## Context
+
+Debugging the IC-7610 TX audio bridge required repeated manual steps across
+machines: start rigplane, start WSJT-X, press Tune, listen locally, watch the
+radio waterfall, inspect logs, and infer whether the failure was PortAudio,
+bridge capture, codec negotiation, rigctld packet mode, DATA source selection,
+or LAN audio TX payload format.
+
+That workflow is too slow and too fragile for future audio work. We need an
+automated harness that exercises the whole pipeline with synthetic audio and
+observable sinks.
+
+Related route-policy issue: rigplane/rigplane-core#1446.
+
+## Goal
+
+Create a layered audio pipeline test harness that can run without a human
+pressing WSJT-X Tune, while still allowing optional hardware-assisted validation
+against real radios.
+
+## Proposed Test Layers
+
+### Layer 1: Pure in-process pipeline
+
+- Synthetic PCM source, e.g. 1 kHz tone frames.
+- Fake bridge input/output devices.
+- Fake radio audio sink that records pushed TX payloads.
+- Assertions:
+  - non-zero peak/RMS reaches bridge TX capture path;
+  - expected frame count and continuity;
+  - PCM TX stays raw PCM when negotiated codec is `PCM_1CH_16BIT`;
+  - Opus encode is used only when negotiated TX codec is Opus;
+  - no silence is introduced by downmix/resampling/chunking.
+
+### Layer 2: rigctld + bridge integration
+
+- Run embedded rigctld against fake radio/backend.
+- Replay WSJT-X-like rigctl commands: `M PKTUSB`, `T 1`, `T 0`.
+- Feed synthetic audio during the TX window.
+- Assertions:
+  - PTT transitions occur;
+  - packet mode maps to the route-derived DATA policy;
+  - DATA1 MOD is not touched automatically;
+  - TX audio payload continues for the whole TX window.
+
+### Layer 3: OS audio backend smoke
+
+- Use PortAudio/sounddevice with a deterministic local virtual device when
+  available, or a fake backend in CI.
+- Feed synthetic tone into the configured TX device.
+- Capture through the same backend path used by `AudioBridge`.
+- Assertions:
+  - device selection uses the requested RX/TX devices;
+  - capture is non-zero under the same process/env as rigplane;
+  - no regression to all-zero capture when RX output is also open.
+
+### Layer 4: hardware-assisted validation
+
+- Optional test profile for real IC-7610 LAN at a configured host.
+- No WSJT-X UI dependency: drive rigctld commands and synthetic audio directly.
+- Capture logs and radio-side ACK/state where possible.
+- Assertions:
+  - route policy selects DATA2/LAN for direct LAN multi-DATA radio;
+  - raw PCM TX produces continuous radio TX audio symptoms;
+  - no broad intermittent burst pattern from Opus-as-PCM mismatch.
+
+## Requirements
+
+- Tests must run through `uv`.
+- CI-safe layers must not require radio hardware, microphone permissions, or
+  BlackHole/VB-Cable.
+- Hardware/OS layers must be opt-in through environment variables and skip with
+  clear reasons.
+- The harness must produce compact diagnostics: route, codec, frame count, RMS,
+  peak, drops, selected devices, and rigctld DATA policy.
+- The harness must not depend on the WSJT-X GUI. WSJT-X behavior should be
+  represented by rigctl command replay and synthetic audio generation.
+
+## Acceptance Criteria
+
+- A developer can run one command to validate the in-process TX audio pipeline.
+- A developer can run one command to validate rigctld packet-mode + TX audio
+  bridge behavior without a radio.
+- Optional OS/hardware tests are documented and skipped unless explicitly
+  enabled.
+- The previous IC-7610 failure modes would have been caught by automated tests:
+  - PCM negotiated but Opus bytes sent;
+  - DATA1 selected for direct LAN WSJT-X bridge;
+  - DATA1 MOD rewritten by profile apply/restore;
+  - PortAudio bridge TX capture reads all-zero frames.
+
+## Notes
+
+This is open-core scope because it validates generic audio routing, codec
+contract, rigctld behavior, and backend-independent diagnostics. Pro can consume
+the same harness for packaged desktop smoke tests.

rigplane-2.0.3/docs/plans/issue-drafts/2026-05-07-core-audio-route-resolver.md

@@ -0,0 +1,34 @@
+# Core Issue Draft: Design and implement AudioRoute resolver for WSJT-X DATA policy
+
+## Context
+
+During IC-7610 LAN TX bridge debugging we found that `--bridge` is not a reliable signal for choosing radio DATA policy. A bridge can be used both for direct Icom LAN audio workflows and for USB/serial audio workflows. Those require different packet-mode behavior:
+
+- Direct Icom LAN TX audio: WSJT-X `PKTUSB`/`PKTLSB`/`PKTRTTY` should map to DATA2/LAN on multi-DATA radios such as IC-7610.
+- USB/serial audio route, even with a local bridge: packet mode should remain legacy DATA1/USB behavior.
+
+Canonical design doc: `docs/plans/2026-05-07-audio-route-resolver-design.md`.
+
+## Requirements
+
+- Add a core `AudioRoute` model/resolver that derives radio audio route from backend/profile/capabilities, not from `--bridge`.
+- Route policies must distinguish at least:
+  - direct Icom LAN audio -> `data2_lan` when the profile supports multiple DATA modes;
+  - direct Icom LAN single-DATA profile -> legacy fallback;
+  - Icom serial/USB audio bridge -> DATA1/USB or legacy DATA1, never DATA2/LAN;
+  - unavailable/unknown route -> no automatic DATA source changes.
+- Replace direct CLI/backend guard logic with route-derived `RigctldConfig` wiring.
+- Keep DATA1 MOD user-owned by default: no automatic DATA1 MOD writes from prewarm, profile apply, or state restore.
+- Keep TX codec behavior aligned with negotiated TX codec: direct Icom LAN PCM TX must send raw PCM, not Opus bytes.
+
+## Acceptance Criteria
+
+- Unit tests cover route resolution for direct LAN, serial/USB bridge, single-DATA fallback, and unavailable route.
+- Rigctld tests prove packet-mode mapping follows route-derived policy.
+- CLI/web startup tests prove route policy is not inferred from `--bridge` alone.
+- Docs explain `bridge` vs `audio route` and DATA1/DATA2 ownership.
+- Existing WSJT-X compatibility behavior is preserved for non-LAN routes.
+
+## Notes
+
+This is open-core scope: protocol correctness, backend capability modeling, route-derived rigctld policy, and public docs. Product auto-start behavior belongs in rigplane-pro.

{rigplane-2.0.2 → rigplane-2.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rigplane"
-version = "2.0.2"
+version = "2.0.3"
 description = "Python library for controlling Icom transceivers over LAN (UDP) — no wfview/hamlib required"
 readme = "README.md"
 license = "MIT"

{rigplane-2.0.2 → rigplane-2.0.3}/src/rigplane/audio/lan_stream.py

@@ -593,7 +593,7 @@ class AudioStream:
         self._tx_packets_sent = 0
         logger.info("Audio TX started")
 
-    async def push_tx(self, opus_data: bytes) -> None:
+    async def push_tx(self, audio_data: bytes) -> None:
         """Send an audio frame to the radio.
 
         Large payloads (e.g. raw PCM) are automatically chunked to fit the
@@ -601,7 +601,7 @@ class AudioStream:
         matching the wfview chunking behaviour.
 
         Args:
-            opus_data: Audio data (Opus-encoded or raw PCM).
+            audio_data: Payload encoded with the negotiated TX audio codec.
 
         Raises:
             RuntimeError: If not in transmitting state.
@@ -609,7 +609,7 @@ class AudioStream:
         if self._state != AudioState.TRANSMITTING:
             raise RuntimeError(f"Cannot push TX in state {self._state}")
 
-        data = opus_data
+        data = audio_data
         offset = 0
         while offset < len(data):
             chunk = data[offset : offset + MAX_AUDIO_PAYLOAD]
@@ -670,17 +670,17 @@ def parse_audio_packet(data: bytes) -> AudioPacket | None:
 
 
 def build_audio_packet(
-    opus_data: bytes,
+    audio_data: bytes,
     *,
     sender_id: int,
     receiver_id: int,
     send_seq: int,
     ident: int = TX_IDENT,
 ) -> bytes:
-    """Build a raw UDP audio packet from Opus data.
+    """Build a raw UDP audio packet from negotiated-codec audio data.
 
     Args:
-        opus_data: Opus-encoded audio frame.
+        audio_data: Audio payload encoded with the negotiated stream codec.
         sender_id: Our connection ID.
         receiver_id: Radio's connection ID.
         send_seq: Audio-level sequence number.
@@ -689,7 +689,7 @@ def build_audio_packet(
     Returns:
         Complete UDP packet bytes ready to send.
     """
-    total_len = AUDIO_HEADER_SIZE + len(opus_data)
+    total_len = AUDIO_HEADER_SIZE + len(audio_data)
     pkt = bytearray(total_len)
 
     struct.pack_into("<I", pkt, 0x00, total_len)  # len (LE)
@@ -700,7 +700,7 @@ def build_audio_packet(
     struct.pack_into("<H", pkt, 0x10, ident)  # ident (LE)
     struct.pack_into(">H", pkt, 0x12, send_seq)  # sendseq (BE)
     # 0x14: unused (stays 0)
-    struct.pack_into(">H", pkt, 0x16, len(opus_data))  # datalen (BE)
+    struct.pack_into(">H", pkt, 0x16, len(audio_data))  # datalen (BE)
 
-    pkt[AUDIO_HEADER_SIZE:] = opus_data
+    pkt[AUDIO_HEADER_SIZE:] = audio_data
     return bytes(pkt)

{rigplane-2.0.2 → rigplane-2.0.3}/src/rigplane/cli/__init__.py

@@ -2499,6 +2499,11 @@ def _detect_loopback_hint() -> str | None:
     return None
 
 
+def _uses_direct_lan_audio(radio: Radio) -> bool:
+    """Return True when the active radio backend streams TX audio over Icom LAN."""
+    return getattr(radio, "backend_id", None) == "rigplane"
+
+
 def _print_startup_banner(
     *,
     radio: Radio,
@@ -2727,10 +2732,20 @@ async def _cmd_web(radio: Radio, args: argparse.Namespace) -> int:
         from rigplane.rigctld.server import RigctldServer
 
         rigctld_port = getattr(args, "web_rigctld_port", 4532)
+        wsjtx_compat = getattr(args, "wsjtx_compat", False)
+        wsjtx_data_mode = None
+        wsjtx_data_mod_input = None
+        if wsjtx_compat and _uses_direct_lan_audio(radio):
+            profile = getattr(radio, "profile", None)
+            if getattr(profile, "data_mode_count", 1) >= 2:
+                wsjtx_data_mode = 2
+                wsjtx_data_mod_input = 5  # IC-7610 DATA2 MOD input: LAN
         rigctld_config = RigctldConfig(
             host="0.0.0.0",
             port=rigctld_port,
-            wsjtx_compat=getattr(args, "wsjtx_compat", False),
+            wsjtx_compat=wsjtx_compat,
+            wsjtx_data_mode=wsjtx_data_mode,
+            wsjtx_data_mod_input=wsjtx_data_mod_input,
         )
         candidate = RigctldServer(radio, rigctld_config)
         try:

{rigplane-2.0.2 → rigplane-2.0.3}/src/rigplane/commands/config.py

@@ -180,8 +180,8 @@ def set_data1_mod_input(
     from_addr: int = CONTROLLER_ADDR,
     cmd_map: CommandMap | None = None,
 ) -> bytes:
-    if not 0 <= source <= 4:
-        raise ValueError(f"DATA1 mod input must be 0-4, got {source}")
+    if not 0 <= source <= 5:
+        raise ValueError(f"DATA1 mod input must be 0-5, got {source}")
     return _build_ctl_mem_set(
         _CTL_MEM_DATA1_MOD_INPUT,
         source,
@@ -211,8 +211,8 @@ def set_data2_mod_input(
     from_addr: int = CONTROLLER_ADDR,
     cmd_map: CommandMap | None = None,
 ) -> bytes:
-    if not 0 <= source <= 4:
-        raise ValueError(f"DATA2 mod input must be 0-4, got {source}")
+    if not 0 <= source <= 5:
+        raise ValueError(f"DATA2 mod input must be 0-5, got {source}")
     return _build_ctl_mem_set(
         _CTL_MEM_DATA2_MOD_INPUT,
         source,
@@ -242,8 +242,8 @@ def set_data3_mod_input(
     from_addr: int = CONTROLLER_ADDR,
     cmd_map: CommandMap | None = None,
 ) -> bytes:
-    if not 0 <= source <= 4:
-        raise ValueError(f"DATA3 mod input must be 0-4, got {source}")
+    if not 0 <= source <= 5:
+        raise ValueError(f"DATA3 mod input must be 0-5, got {source}")
     return _build_ctl_mem_set(
         _CTL_MEM_DATA3_MOD_INPUT,
         source,

{rigplane-2.0.2 → rigplane-2.0.3}/src/rigplane/rigctld/contract.py

@@ -381,4 +381,6 @@ class RigctldConfig:
     max_line_length: int = 1024  # max bytes per command line (OOM guard)
     poll_interval: float = 0.2  # seconds between autonomous poll cycles
     wsjtx_compat: bool = False  # pre-warm DATA mode for WSJT-X-style CAT/PTT flow
+    wsjtx_data_mode: int | None = None  # explicit DATA sub-mode for packet modes
+    wsjtx_data_mod_input: int | None = None  # optional DATAx modulation source
     command_rate_limit: float | None = None  # max cmds/sec per client, None=unlimited

{rigplane-2.0.2 → rigplane-2.0.3}/src/rigplane/rigctld/handler.py

@@ -199,6 +199,12 @@ def _err(code: HamlibError) -> RigctldResponse:
     return RigctldResponse(error=code)
 
 
+def _profile_data_mode_count(radio: Any) -> int:
+    profile = getattr(radio, "profile", None)
+    count = getattr(profile, "data_mode_count", 1)
+    return count if isinstance(count, int) and count > 0 else 1
+
+
 def _mode_to_hamlib_str(mode: object) -> str:
     """Normalize backend mode values to a hamlib-compatible string."""
     if isinstance(mode, Mode):
@@ -354,6 +360,32 @@ class RigctldHandler:
             radio, self._cache, getattr(config, "max_power_w", 100.0)
         )
 
+    def _packet_data_mode_value(self) -> int | bool:
+        value = self._config.wsjtx_data_mode
+        if value is None:
+            return True
+        if value > _profile_data_mode_count(self._radio):
+            return True
+        return value
+
+    async def _apply_packet_data_mode(self, *, receiver: int = 0) -> int | bool:
+        data_mode = self._packet_data_mode_value()
+        source = self._config.wsjtx_data_mod_input
+        if source is not None and type(data_mode) is int:
+            setter = getattr(self._radio, f"set_data{data_mode}_mod_input", None)
+            if setter is not None:
+                await setter(source)
+            else:
+                logger.debug(
+                    "rigctld: radio has no set_data%d_mod_input, skipping",
+                    data_mode,
+                )
+        if receiver == 0:
+            await self._radio.set_data_mode(data_mode)
+        else:
+            await self._radio.set_data_mode(data_mode, receiver=receiver)
+        return data_mode
+
     def _radio_state(self) -> RadioState | None:
         state = getattr(self._radio, "radio_state", None)
         return state if isinstance(state, RadioState) else None
@@ -621,9 +653,7 @@ class RigctldHandler:
                 base_mode_str, filter_width=filter_width, receiver=1
             )
             if requested_mode in packet_modes:
-                set_data_mode = getattr(self._radio, "set_data_mode", None)
-                if set_data_mode is not None:
-                    await set_data_mode(True, receiver=1)
+                await self._apply_packet_data_mode(receiver=1)
             return _ok()
 
         await self._radio.set_mode(base_mode_str, filter_width=filter_width)
@@ -631,7 +661,7 @@ class RigctldHandler:
         # Only set DATA mode explicitly for packet modes.
         # For non-packet modes, avoid hidden side-effects (do not force DATA off).
         if requested_mode in packet_modes:
-            await self._radio.set_data_mode(True)
+            data_mode = await self._apply_packet_data_mode()
 
             # Read-back sync: keep next get_mode deterministic for CAT clients.
             # Some radios acknowledge set-data quickly but reflect packet mode
@@ -656,6 +686,7 @@ class RigctldHandler:
             self._pending.mode = base_mode_str
             self._pending.filter_width = filter_width
             self._pending.data_mode = True
+            logger.debug("set_mode(%s): DATA%s selected", requested_mode, data_mode)
             if not synced:
                 logger.debug(
                     "set_mode(%s): packet read-back not fully synced yet; cached optimistic state",