lr-shuttle 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

{lr_shuttle-0.2.1.dist-info → lr_shuttle-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lr-shuttle
-Version: 0.2.1
+Version: 0.2.3
 Summary: CLI and Python client for host-side of json based serial communication with embedded device bridge.
 Author-email: Jonas Estberger <jonas.estberger@lumenradio.com>
 License: MIT
@@ -247,6 +247,12 @@ Events continue to emit until you close the subscription or client, so you can a
 
 | Command | Description |
 | --- | --- |
-| `shuttle prodtest reset` |  |
-| `shuttle prodtest ping` |  |
-| `shuttle prodtest io-self-test` |  |
+| `shuttle prodtest reset` | Reset GPIO pins, IRQ pin and Radio |
+| `shuttle prodtest ping` | Send '+' and expect '-' to verify SPI link |
+| `shuttle prodtest io-self-test` | Perform GPIO self-test on pins given as argument |
+| `shuttle prodtest antenna` | Select antenna |
+| `shuttle prodtest continuous-tx` | Continuous transmitter test |
+| `shuttle prodtest hw-device-id` | Read the 8-byte HW Device ID |
+| `shuttle prodtest serial-number [--value HEX]` | Read or write the 8-byte serial number |
+| `shuttle prodtest config [--value HEX]` | Read or write the 5-byte config payload |
+| `shuttle prodtest erase-nvmc HW_ID` | Erase NVMC if the provided 8-byte HW ID matches |

{lr_shuttle-0.2.1.dist-info → lr_shuttle-0.2.3.dist-info}/RECORD

@@ -1,18 +1,18 @@
-shuttle/cli.py,sha256=h8wElgPA-xN3MRUK3j_uBuWZs0hS_44bOc4WG_zYF_k,71365
+shuttle/cli.py,sha256=i75UW_r_v2AbVTMA1X4u_LnVf3fQz5Xc00IjbxNZwN8,93515
 shuttle/constants.py,sha256=GUlAg3iEuPxLQ2mDCvlv5gVXHnlawl_YeLtaUSqsnPM,757
 shuttle/flash.py,sha256=9ph23MHL40SjKZoL38Sbd3JbykGb-ECxvzBzCIjAues,4492
-shuttle/prodtest.py,sha256=V0wkbicAb-kqMPKsvvi7lQgcPvto7M8RbACU9pf7y8I,3595
-shuttle/serial_client.py,sha256=CnqWpC4CyxNXzsQQgRQsGwkDf19OoIEYvipu4kt2IQo,17392
+shuttle/prodtest.py,sha256=1q-1dZYtrWBpI_e0jPgROVGbb_42Y0q0DIxDoo4MWUk,8020
+shuttle/serial_client.py,sha256=WjGanUAL16qw2RZcCjHjYMKHsk-B6zY3cMeS0gPtPHE,17650
 shuttle/timo.py,sha256=1K18y0QtDF2lw2Abeok9PgrpPUiCEbQdGQXOQik75Hw,16481
 shuttle/firmware/__init__.py,sha256=KRXyz3xJ2GIB473tCHAky3DdPIQb78gX64Qn-uu55To,120
 shuttle/firmware/esp32c5/__init__.py,sha256=U2xXnb80Wv8EJaJ6Tv9iev1mVlpoaEeqsNmjmEtxdFQ,41
 shuttle/firmware/esp32c5/boot_app0.bin,sha256=-UxdeGp6j6sGrF0Q4zvzdxGmaXY23AN1WeoZzEEKF_A,8192
-shuttle/firmware/esp32c5/devboard.ino.bin,sha256=ehmd3EEcns5cAXrIqjQDxCQJr9JrKEdGqvScv0utF8Q,378880
+shuttle/firmware/esp32c5/devboard.ino.bin,sha256=eCkSHtcBBbLRvHQmkvXR1jRoMMqMTMEXaXMv8GMIsD8,1098256
 shuttle/firmware/esp32c5/devboard.ino.bootloader.bin,sha256=LPU51SdUwebYemCZb5Pya-wGe7RC4UXrkRmBnsHePp0,20784
 shuttle/firmware/esp32c5/devboard.ino.partitions.bin,sha256=FIuVnL_xw4qo4dXAup1hLFSZe5ReVqY_QSI-72UGU6E,3072
 shuttle/firmware/esp32c5/manifest.json,sha256=CPOegfEK4PTtI6UPeohuUKkJNeg0t8aWntEczpoxYt4,480
-lr_shuttle-0.2.1.dist-info/METADATA,sha256=NtysDMhV36TKVUVNlho_2zogxpYTDKl_sZjgdjCVRjQ,13037
-lr_shuttle-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lr_shuttle-0.2.1.dist-info/entry_points.txt,sha256=obqdFPgvQLB1_EWcnD9ch8HjQRlNVT_pdB_EidDRDco,44
-lr_shuttle-0.2.1.dist-info/top_level.txt,sha256=PtNxNQQdya-Xs8DYublNTBTa8c1TrtfEpQ0lUd_OeZY,8
-lr_shuttle-0.2.1.dist-info/RECORD,,
+lr_shuttle-0.2.3.dist-info/METADATA,sha256=_hp5-NmIdtKB2wZIQww4oPpXCe3mDHqevScN3G9uj4Y,13611
+lr_shuttle-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lr_shuttle-0.2.3.dist-info/entry_points.txt,sha256=obqdFPgvQLB1_EWcnD9ch8HjQRlNVT_pdB_EidDRDco,44
+lr_shuttle-0.2.3.dist-info/top_level.txt,sha256=PtNxNQQdya-Xs8DYublNTBTa8c1TrtfEpQ0lUd_OeZY,8
+lr_shuttle-0.2.3.dist-info/RECORD,,

shuttle/cli.py

@@ -2,6 +2,8 @@
 # -*- coding: utf-8 -*-
 from __future__ import annotations
 
+import ipaddress
+import re
 import string
 import sys
 import time
@@ -45,6 +47,70 @@ app.add_typer(
 
 console = Console()
 UART_RX_POLL_INTERVAL = 0.25
+PRODTEST_ANTENNA_CHOICES = {
+    "internal": 0,
+    "external": 1,
+}
+PRODTEST_TX_POWER_LEVELS = [
+    {
+        "value": 0,
+        "label": "-30 dBm",
+        "macro": "RADIO_TXPOWER_TXPOWER_Neg30dBm",
+        "aliases": ["neg30", "neg30dbm", "-30", "-30dbm"],
+    },
+    {
+        "value": 1,
+        "label": "-20 dBm",
+        "macro": "RADIO_TXPOWER_TXPOWER_Neg20dBm",
+        "aliases": ["neg20", "neg20dbm", "-20", "-20dbm"],
+    },
+    {
+        "value": 2,
+        "label": "-16 dBm",
+        "macro": "RADIO_TXPOWER_TXPOWER_Neg16dBm",
+        "aliases": ["neg16", "neg16dbm", "-16", "-16dbm"],
+    },
+    {
+        "value": 3,
+        "label": "-12 dBm",
+        "macro": "RADIO_TXPOWER_TXPOWER_Neg12dBm",
+        "aliases": ["neg12", "neg12dbm", "-12", "-12dbm"],
+    },
+    {
+        "value": 4,
+        "label": "-8 dBm",
+        "macro": "RADIO_TXPOWER_TXPOWER_Neg8dBm",
+        "aliases": ["neg8", "neg8dbm", "-8", "-8dbm"],
+    },
+    {
+        "value": 5,
+        "label": "-4 dBm",
+        "macro": "RADIO_TXPOWER_TXPOWER_Neg4dBm",
+        "aliases": ["neg4", "neg4dbm", "-4", "-4dbm"],
+    },
+    {
+        "value": 6,
+        "label": "0 dBm",
+        "macro": "RADIO_TXPOWER_TXPOWER_0dBm",
+        "aliases": ["0dbm", "0db", "0d", "zero"],
+    },
+    {
+        "value": 7,
+        "label": "+4 dBm",
+        "macro": "RADIO_TXPOWER_TXPOWER_Pos4dBm",
+        "aliases": ["pos4", "pos4dbm", "+4", "+4dbm"],
+    },
+]
+PRODTEST_TX_POWER_META = {entry["value"]: entry for entry in PRODTEST_TX_POWER_LEVELS}
+PRODTEST_TX_POWER_ALIASES: Dict[str, int] = {}
+for entry in PRODTEST_TX_POWER_LEVELS:
+    for alias in entry["aliases"]:
+        PRODTEST_TX_POWER_ALIASES[alias.lower()] = entry["value"]
+    PRODTEST_TX_POWER_ALIASES[str(entry["value"])] = entry["value"]
+PRODTEST_TX_POWER_CANONICAL = [entry["aliases"][0] for entry in PRODTEST_TX_POWER_LEVELS]
+
+_HOST_PORT_PATTERN = re.compile(r"^[A-Za-z0-9_.-]+:\d+$")
+_IPV6_HOST_PORT_PATTERN = re.compile(r"^\[[0-9A-Fa-f:]+\]:\d+$")
 
 # Backwards-compatible aliases for tests and external callers
 _SerialLogger = SerialLogger
@@ -79,6 +145,26 @@ def _normalize_choice(value: Optional[str], *, name: str) -> Optional[str]:
     return normalized
 
 
+def _resolve_prodtest_power_choice(value: str) -> Tuple[int, Dict[str, str]]:
+    trimmed = value.strip().lower()
+    if not trimmed:
+        raise typer.BadParameter("Power level cannot be empty")
+    resolved = PRODTEST_TX_POWER_ALIASES.get(trimmed)
+    if resolved is None:
+        try:
+            parsed = int(trimmed, 0)
+        except ValueError:
+            parsed = None
+        if parsed is not None and parsed in PRODTEST_TX_POWER_META:
+            resolved = parsed
+    if resolved is None:
+        allowed = ", ".join(PRODTEST_TX_POWER_CANONICAL)
+        raise typer.BadParameter(
+            f"Power must be one of: {allowed} or an index 0-7"
+        )
+    return resolved, PRODTEST_TX_POWER_META[resolved]
+
+
 def _normalize_uart_parity(value: Optional[str]) -> Optional[str]:
     if value is None:
         return None
@@ -170,9 +256,24 @@ def _resolve_uart_payload(
     return payload_bytes.hex(), len(payload_bytes)
 
 
+def _normalize_port(port: str) -> str:
+    trimmed = port.strip()
+    if not trimmed:
+        raise typer.BadParameter(
+            "Serial port is required (use --port or SHUTTLE_PORT)"
+        )
+    if "://" in trimmed:
+        return trimmed
+    if trimmed.startswith("/") or trimmed.startswith("\\"):
+        return trimmed
+    if _HOST_PORT_PATTERN.match(trimmed) or _IPV6_HOST_PORT_PATTERN.match(trimmed):
+        return f"socket://{trimmed}"
+    return trimmed
+
+
 def _require_port(port: Optional[str]) -> str:
     if port:
-        return port
+        return _normalize_port(port)
     raise typer.BadParameter("Serial port is required (use --port or SHUTTLE_PORT)")
 
 
@@ -188,6 +289,16 @@ def _parse_int_option(value: str, *, name: str) -> int:
     return parsed
 
 
+def _parse_ipv4(value: Optional[str], *, name: str) -> Optional[str]:
+    if value is None:
+        return None
+    try:
+        ipaddress.IPv4Address(value)
+    except ipaddress.AddressValueError as exc:
+        raise typer.BadParameter(f"{name} must be a valid IPv4 address") from exc
+    return value
+
+
 def _parse_prodtest_mask(value: str) -> bytes:
     try:
         return prodtest.mask_from_hex(value)
@@ -195,6 +306,21 @@ def _parse_prodtest_mask(value: str) -> bytes:
         raise typer.BadParameter(str(exc)) from exc
 
 
+def _parse_fixed_hex(value: str, *, name: str, length: int) -> bytes:
+    cleaned = value.strip()
+    if cleaned.startswith(("0x", "0X")):
+        cleaned = cleaned[2:]
+    cleaned = cleaned.replace("_", "").replace(" ", "")
+    if len(cleaned) != length * 2:
+        raise typer.BadParameter(
+            f"{name} must be {length * 2} hex characters ({length} bytes)"
+        )
+    try:
+        return bytes.fromhex(cleaned)
+    except ValueError as exc:
+        raise typer.BadParameter(f"{name} must be valid hex") from exc
+
+
 def _format_hex(hex_str: str) -> str:
     if not hex_str:
         return "—"
@@ -1425,17 +1551,474 @@ def prodtest_ping(
         logger=resources.get("logger"),
         seq_tracker=resources.get("seq_tracker"),
     )
-    if not responses or len(responses) < 2:
+    if not responses:
         console.print("[red]Device returned no response[/]")
         raise typer.Exit(1)
-    rx2 = responses[1].get("rx", "")
-    if rx2 and isinstance(rx2, str):
-        rx_bytes = bytes.fromhex(rx2)
-        if rx_bytes and rx_bytes[0] == 0x2D:  # ord('-')
-            console.print("[green]Ping successful: got '-' response[/]")
-            return
-    console.print(f"[red]Ping failed: expected '-' (0x2D), got: {rx2}[/]")
-    raise typer.Exit(1)
+
+    failed_idx = next(
+        (idx for idx, resp in enumerate(responses) if not resp.get("ok")), None
+    )
+    if failed_idx is not None:
+        phase = "command" if failed_idx == 0 else "payload"
+        _render_spi_response(
+            f"prodtest ping ({phase})",
+            responses[failed_idx],
+            command_label=f"spi.xfer (prodtest {phase})",
+        )
+        raise typer.Exit(1)
+
+    if len(responses) != len(sequence):
+        console.print("[red]Prodtest command halted before completing all SPI phases[/]")
+        raise typer.Exit(1)
+
+    command_response, payload_response = responses
+    _render_spi_response(
+        "prodtest ping (command)",
+        command_response,
+        command_label="spi.xfer (prodtest command)",
+    )
+    _render_spi_response(
+        "prodtest ping (payload)",
+        payload_response,
+        command_label="spi.xfer (prodtest payload)",
+    )
+
+    rx_bytes = _decode_hex_response(
+        payload_response, label="prodtest ping (payload)"
+    )
+    if not rx_bytes or rx_bytes[0] != 0x2D:  # ord('-')
+        console.print(
+            "[red]Ping failed: expected '-' (0x2D), got: "
+            f"{_format_hex(payload_response.get('rx', ''))}[/]"
+        )
+        raise typer.Exit(1)
+
+    console.print("[green]Ping successful: got '-' response[/]")
+
+
+@prodtest_app.command("antenna")
+def prodtest_antenna(
+    ctx: typer.Context,
+    antenna: str = typer.Argument(
+        ...,
+        metavar="ANTENNA",
+        help="Antenna to select (internal/external)",
+    ),
+    port: Optional[str] = typer.Option(
+        None,
+        "--port",
+        envvar="SHUTTLE_PORT",
+        help="Serial port (e.g., /dev/ttyACM0)",
+    ),
+    baudrate: int = typer.Option(DEFAULT_BAUD, "--baud", help="Serial baud rate"),
+    timeout: float = typer.Option(
+        DEFAULT_TIMEOUT, "--timeout", help="Read timeout in seconds"
+    ),
+):
+    """Select the active prodtest antenna (opcode 'a')."""
+
+    resources = _ctx_resources(ctx)
+    normalized = antenna.strip().lower()
+    try:
+        antenna_value = PRODTEST_ANTENNA_CHOICES[normalized]
+    except KeyError as exc:
+        allowed = ", ".join(sorted(PRODTEST_ANTENNA_CHOICES))
+        raise typer.BadParameter(
+            f"Antenna must be one of: {allowed}"
+        ) from exc
+
+    sequence = [prodtest.select_antenna(antenna_value)]
+    responses = _execute_timo_sequence(
+        port=port,
+        baudrate=baudrate,
+        timeout=timeout,
+        sequence=sequence,
+        spinner_label=f"Selecting prodtest antenna ({normalized})",
+        logger=resources.get("logger"),
+        seq_tracker=resources.get("seq_tracker"),
+    )
+
+    if not responses:
+        console.print("[red]Device returned no response[/]")
+        raise typer.Exit(1)
+
+    response = responses[0]
+    _render_spi_response(
+        "prodtest antenna",
+        response,
+        command_label="spi.xfer (prodtest)",
+    )
+
+    if not response.get("ok"):
+        raise typer.Exit(1)
+
+    console.print(f"[green]Antenna set to {normalized}")
+
+
+@prodtest_app.command("continuous-tx")
+def prodtest_continuous_tx(
+    ctx: typer.Context,
+    channel: int = typer.Argument(
+        ...,
+        metavar="CHANNEL",
+        min=0,
+        max=100,
+        help="NRF_RADIO->FREQUENCY channel index (0=2400 MHz, 100=2500 MHz)",
+    ),
+    power: str = typer.Argument(
+        ...,
+        metavar="POWER",
+        help=(
+            "Output power alias (neg30, neg20, neg16, neg12, neg8, neg4, 0, pos4) "
+            "or numeric index 0-7"
+        ),
+    ),
+    port: Optional[str] = typer.Option(
+        None,
+        "--port",
+        envvar="SHUTTLE_PORT",
+        help="Serial port (e.g., /dev/ttyACM0)",
+    ),
+    baudrate: int = typer.Option(DEFAULT_BAUD, "--baud", help="Serial baud rate"),
+    timeout: float = typer.Option(
+        DEFAULT_TIMEOUT, "--timeout", help="Read timeout in seconds"
+    ),
+):
+    """Run the prodtest continuous transmitter test (opcode 'o')."""
+
+    resources = _ctx_resources(ctx)
+    power_value, power_meta = _resolve_prodtest_power_choice(power)
+    freq_mhz = 2400 + channel
+    sequence = [prodtest.continuous_transmitter(channel, power_value)]
+    responses = _execute_timo_sequence(
+        port=port,
+        baudrate=baudrate,
+        timeout=timeout,
+        sequence=sequence,
+        spinner_label=(
+            f"Enabling continuous TX (ch={channel}, power={power_meta['label']})"
+        ),
+        logger=resources.get("logger"),
+        seq_tracker=resources.get("seq_tracker"),
+    )
+
+    if not responses:
+        console.print("[red]Device returned no response[/]")
+        raise typer.Exit(1)
+
+    response = responses[0]
+    _render_spi_response(
+        "prodtest continuous-tx",
+        response,
+        command_label="spi.xfer (prodtest)",
+    )
+
+    if not response.get("ok"):
+        raise typer.Exit(1)
+
+    console.print(
+        f"[green]Continuous transmitter enabled[/] channel={channel} ({freq_mhz} MHz) "
+        f"power={power_meta['label']} ({power_meta['macro']})"
+    )
+
+
+@prodtest_app.command("hw-device-id")
+def prodtest_hw_device_id(
+    ctx: typer.Context,
+    port: Optional[str] = typer.Option(
+        None,
+        "--port",
+        envvar="SHUTTLE_PORT",
+        help="Serial port (e.g., /dev/ttyACM0)",
+    ),
+    baudrate: int = typer.Option(DEFAULT_BAUD, "--baud", help="Serial baud rate"),
+    timeout: float = typer.Option(
+        DEFAULT_TIMEOUT, "--timeout", help="Read timeout in seconds"
+    ),
+):
+    """Read the prodtest HW Device ID (opcode 'I')."""
+
+    resources = _ctx_resources(ctx)
+    sequence = prodtest.hw_device_id_sequence()
+    responses = _execute_timo_sequence(
+        port=port,
+        baudrate=baudrate,
+        timeout=timeout,
+        sequence=sequence,
+        spinner_label="Reading prodtest HW Device ID",
+        logger=resources.get("logger"),
+        seq_tracker=resources.get("seq_tracker"),
+    )
+
+    if not responses:
+        console.print("[red]Device returned no response[/]")
+        raise typer.Exit(1)
+
+    failed_idx = next(
+        (idx for idx, resp in enumerate(responses) if not resp.get("ok")), None
+    )
+    if failed_idx is not None:
+        phase = "command" if failed_idx == 0 else "payload"
+        _render_spi_response(
+            f"prodtest hw-device-id ({phase})",
+            responses[failed_idx],
+            command_label=f"spi.xfer (prodtest {phase})",
+        )
+        raise typer.Exit(1)
+
+    if len(responses) != len(sequence):
+        console.print("[red]Prodtest command halted before completing all SPI phases[/]")
+        raise typer.Exit(1)
+
+    result_response = responses[-1]
+    _render_spi_response(
+        "prodtest hw-device-id",
+        result_response,
+        command_label="spi.xfer (prodtest payload)",
+    )
+
+    rx_bytes = _decode_hex_response(result_response, label="prodtest hw-device-id")
+    if len(rx_bytes) < prodtest.HW_DEVICE_ID_RESULT_LEN:
+        console.print("[red]Prodtest HW Device ID response shorter than expected[/]")
+        raise typer.Exit(1)
+
+    hw_id = rx_bytes[-prodtest.HW_DEVICE_ID_RESULT_LEN :]
+    console.print(f"HW Device ID: {_format_hex(hw_id.hex())}")
+
+
+@prodtest_app.command("serial-number")
+def prodtest_serial_number(
+    ctx: typer.Context,
+    value: Optional[str] = typer.Option(
+        None,
+        "--value",
+        "-v",
+        help="Hex-encoded 8-byte serial number to write (omit to read)",
+    ),
+    port: Optional[str] = typer.Option(
+        None,
+        "--port",
+        envvar="SHUTTLE_PORT",
+        help="Serial port (e.g., /dev/ttyACM0)",
+    ),
+    baudrate: int = typer.Option(DEFAULT_BAUD, "--baud", help="Serial baud rate"),
+    timeout: float = typer.Option(
+        DEFAULT_TIMEOUT, "--timeout", help="Read timeout in seconds"
+    ),
+):
+    """Read or write the prodtest serial number (opcode 'x'/'X')."""
+
+    resources = _ctx_resources(ctx)
+    if value is None:
+        sequence = prodtest.serial_number_read_sequence()
+        spinner_label = "Reading prodtest serial number"
+    else:
+        serial_bytes = _parse_fixed_hex(
+            value, name="--value", length=prodtest.SERIAL_NUMBER_LEN
+        )
+        sequence = [prodtest.serial_number_write(serial_bytes)]
+        spinner_label = "Writing prodtest serial number"
+
+    responses = _execute_timo_sequence(
+        port=port,
+        baudrate=baudrate,
+        timeout=timeout,
+        sequence=sequence,
+        spinner_label=spinner_label,
+        logger=resources.get("logger"),
+        seq_tracker=resources.get("seq_tracker"),
+    )
+
+    if not responses:
+        console.print("[red]Device returned no response[/]")
+        raise typer.Exit(1)
+
+    failed_idx = next(
+        (idx for idx, resp in enumerate(responses) if not resp.get("ok")), None
+    )
+    if failed_idx is not None:
+        phase = "command" if failed_idx == 0 else "payload"
+        _render_spi_response(
+            f"prodtest serial-number ({phase})",
+            responses[failed_idx],
+            command_label=f"spi.xfer (prodtest {phase})",
+        )
+        raise typer.Exit(1)
+
+    if len(responses) != len(sequence):
+        console.print(
+            "[red]Prodtest command halted before completing all SPI phases[/]"
+        )
+        raise typer.Exit(1)
+
+    if value is None:
+        result_response = responses[-1]
+        _render_spi_response(
+            "prodtest serial-number",
+            result_response,
+            command_label="spi.xfer (prodtest payload)",
+        )
+        rx_bytes = _decode_hex_response(
+            result_response, label="prodtest serial-number"
+        )
+        if len(rx_bytes) < prodtest.SERIAL_NUMBER_LEN:
+            console.print("[red]Prodtest serial-number response shorter than expected[/]")
+            raise typer.Exit(1)
+        serial_bytes = rx_bytes[-prodtest.SERIAL_NUMBER_LEN :]
+        console.print(f"Serial number: {_format_hex(serial_bytes.hex())}")
+    else:
+        _render_spi_response(
+            "prodtest serial-number",
+            responses[0],
+            command_label="spi.xfer (prodtest command)",
+        )
+        console.print(
+            f"[green]Serial number updated[/] value={_format_hex(serial_bytes.hex())}"
+        )
+
+
+@prodtest_app.command("config")
+def prodtest_config(
+    ctx: typer.Context,
+    value: Optional[str] = typer.Option(
+        None,
+        "--value",
+        "-v",
+        help="Hex-encoded 5-byte config payload to write (omit to read)",
+    ),
+    port: Optional[str] = typer.Option(
+        None,
+        "--port",
+        envvar="SHUTTLE_PORT",
+        help="Serial port (e.g., /dev/ttyACM0)",
+    ),
+    baudrate: int = typer.Option(DEFAULT_BAUD, "--baud", help="Serial baud rate"),
+    timeout: float = typer.Option(
+        DEFAULT_TIMEOUT, "--timeout", help="Read timeout in seconds"
+    ),
+):
+    """Read or write the prodtest config (opcode 'r'/'R')."""
+
+    resources = _ctx_resources(ctx)
+    if value is None:
+        sequence = prodtest.config_read_sequence()
+        spinner_label = "Reading prodtest config"
+    else:
+        config_bytes = _parse_fixed_hex(
+            value, name="--value", length=prodtest.CONFIG_WRITE_LEN
+        )
+        sequence = [prodtest.config_write(config_bytes)]
+        spinner_label = "Writing prodtest config"
+
+    responses = _execute_timo_sequence(
+        port=port,
+        baudrate=baudrate,
+        timeout=timeout,
+        sequence=sequence,
+        spinner_label=spinner_label,
+        logger=resources.get("logger"),
+        seq_tracker=resources.get("seq_tracker"),
+    )
+
+    if not responses:
+        console.print("[red]Device returned no response[/]")
+        raise typer.Exit(1)
+
+    failed_idx = next(
+        (idx for idx, resp in enumerate(responses) if not resp.get("ok")), None
+    )
+    if failed_idx is not None:
+        phase = "command" if failed_idx == 0 else "payload"
+        _render_spi_response(
+            f"prodtest config ({phase})",
+            responses[failed_idx],
+            command_label=f"spi.xfer (prodtest {phase})",
+        )
+        raise typer.Exit(1)
+
+    if len(responses) != len(sequence):
+        console.print(
+            "[red]Prodtest command halted before completing all SPI phases[/]"
+        )
+        raise typer.Exit(1)
+
+    if value is None:
+        result_response = responses[-1]
+        _render_spi_response(
+            "prodtest config",
+            result_response,
+            command_label="spi.xfer (prodtest payload)",
+        )
+        rx_bytes = _decode_hex_response(result_response, label="prodtest config")
+        if len(rx_bytes) < prodtest.CONFIG_RESULT_LEN:
+            console.print("[red]Prodtest config response shorter than expected[/]")
+            raise typer.Exit(1)
+        config_bytes = rx_bytes[-prodtest.CONFIG_RESULT_LEN :]
+        console.print(f"Config: {_format_hex(config_bytes.hex())}")
+    else:
+        _render_spi_response(
+            "prodtest config",
+            responses[0],
+            command_label="spi.xfer (prodtest command)",
+        )
+        console.print(
+            f"[green]Config updated[/] value={_format_hex(config_bytes.hex())}"
+        )
+
+
+@prodtest_app.command("erase-nvmc")
+def prodtest_erase_nvmc(
+    ctx: typer.Context,
+    hw_device_id: str = typer.Argument(
+        ...,
+        metavar="HW_ID",
+        help="Hex-encoded 8-byte HW Device ID (must match device to erase)",
+    ),
+    port: Optional[str] = typer.Option(
+        None,
+        "--port",
+        envvar="SHUTTLE_PORT",
+        help="Serial port (e.g., /dev/ttyACM0)",
+    ),
+    baudrate: int = typer.Option(DEFAULT_BAUD, "--baud", help="Serial baud rate"),
+    timeout: float = typer.Option(
+        DEFAULT_TIMEOUT, "--timeout", help="Read timeout in seconds"
+    ),
+):
+    """Erase NVMC if the provided HW Device ID matches (opcode 'e')."""
+
+    resources = _ctx_resources(ctx)
+    hw_id_bytes = _parse_fixed_hex(
+        hw_device_id, name="HW_ID", length=prodtest.ERASE_NVMC_LEN
+    )
+    sequence = [prodtest.erase_nvmc(hw_id_bytes)]
+    responses = _execute_timo_sequence(
+        port=port,
+        baudrate=baudrate,
+        timeout=timeout,
+        sequence=sequence,
+        spinner_label="Erasing NVMC (if HW ID matches)",
+        logger=resources.get("logger"),
+        seq_tracker=resources.get("seq_tracker"),
+    )
+
+    if not responses:
+        console.print("[red]Device returned no response[/]")
+        raise typer.Exit(1)
+
+    response = responses[0]
+    _render_spi_response(
+        "prodtest erase-nvmc",
+        response,
+        command_label="spi.xfer (prodtest)",
+    )
+
+    if not response.get("ok"):
+        raise typer.Exit(1)
+
+    console.print(
+        f"[green]erase-nvmc completed[/] hw-id={_format_hex(hw_id_bytes.hex())}"
+    )
 
 
 @prodtest_app.command("io-self-test")
@@ -1807,6 +2390,123 @@ def uart_sub_command(
     _render_payload_response("uart.sub", response)
 
 
+@app.command("wifi-cfg")
+def wifi_cfg_command(
+    ctx: typer.Context,
+    port: Optional[str] = typer.Option(
+        None,
+        "--port",
+        envvar="SHUTTLE_PORT",
+        help="Serial port or host:port (e.g., /dev/ttyUSB0 or 192.168.1.10:5000)",
+    ),
+    baudrate: int = typer.Option(DEFAULT_BAUD, "--baud", help="Serial baud rate"),
+    timeout: float = typer.Option(
+        DEFAULT_TIMEOUT, "--timeout", help="Read timeout in seconds"
+    ),
+    ssid: Optional[str] = typer.Option(
+        None,
+        "--ssid",
+        help="Set the station SSID",
+        show_default=False,
+    ),
+    psk: Optional[str] = typer.Option(
+        None,
+        "--psk",
+        help="Set the WPA/WPA2/WPA3 passphrase",
+        show_default=False,
+    ),
+    dhcp: Optional[bool] = typer.Option(
+        None,
+        "--dhcp/--static",
+        help="Enable DHCP or force static IPv4 addressing",
+    ),
+    ip_addr: Optional[str] = typer.Option(
+        None,
+        "--ip",
+        help="Static IPv4 address (requires --static or other static fields)",
+        show_default=False,
+    ),
+    netmask: Optional[str] = typer.Option(
+        None,
+        "--netmask",
+        help="Static subnet mask (e.g., 255.255.255.0)",
+        show_default=False,
+    ),
+    gateway: Optional[str] = typer.Option(
+        None,
+        "--gateway",
+        help="Static default gateway IPv4 address",
+        show_default=False,
+    ),
+    dns: Optional[str] = typer.Option(
+        None,
+        "--dns",
+        help="Primary DNS server IPv4 address",
+        show_default=False,
+    ),
+    dns_alt: Optional[str] = typer.Option(
+        None,
+        "--dns-alt",
+        help="Secondary DNS server IPv4 address",
+        show_default=False,
+    ),
+):
+    """Query or update Wi-Fi credentials and network settings."""
+
+    resources = _ctx_resources(ctx)
+    wifi_payload: Dict[str, Any] = {}
+    if ssid is not None:
+        wifi_payload["ssid"] = ssid
+    if psk is not None:
+        wifi_payload["psk"] = psk
+    if dhcp is not None:
+        wifi_payload["dhcp"] = dhcp
+
+    network_payload: Dict[str, Any] = {}
+    parsed_ip = _parse_ipv4(ip_addr, name="--ip")
+    parsed_mask = _parse_ipv4(netmask, name="--netmask")
+    parsed_gateway = _parse_ipv4(gateway, name="--gateway")
+    parsed_dns_primary = _parse_ipv4(dns, name="--dns")
+    parsed_dns_secondary = _parse_ipv4(dns_alt, name="--dns-alt")
+
+    if parsed_ip is not None:
+        network_payload["ip"] = parsed_ip
+    if parsed_mask is not None:
+        network_payload["netmask"] = parsed_mask
+    if parsed_gateway is not None:
+        network_payload["gateway"] = parsed_gateway
+
+    dns_entries = [entry for entry in (parsed_dns_primary, parsed_dns_secondary) if entry]
+    if dns_entries:
+        network_payload["dns"] = dns_entries
+
+    if network_payload:
+        if wifi_payload.get("dhcp") is True:
+            raise typer.BadParameter(
+                "Static network options cannot be combined with --dhcp"
+            )
+        wifi_payload.setdefault("dhcp", False)
+        wifi_payload["network"] = network_payload
+
+    resolved_port = _require_port(port)
+    action = "Updating" if wifi_payload else "Querying"
+    with spinner(f"{action} wifi.cfg over {resolved_port}"):
+        try:
+            with NDJSONSerialClient(
+                resolved_port,
+                baudrate=baudrate,
+                timeout=timeout,
+                logger=resources.get("logger"),
+                seq_tracker=resources.get("seq_tracker"),
+            ) as client:
+                response = client.wifi_cfg(wifi_payload if wifi_payload else None)
+        except ShuttleSerialError as exc:
+            console.print(f"[red]{exc}[/]")
+            raise typer.Exit(1) from exc
+
+    _render_payload_response("wifi.cfg", response)
+
+
 @app.command("uart-tx")
 def uart_tx_command(
     ctx: typer.Context,

shuttle/prodtest.py

@@ -10,10 +10,32 @@ from . import timo
 
 RESET_OPCODE = ord("?")
 PLUS_OPCODE = ord("+")
+ANTENNA_OPCODE = ord("a")
+CONTINUOUS_TX_OPCODE = ord("o")
+HW_DEVICE_ID_OPCODE = ord("I")
+SERIAL_NUMBER_READ_OPCODE = ord("x")
+SERIAL_NUMBER_WRITE_OPCODE = ord("X")
+CONFIG_READ_OPCODE = ord("r")
+CONFIG_WRITE_OPCODE = ord("R")
+ERASE_NVMC_OPCODE = ord("e")
 IO_SELF_TEST_OPCODE = ord("T")
 IO_SELF_TEST_MASK_LEN = 8
 IO_SELF_TEST_DUMMY_BYTE = 0xFF
-IO_SELF_TEST_IRQ_TIMEOUT_US = 1_000_000
+IO_SELF_TEST_IRQ_TIMEOUT_US = 500_000
+RESET_IRQ_TIMEOUT_US = 200_000
+CONTINUOUS_TX_IRQ_TIMEOUT_US = 100_000
+HW_DEVICE_ID_RESULT_LEN = 8
+HW_DEVICE_ID_DUMMY_BYTE = 0xFF
+HW_DEVICE_ID_IRQ_TIMEOUT_US = 100_000
+SERIAL_NUMBER_LEN = 8
+SERIAL_NUMBER_DUMMY_BYTE = 0xFF
+SERIAL_NUMBER_IRQ_TIMEOUT_US = 100_000
+CONFIG_RESULT_LEN = 6
+CONFIG_WRITE_LEN = 5
+CONFIG_DUMMY_BYTE = 0xFF
+CONFIG_IRQ_TIMEOUT_US = 100_000
+ERASE_NVMC_LEN = 8
+ERASE_NVMC_IRQ_TIMEOUT_US = 500_000
 
 
 def _ensure_byte(value: int) -> int:
@@ -32,16 +54,31 @@ def _build_command_bytes(opcode: int, arguments: Iterable[int] | bytes = ()) ->
     return bytes([opcode]) + payload
 
 
-def command(opcode: int, arguments: Iterable[int] | bytes = ()) -> dict:
+def command(
+    opcode: int,
+    arguments: Iterable[int] | bytes = (),
+    *,
+    params: dict | None = None,
+) -> dict:
     """Build an NDJSON-ready spi.xfer payload for a prodtest command."""
 
-    return timo.command_payload(_build_command_bytes(opcode, arguments))
+    return timo.command_payload(
+        _build_command_bytes(opcode, arguments), params=params
+    )
 
 
 def reset() -> dict:
     """Return the prodtest reset command (single '?' byte)."""
 
-    return command(RESET_OPCODE)
+    return timo.command_payload(
+        bytes([RESET_OPCODE]),
+        params={
+            "wait_irq": {
+                "edge": "leading",
+                "timeout_us": RESET_IRQ_TIMEOUT_US,
+            }
+        },
+    )
 
 
 def reset_transfer() -> dict:
@@ -50,6 +87,130 @@ def reset_transfer() -> dict:
     return reset()
 
 
+def select_antenna(selection: int) -> dict:
+    """Return the prodtest antenna command for the given antenna index."""
+
+    return command(ANTENNA_OPCODE, [selection])
+
+
+def continuous_transmitter(channel: int, power_level: int) -> dict:
+    """Return the prodtest continuous transmitter command (opcode 'o')."""
+
+    return command(
+        CONTINUOUS_TX_OPCODE,
+        [channel, power_level],
+        params={
+            "wait_irq": {
+                "edge": "trailing",
+                "timeout_us": CONTINUOUS_TX_IRQ_TIMEOUT_US,
+            }
+        },
+    )
+
+
+def hw_device_id_sequence() -> Sequence[dict]:
+    """Return the SPI frames required to read the HW Device ID (opcode 'I')."""
+
+    command = timo.command_payload(
+        bytes([HW_DEVICE_ID_OPCODE]),
+        params={
+            "wait_irq": {
+                "edge": "trailing",
+                "timeout_us": HW_DEVICE_ID_IRQ_TIMEOUT_US,
+            }
+        },
+    )
+    readback = timo.command_payload(
+        bytes([HW_DEVICE_ID_DUMMY_BYTE] * HW_DEVICE_ID_RESULT_LEN)
+    )
+    return (command, readback)
+
+
+def serial_number_read_sequence() -> Sequence[dict]:
+    """Return the SPI frames required to read the prodtest serial number (opcode 'x')."""
+
+    command = timo.command_payload(
+        bytes([SERIAL_NUMBER_READ_OPCODE]),
+        params={
+            "wait_irq": {
+                "edge": "trailing",
+                "timeout_us": SERIAL_NUMBER_IRQ_TIMEOUT_US,
+            }
+        },
+    )
+    readback = timo.command_payload(
+        bytes([SERIAL_NUMBER_DUMMY_BYTE] * SERIAL_NUMBER_LEN)
+    )
+    return (command, readback)
+
+
+def serial_number_write(serial_bytes: bytes) -> dict:
+    """Build the prodtest serial-number write command (opcode 'X')."""
+
+    if len(serial_bytes) != SERIAL_NUMBER_LEN:
+        raise ValueError("Serial number must be exactly 8 bytes")
+    return command(
+        SERIAL_NUMBER_WRITE_OPCODE,
+        serial_bytes,
+        params={
+            "wait_irq": {
+                "edge": "trailing",
+                "timeout_us": SERIAL_NUMBER_IRQ_TIMEOUT_US,
+            }
+        },
+    )
+
+
+def config_read_sequence() -> Sequence[dict]:
+    """Return the SPI frames required to read the prodtest config (opcode 'r')."""
+
+    command = timo.command_payload(
+        bytes([CONFIG_READ_OPCODE]),
+        params={
+            "wait_irq": {
+                "edge": "trailing",
+                "timeout_us": CONFIG_IRQ_TIMEOUT_US,
+            }
+        },
+    )
+    readback = timo.command_payload(bytes([CONFIG_DUMMY_BYTE] * CONFIG_RESULT_LEN))
+    return (command, readback)
+
+
+def config_write(config_bytes: bytes) -> dict:
+    """Build the prodtest config write command (opcode 'R')."""
+
+    if len(config_bytes) != CONFIG_WRITE_LEN:
+        raise ValueError("Config payload must be exactly 5 bytes")
+    return command(
+        CONFIG_WRITE_OPCODE,
+        config_bytes,
+        params={
+            "wait_irq": {
+                "edge": "trailing",
+                "timeout_us": CONFIG_IRQ_TIMEOUT_US,
+            }
+        },
+    )
+
+
+def erase_nvmc(hw_id: bytes) -> dict:
+    """Build the prodtest erase command (opcode 'e')."""
+
+    if len(hw_id) != ERASE_NVMC_LEN:
+        raise ValueError("Erase requires an 8-byte HW Device ID argument")
+    return command(
+        ERASE_NVMC_OPCODE,
+        hw_id,
+        params={
+            "wait_irq": {
+                "edge": "trailing",
+                "timeout_us": ERASE_NVMC_IRQ_TIMEOUT_US,
+            }
+        },
+    )
+
+
 def ping_sequence() -> Sequence[dict]:
     """Return the two SPI frames for the prodtest ping action ('+' then dummy)."""
     # First transfer: send '+' (PLUS_OPCODE), expect response (should be ignored)
@@ -72,7 +233,7 @@ def io_self_test(mask: bytes) -> Sequence[dict]:
             command,
             params={
                 "wait_irq": {
-                    "edge": "leading",
+                    "edge": "trailing",
                     "timeout_us": IO_SELF_TEST_IRQ_TIMEOUT_US,
                 }
             },

shuttle/serial_client.py

@@ -228,7 +228,9 @@ class NDJSONSerialClient:
         seq_tracker: Optional[SequenceTracker] = None,
     ):
         try:
-            self._serial = serial.Serial(port=port, baudrate=baudrate, timeout=timeout)
+            self._serial = serial.serial_for_url(
+                url=port, baudrate=baudrate, timeout=timeout
+            )
         except SerialException as exc:  # pragma: no cover - hardware specific
             raise ShuttleSerialError(f"Unable to open {port}: {exc}") from exc
         self._serial.reset_input_buffer()
@@ -345,6 +347,12 @@ class NDJSONSerialClient:
             payload["uart"] = uart
         return self._command("uart.cfg", payload)
 
+    def wifi_cfg(self, wifi: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {}
+        if wifi:
+            payload["wifi"] = wifi
+        return self._command("wifi.cfg", payload)
+
     def uart_tx(self, data: str, port: Optional[int] = None) -> Dict[str, Any]:
         payload: Dict[str, Any] = {"data": data}
         if port is not None: