lr-shuttle 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

{lr_shuttle-0.2.0.dist-info → lr_shuttle-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lr-shuttle
-Version: 0.2.0
+Version: 0.2.2
 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.0.dist-info → lr_shuttle-0.2.2.dist-info}/RECORD

@@ -1,18 +1,18 @@
-shuttle/cli.py,sha256=SxTNlqIfGviNQDloIUIVE2IffggkvVKne-GoN9VJJfA,69716
+shuttle/cli.py,sha256=eMJEEmHG6Ar3vQsrQmCbPLY0pHUJg6gUyUDCaW0KNGM,87851
 shuttle/constants.py,sha256=GUlAg3iEuPxLQ2mDCvlv5gVXHnlawl_YeLtaUSqsnPM,757
-shuttle/flash.py,sha256=a2KMECO4aVFuWtP0zrT7cELQgQuyDoSXNM1EBk1Wd-U,4416
-shuttle/prodtest.py,sha256=V0wkbicAb-kqMPKsvvi7lQgcPvto7M8RbACU9pf7y8I,3595
-shuttle/serial_client.py,sha256=B4ci-Ox-ig65H0xO32FgJHfTG0Ievg6VjGfQ_PSZjWE,17104
+shuttle/flash.py,sha256=9ph23MHL40SjKZoL38Sbd3JbykGb-ECxvzBzCIjAues,4492
+shuttle/prodtest.py,sha256=1q-1dZYtrWBpI_e0jPgROVGbb_42Y0q0DIxDoo4MWUk,8020
+shuttle/serial_client.py,sha256=CnqWpC4CyxNXzsQQgRQsGwkDf19OoIEYvipu4kt2IQo,17392
 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=xrS7cn4mllTXPtpBqpgjuA9863shD1TISgFkHfxMIGk,377792
+shuttle/firmware/esp32c5/devboard.ino.bin,sha256=vH-IBzbJCpSKgCLDl6snXqe2d5PFJJ3RDVQq41b3iKg,378880
 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.0.dist-info/METADATA,sha256=DeZ2s75NvqbuHDa-4077ItWJuvLWEbSEvk5byWEa_mw,13037
-lr_shuttle-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lr_shuttle-0.2.0.dist-info/entry_points.txt,sha256=obqdFPgvQLB1_EWcnD9ch8HjQRlNVT_pdB_EidDRDco,44
-lr_shuttle-0.2.0.dist-info/top_level.txt,sha256=PtNxNQQdya-Xs8DYublNTBTa8c1TrtfEpQ0lUd_OeZY,8
-lr_shuttle-0.2.0.dist-info/RECORD,,
+lr_shuttle-0.2.2.dist-info/METADATA,sha256=eS1NFB_YNkvsq7eT4akMzyUij0ormtqHHtagAMghonA,13611
+lr_shuttle-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lr_shuttle-0.2.2.dist-info/entry_points.txt,sha256=obqdFPgvQLB1_EWcnD9ch8HjQRlNVT_pdB_EidDRDco,44
+lr_shuttle-0.2.2.dist-info/top_level.txt,sha256=PtNxNQQdya-Xs8DYublNTBTa8c1TrtfEpQ0lUd_OeZY,8
+lr_shuttle-0.2.2.dist-info/RECORD,,

shuttle/cli.py

@@ -45,6 +45,67 @@ 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]
 
 # Backwards-compatible aliases for tests and external callers
 _SerialLogger = SerialLogger
@@ -79,6 +140,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
@@ -195,6 +276,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 "—"
@@ -1438,6 +1534,431 @@ def prodtest_ping(
     raise typer.Exit(1)
 
 
+@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")
 def prodtest_io_self_test(
     ctx: typer.Context,
@@ -1977,6 +2498,60 @@ def uart_rx_command(
         console.print("[yellow]No uart.rx events observed[/]")
 
 
+@app.command("power")
+def power_command(
+    ctx: typer.Context,
+    port: Optional[str] = typer.Option(
+        None,
+        "--port",
+        envvar="SHUTTLE_PORT",
+        help="Serial port (e.g., /dev/ttyUSB0)",
+    ),
+    baudrate: int = typer.Option(DEFAULT_BAUD, "--baud", help="Serial baud rate"),
+    timeout: float = typer.Option(
+        DEFAULT_TIMEOUT, "--timeout", help="Read timeout in seconds"
+    ),
+    enable: Optional[bool] = typer.Option(
+        None,
+        "--enable/--disable",
+        help="Enable or disable the downstream power rail",
+    ),
+):
+    """Query or toggle the downstream power rail."""
+
+    resources = _ctx_resources(ctx)
+    resolved_port = _require_port(port)
+    if enable is None:
+        action = "Querying"
+        label = "power.state"
+        method_name = "power_state"
+    elif enable:
+        action = "Enabling"
+        label = "power.enable"
+        method_name = "power_enable"
+    else:
+        action = "Disabling"
+        label = "power.disable"
+        method_name = "power_disable"
+
+    with spinner(f"{action} power over {resolved_port}"):
+        try:
+            with NDJSONSerialClient(
+                resolved_port,
+                baudrate=baudrate,
+                timeout=timeout,
+                logger=resources.get("logger"),
+                seq_tracker=resources.get("seq_tracker"),
+            ) as client:
+                method = getattr(client, method_name)
+                response = method()
+        except ShuttleSerialError as exc:
+            console.print(f"[red]{exc}[/]")
+            raise typer.Exit(1) from exc
+
+    _render_payload_response(label, response)
+
+
 @app.command("flash")
 def flash_command(
     ctx: typer.Context,

shuttle/flash.py

@@ -90,12 +90,16 @@ def flash_firmware(
             offset = segment.get("offset")
             file_name = segment.get("file")
             if not offset or not file_name:
-                raise FirmwareFlashError("Manifest segment entries require 'offset' and 'file'")
+                raise FirmwareFlashError(
+                    "Manifest segment entries require 'offset' and 'file'"
+                )
             traversable = resources.files(package) / file_name
             try:
                 file_path = stack.enter_context(resources.as_file(traversable))
             except FileNotFoundError as exc:
-                raise FirmwareFlashError(f"Missing firmware artifact: {file_name}") from exc
+                raise FirmwareFlashError(
+                    f"Missing firmware artifact: {file_name}"
+                ) from exc
             resolved_segments.append((str(offset), Path(file_path)))
 
         if erase_first:

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

@@ -324,6 +324,15 @@ class NDJSONSerialClient:
     def ping(self) -> Dict[str, Any]:
         return self._command("ping", {})
 
+    def power_state(self) -> Dict[str, Any]:
+        return self._command("power.state", {})
+
+    def power_enable(self) -> Dict[str, Any]:
+        return self._command("power.enable", {})
+
+    def power_disable(self) -> Dict[str, Any]:
+        return self._command("power.disable", {})
+
     def spi_cfg(self, spi: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         payload: Dict[str, Any] = {}
         if spi: