lr-shuttle 0.2.1__tar.gz → 0.2.2__tar.gz

{lr_shuttle-0.2.1 → lr_shuttle-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lr-shuttle
-Version: 0.2.1
+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.1 → lr_shuttle-0.2.2}/README.md

@@ -221,6 +221,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 → lr_shuttle-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lr-shuttle"
-version = "0.2.1"
+version = "0.2.2"
 description = "CLI and Python client for host-side of json based serial communication with embedded device bridge."
 readme = "README.md"
 requires-python = ">=3.11"

{lr_shuttle-0.2.1 → lr_shuttle-0.2.2}/src/lr_shuttle.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lr-shuttle
-Version: 0.2.1
+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.1 → lr_shuttle-0.2.2}/src/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,