RemoteRF 2.0.7__tar.gz → 2.0.8__tar.gz

{remoterf-2.0.7/src/remoterf.egg-info → remoterf-2.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remoterf
-Version: 2.0.7
+Version: 2.0.8
 Summary: A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts.
 Author: Ethan Ge
 Author-email: ethoGalaxy@gmail.com
@@ -53,9 +53,15 @@ source venv/bin/activate    # Activate virtual environment
 pip install remoterf        # Install remoteRF
 ```
 
-## NI USRP-2901 / B200-family
+## NI USRP-2901, Ettus B205-mini, B200-family, and USRP N210
 
-After reserving a server-local or HostRF-owned `usrp` inventory entry, fetch or refresh its
+The packaged client natively includes the shared USRP schema for the qualified
+NI USRP-2901, Ettus Research USRP B205-mini, the broader USB/B200 family, and
+the Ethernet-connected N210. No custom client driver is required. The B205-mini
+uses the same native-style API and reports its live 1 RX/1 TX channel topology
+through `remoterf_capabilities`.
+
+After reserving a server-local `usrp` inventory entry, fetch or refresh its
 Dynamic v2 package with the reservation token:
 
 ```python
@@ -112,6 +118,75 @@ generic native dispatch, but are not release-qualified as exact UHD overload
 parity until the server's UHD 4.10 target-introspection and hardware
 differential gates pass.
 
+## RTL-SDR
+
+RTL-SDR clients are generated from the server's `rtl_sdr` schema. The machine
+running client code does not need `librtlsdr` or PyRtlSdr:
+
+```python
+from remoteRF.drivers import ensure_driver
+
+token = "reservation-token"
+ensure_driver(token=token)
+
+from remoteRF.drivers.rtl_sdr import RtlSdr
+
+sdr = RtlSdr(token)
+sdr.sample_rate = 2_048_000
+sdr.center_freq = 100_000_000
+sdr.gain = "auto"
+sdr.agc_mode = True
+
+samples = sdr.read_samples(16_384)  # NumPy complex64
+raw_iq = sdr.read_bytes(4096)       # packed uint8 I/Q bytes
+```
+
+The server owns the USB handle for its lifetime, so the generated client does
+not close the physical radio. `read_samples` and `read_bytes` are bounded to a
+4 MiB response. Call them repeatedly for longer captures. Native asynchronous
+callbacks are not transported remotely.
+
+When a Tailscale address differs from the IP or DNS identity in the server
+certificate, keep TLS verification enabled and set the expected identity:
+
+```bash
+export REMOTERF_ADDR=rrf2.example.ts.net:61005
+export REMOTERF_TLS_SERVER_NAME=certificate-name.example
+```
+
+## TI mmWave radar
+
+TI radar clients are generated from the server's `ti_mmwave` schema. Only the
+machine physically connected to the radar needs `pyserial` or a CP210x driver.
+The initial parser profile supports xWR68xx mmWave SDK 3 out-of-box TLV output.
+
+```python
+from remoteRF.drivers import ensure_driver
+
+token = "reservation-token"
+ensure_driver(token=token)
+
+from remoteRF.drivers.ti_mmwave import TiMmWave, decode_frame
+
+radar = TiMmWave(token)
+print(radar.device_info)
+print(radar.query_version())
+
+radar.apply_config(open("profile.cfg").read(), start=True)
+try:
+    packet = radar.read_frame(timeout=1.0)
+    frame = decode_frame(packet)
+    print(frame.header.frame_number, frame.points, frame.side_info)
+finally:
+    radar.stop()
+```
+
+`read_frame()` returns one complete binary UART packet. Decoding is client-local
+and retains unknown TLVs as raw bytes, allowing custom firmware to be captured
+before a dedicated parser profile is added. `stream_stats` reports dropped
+frames, queued frames, resynchronization bytes, invalid headers, and reader
+health. Remote firmware flashing is deliberately unsupported.
+
 If `pip install` doesn't work, you can clone the [source](https://github.com/WirelessLabAtUCLA/RemoteRF-Client) directly from github.
 
 <!-- 1. **Clone the repository:**

{remoterf-2.0.7 → remoterf-2.0.8}/README.md

@@ -27,9 +27,15 @@ source venv/bin/activate    # Activate virtual environment
 pip install remoterf        # Install remoteRF
 ```
 
-## NI USRP-2901 / B200-family
+## NI USRP-2901, Ettus B205-mini, B200-family, and USRP N210
 
-After reserving a server-local or HostRF-owned `usrp` inventory entry, fetch or refresh its
+The packaged client natively includes the shared USRP schema for the qualified
+NI USRP-2901, Ettus Research USRP B205-mini, the broader USB/B200 family, and
+the Ethernet-connected N210. No custom client driver is required. The B205-mini
+uses the same native-style API and reports its live 1 RX/1 TX channel topology
+through `remoterf_capabilities`.
+
+After reserving a server-local `usrp` inventory entry, fetch or refresh its
 Dynamic v2 package with the reservation token:
 
 ```python
@@ -86,6 +92,75 @@ generic native dispatch, but are not release-qualified as exact UHD overload
 parity until the server's UHD 4.10 target-introspection and hardware
 differential gates pass.
 
+## RTL-SDR
+
+RTL-SDR clients are generated from the server's `rtl_sdr` schema. The machine
+running client code does not need `librtlsdr` or PyRtlSdr:
+
+```python
+from remoteRF.drivers import ensure_driver
+
+token = "reservation-token"
+ensure_driver(token=token)
+
+from remoteRF.drivers.rtl_sdr import RtlSdr
+
+sdr = RtlSdr(token)
+sdr.sample_rate = 2_048_000
+sdr.center_freq = 100_000_000
+sdr.gain = "auto"
+sdr.agc_mode = True
+
+samples = sdr.read_samples(16_384)  # NumPy complex64
+raw_iq = sdr.read_bytes(4096)       # packed uint8 I/Q bytes
+```
+
+The server owns the USB handle for its lifetime, so the generated client does
+not close the physical radio. `read_samples` and `read_bytes` are bounded to a
+4 MiB response. Call them repeatedly for longer captures. Native asynchronous
+callbacks are not transported remotely.
+
+When a Tailscale address differs from the IP or DNS identity in the server
+certificate, keep TLS verification enabled and set the expected identity:
+
+```bash
+export REMOTERF_ADDR=rrf2.example.ts.net:61005
+export REMOTERF_TLS_SERVER_NAME=certificate-name.example
+```
+
+## TI mmWave radar
+
+TI radar clients are generated from the server's `ti_mmwave` schema. Only the
+machine physically connected to the radar needs `pyserial` or a CP210x driver.
+The initial parser profile supports xWR68xx mmWave SDK 3 out-of-box TLV output.
+
+```python
+from remoteRF.drivers import ensure_driver
+
+token = "reservation-token"
+ensure_driver(token=token)
+
+from remoteRF.drivers.ti_mmwave import TiMmWave, decode_frame
+
+radar = TiMmWave(token)
+print(radar.device_info)
+print(radar.query_version())
+
+radar.apply_config(open("profile.cfg").read(), start=True)
+try:
+    packet = radar.read_frame(timeout=1.0)
+    frame = decode_frame(packet)
+    print(frame.header.frame_number, frame.points, frame.side_info)
+finally:
+    radar.stop()
+```
+
+`read_frame()` returns one complete binary UART packet. Decoding is client-local
+and retains unknown TLVs as raw bytes, allowing custom firmware to be captured
+before a dedicated parser profile is added. `stream_stats` reports dropped
+frames, queued frames, resynchronization bytes, invalid headers, and reader
+health. Remote firmware flashing is deliberately unsupported.
+
 If `pip install` doesn't work, you can clone the [source](https://github.com/WirelessLabAtUCLA/RemoteRF-Client) directly from github.
 
 <!-- 1. **Clone the repository:**

{remoterf-2.0.7 → remoterf-2.0.8}/setup.py

@@ -6,7 +6,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="remoterf",
-    version="2.0.7",
+    version="2.0.8",
     author="Ethan Ge",
     author_email="ethoGalaxy@gmail.com",
     description="A python API to remotely access signal centric hardware. Client-side only! Courtesy of Wireless Lab @ UCLA & Prof. Ian Roberts.",

{remoterf-2.0.7 → remoterf-2.0.8}/src/remoteRF/core/grpc_client.py

@@ -49,6 +49,18 @@ options = [
       ('grpc.max_receive_message_length', 100 * 1024 * 1024),
 ]
 
+# A server reached over Tailscale may present the same certificate it uses on
+# its public or LAN address. Keep certificate verification enabled while
+# allowing the configured certificate identity to differ from REMOTERF_ADDR.
+tls_server_name = (os.getenv("REMOTERF_TLS_SERVER_NAME") or "").strip()
+if tls_server_name:
+    options.extend(
+        [
+            ("grpc.ssl_target_name_override", tls_server_name),
+            ("grpc.default_authority", tls_server_name),
+        ]
+    )
+
 # Server.crt
 certs_path = Path(ca_path).expanduser().resolve()
 with certs_path.open('rb') as f:

remoterf-2.0.8/src/remoteRF/drivers/hackrf/__init__.py

@@ -0,0 +1,6 @@
+from importlib import import_module as _import_module
+
+from . import hackrf_remote as adi
+from .hackrf_remote import HackRF
+
+__all__ = ["adi", "HackRF"]

remoterf-2.0.8/src/remoteRF/drivers/hackrf/hackrf_remote.py

@@ -0,0 +1,216 @@
+# Auto-generated from IDL schema — do not edit by hand.
+# device_type: hackrf  driver_version: 0.1.1  schema_hash: sha256:1d6e935e2e33959e753b89d943a1a5696d814ec28aac52a7c39142b3fce89693
+
+_PREFIX = "Hackrf"
+_SCHEMA_HASH = "sha256:1d6e935e2e33959e753b89d943a1a5696d814ec28aac52a7c39142b3fce89693"
+_CLIENT_MODULES = {}
+_CLIENT_OBJECTS = {}
+
+from importlib import import_module as _import_module
+
+from ...core.grpc_client import rpc_client
+from ...common.utils import map_arg, unmap_arg
+
+_NO_ARG = object()
+
+
+for _alias, _module_path in _CLIENT_MODULES.items():
+    globals()[_alias] = _import_module(_module_path)
+
+
+def _resolve_client_target(target):
+    parts = str(target or "").split(".")
+    if not parts or not parts[0]:
+        raise ValueError(f"Invalid client constructor target: {target!r}")
+    if parts[0] not in globals():
+        raise ValueError(
+            f"Client helper module {parts[0]!r} is not declared in _CLIENT_MODULES"
+        )
+    obj = globals()[parts[0]]
+    for part in parts[1:]:
+        obj = getattr(obj, part)
+    return obj
+
+
+def _client_ctor_arg(spec, self_obj, result):
+    if spec == "$self":
+        return self_obj
+    if spec == "$result":
+        return result
+    if isinstance(spec, dict) and "const" in spec:
+        return spec["const"]
+    return spec
+
+
+def _wrap_client_return(spec, self_obj, result):
+    if not spec:
+        return result
+    if spec.get("kind") != "constructor":
+        raise ValueError(f"Unsupported client_return metadata: {spec!r}")
+    ctor = _resolve_client_target(spec.get("target"))
+    args = [
+        _client_ctor_arg(item, self_obj, result)
+        for item in spec.get("args", [])
+    ]
+    return ctor(*args)
+
+
+def _try_get(prop, token):
+    return unmap_arg(rpc_client(
+        function_name=f"{_PREFIX}:{prop}:GET",
+        args={'a': map_arg(token)},
+    ).results[prop])
+
+
+def _try_set(prop, value, token):
+    rpc_client(
+        function_name=f"{_PREFIX}:{prop}:SET",
+        args={prop: map_arg(value), 'a': map_arg(token)},
+    )
+
+
+def _try_call(prop, token, arg=_NO_ARG):
+    if arg is _NO_ARG:
+        resp = rpc_client(
+            function_name=f"{_PREFIX}:{prop}:CALL0",
+            args={'a': map_arg(token)},
+        )
+    else:
+        resp = rpc_client(
+            function_name=f"{_PREFIX}:{prop}:CALL1",
+            args={'a': map_arg(token), 'arg1': map_arg(arg)},
+        )
+    result = resp.results.get(prop)
+    return unmap_arg(result) if result is not None else None
+
+
+def _try_calln(prop, token, kwargs):
+    payload = {'a': map_arg(token)}
+    for key, value in dict(kwargs).items():
+        if value is _NO_ARG:
+            continue
+        payload[str(key)] = map_arg(value)
+    resp = rpc_client(
+        function_name=f"{_PREFIX}:{prop}:CALLN",
+        args=payload,
+    )
+    result = resp.results.get(prop)
+    return unmap_arg(result) if result is not None else None
+
+class HackRF:
+
+    def __init__(self, token: str):
+        self.token = token
+        from ..dynamic_device import install_driver_if_stale
+        install_driver_if_stale(token=token, current_hash=_SCHEMA_HASH)
+
+    @property
+    def amplifier_on(self):
+        'Whether the 14 dB RF front-end amplifier is enabled.'
+        return _try_get("amplifier_on", self.token)
+
+    @amplifier_on.setter
+    def amplifier_on(self, value):
+        _try_set("amplifier_on", value, self.token)
+
+    @property
+    def bias_tee_on(self):
+        'Whether 3.3 V antenna bias (50 mA maximum) is enabled.'
+        return _try_get("bias_tee_on", self.token)
+
+    @bias_tee_on.setter
+    def bias_tee_on(self, value):
+        _try_set("bias_tee_on", value, self.token)
+
+    @property
+    def center_freq(self):
+        'Center frequency in Hz.'
+        return _try_get("center_freq", self.token)
+
+    @center_freq.setter
+    def center_freq(self, value):
+        _try_set("center_freq", value, self.token)
+
+    @property
+    def filter_bandwidth(self):
+        'Baseband filter bandwidth in Hz.'
+        return _try_get("filter_bandwidth", self.token)
+
+    @filter_bandwidth.setter
+    def filter_bandwidth(self, value):
+        _try_set("filter_bandwidth", value, self.token)
+
+    @property
+    def lna_gain(self):
+        'Receive IF LNA gain in dB (0 to 40, in 8 dB steps).'
+        return _try_get("lna_gain", self.token)
+
+    @lna_gain.setter
+    def lna_gain(self, value):
+        _try_set("lna_gain", value, self.token)
+
+    @property
+    def sample_count_limit(self):
+        'Asynchronous receive limit in raw IQ bytes; zero means unlimited.'
+        return _try_get("sample_count_limit", self.token)
+
+    @sample_count_limit.setter
+    def sample_count_limit(self, value):
+        _try_set("sample_count_limit", value, self.token)
+
+    @property
+    def sample_rate(self):
+        'Complex sample rate in samples per second.'
+        return _try_get("sample_rate", self.token)
+
+    @sample_rate.setter
+    def sample_rate(self, value):
+        _try_set("sample_rate", value, self.token)
+
+    @property
+    def txvga_gain(self):
+        'Transmit VGA gain in dB (0 to 47).'
+        return _try_get("txvga_gain", self.token)
+
+    @txvga_gain.setter
+    def txvga_gain(self, value):
+        _try_set("txvga_gain", value, self.token)
+
+    @property
+    def vga_gain(self):
+        'Receive baseband VGA gain in dB (0 to 62, in 2 dB steps).'
+        return _try_get("vga_gain", self.token)
+
+    @vga_gain.setter
+    def vga_gain(self, value):
+        _try_set("vga_gain", value, self.token)
+
+    def clear_buffer(self):
+        'Clear any captured or queued IQ bytes while the radio is idle.'
+        return _try_call("clear_buffer", self.token)
+
+    def enumerate(self):
+        'Return attached serials as a JSON array for broad client compatibility.'
+        return _try_call("enumerate", self.token)
+
+    def get_serial_no(self):
+        'Read the serial number from the open device.'
+        return _try_call("get_serial_no", self.token)
+
+    def load_tx_iq(self, samples):
+        'Convert normalized IQ samples and load the native transmit buffer.'
+        return _try_call("load_tx_iq", self.token, samples)
+
+    def read_samples(self, num_samples=_NO_ARG):
+        'Synchronously read a bounded complex64 IQ array.'
+        return _try_calln("read_samples", self.token, {
+            "num_samples": num_samples,
+        })
+
+    def start_tx(self):
+        'Start transmitting the IQ bytes previously loaded with load_tx_iq().'
+        return _try_call("start_tx", self.token)
+
+    def stop_tx(self):
+        'Stop an active HackRF transmission.'
+        return _try_call("stop_tx", self.token)

remoterf-2.0.8/src/remoteRF/drivers/rtl_sdr/__init__.py

@@ -0,0 +1,6 @@
+from importlib import import_module as _import_module
+
+from . import rtl_sdr_remote as adi
+from .rtl_sdr_remote import RtlSdr
+
+__all__ = ["adi", "RtlSdr"]

remoterf-2.0.8/src/remoteRF/drivers/rtl_sdr/rtl_sdr_remote.py

@@ -0,0 +1,244 @@
+# Auto-generated from IDL schema — do not edit by hand.
+# device_type: rtl_sdr  driver_version: 0.1.1  schema_hash: sha256:1c84effc2c21be734398a87d24bb9da52ab5b7ea0def955c503da484b8d818c0
+
+_PREFIX = "Rtl_sdr"
+_SCHEMA_HASH = "sha256:1c84effc2c21be734398a87d24bb9da52ab5b7ea0def955c503da484b8d818c0"
+_CLIENT_MODULES = {}
+_CLIENT_OBJECTS = {}
+
+from importlib import import_module as _import_module
+
+from ...core.grpc_client import rpc_client
+from ...common.utils import map_arg, unmap_arg
+
+_NO_ARG = object()
+
+
+for _alias, _module_path in _CLIENT_MODULES.items():
+    globals()[_alias] = _import_module(_module_path)
+
+
+def _resolve_client_target(target):
+    parts = str(target or "").split(".")
+    if not parts or not parts[0]:
+        raise ValueError(f"Invalid client constructor target: {target!r}")
+    if parts[0] not in globals():
+        raise ValueError(
+            f"Client helper module {parts[0]!r} is not declared in _CLIENT_MODULES"
+        )
+    obj = globals()[parts[0]]
+    for part in parts[1:]:
+        obj = getattr(obj, part)
+    return obj
+
+
+def _client_ctor_arg(spec, self_obj, result):
+    if spec == "$self":
+        return self_obj
+    if spec == "$result":
+        return result
+    if isinstance(spec, dict) and "const" in spec:
+        return spec["const"]
+    return spec
+
+
+def _wrap_client_return(spec, self_obj, result):
+    if not spec:
+        return result
+    if spec.get("kind") != "constructor":
+        raise ValueError(f"Unsupported client_return metadata: {spec!r}")
+    ctor = _resolve_client_target(spec.get("target"))
+    args = [
+        _client_ctor_arg(item, self_obj, result)
+        for item in spec.get("args", [])
+    ]
+    return ctor(*args)
+
+
+def _try_get(prop, token):
+    return unmap_arg(rpc_client(
+        function_name=f"{_PREFIX}:{prop}:GET",
+        args={'a': map_arg(token)},
+    ).results[prop])
+
+
+def _try_set(prop, value, token):
+    rpc_client(
+        function_name=f"{_PREFIX}:{prop}:SET",
+        args={prop: map_arg(value), 'a': map_arg(token)},
+    )
+
+
+def _try_call(prop, token, arg=_NO_ARG):
+    if arg is _NO_ARG:
+        resp = rpc_client(
+            function_name=f"{_PREFIX}:{prop}:CALL0",
+            args={'a': map_arg(token)},
+        )
+    else:
+        resp = rpc_client(
+            function_name=f"{_PREFIX}:{prop}:CALL1",
+            args={'a': map_arg(token), 'arg1': map_arg(arg)},
+        )
+    result = resp.results.get(prop)
+    return unmap_arg(result) if result is not None else None
+
+
+def _try_calln(prop, token, kwargs):
+    payload = {'a': map_arg(token)}
+    for key, value in dict(kwargs).items():
+        if value is _NO_ARG:
+            continue
+        payload[str(key)] = map_arg(value)
+    resp = rpc_client(
+        function_name=f"{_PREFIX}:{prop}:CALLN",
+        args=payload,
+    )
+    result = resp.results.get(prop)
+    return unmap_arg(result) if result is not None else None
+
+class RtlSdr:
+
+    def __init__(self, token: str):
+        self.token = token
+        from ..dynamic_device import install_driver_if_stale
+        install_driver_if_stale(token=token, current_hash=_SCHEMA_HASH)
+
+    @property
+    def agc_mode(self):
+        return _try_get("agc_mode", self.token)
+
+    @agc_mode.setter
+    def agc_mode(self, value):
+        _try_set("agc_mode", value, self.token)
+
+    @property
+    def bandwidth(self):
+        'Tuner bandwidth in Hz; zero requests automatic selection.'
+        return _try_get("bandwidth", self.token)
+
+    @bandwidth.setter
+    def bandwidth(self, value):
+        _try_set("bandwidth", value, self.token)
+
+    @property
+    def bias_tee(self):
+        return _try_get("bias_tee", self.token)
+
+    @bias_tee.setter
+    def bias_tee(self, value):
+        _try_set("bias_tee", value, self.token)
+
+    @property
+    def center_freq(self):
+        'Tuner center frequency in Hz.'
+        return _try_get("center_freq", self.token)
+
+    @center_freq.setter
+    def center_freq(self, value):
+        _try_set("center_freq", value, self.token)
+
+    @property
+    def device_index(self):
+        return _try_get("device_index", self.token)
+
+    @property
+    def direct_sampling(self):
+        return _try_get("direct_sampling", self.token)
+
+    @direct_sampling.setter
+    def direct_sampling(self, value):
+        _try_set("direct_sampling", value, self.token)
+
+    @property
+    def dithering(self):
+        return _try_get("dithering", self.token)
+
+    @dithering.setter
+    def dithering(self, value):
+        _try_set("dithering", value, self.token)
+
+    @property
+    def fc(self):
+        'Alias for center_freq, matching PyRtlSdr.'
+        return _try_get("fc", self.token)
+
+    @fc.setter
+    def fc(self, value):
+        _try_set("fc", value, self.token)
+
+    @property
+    def freq_correction(self):
+        'Frequency correction in parts per million.'
+        return _try_get("freq_correction", self.token)
+
+    @freq_correction.setter
+    def freq_correction(self, value):
+        _try_set("freq_correction", value, self.token)
+
+    @property
+    def gain(self):
+        'Tuner gain in dB, or auto when automatic gain is enabled.'
+        return _try_get("gain", self.token)
+
+    @gain.setter
+    def gain(self, value):
+        _try_set("gain", value, self.token)
+
+    @property
+    def offset_tuning(self):
+        return _try_get("offset_tuning", self.token)
+
+    @offset_tuning.setter
+    def offset_tuning(self, value):
+        _try_set("offset_tuning", value, self.token)
+
+    @property
+    def rs(self):
+        'Alias for sample_rate, matching PyRtlSdr.'
+        return _try_get("rs", self.token)
+
+    @rs.setter
+    def rs(self, value):
+        _try_set("rs", value, self.token)
+
+    @property
+    def sample_rate(self):
+        'Complex sample rate in samples per second.'
+        return _try_get("sample_rate", self.token)
+
+    @sample_rate.setter
+    def sample_rate(self, value):
+        _try_set("sample_rate", value, self.token)
+
+    @property
+    def serial_number(self):
+        return _try_get("serial_number", self.token)
+
+    @property
+    def tuner_type(self):
+        return _try_get("tuner_type", self.token)
+
+    @property
+    def usb_strings(self):
+        return _try_get("usb_strings", self.token)
+
+    @property
+    def valid_gains_db(self):
+        return _try_get("valid_gains_db", self.token)
+
+    def read_bytes(self, num_bytes=_NO_ARG):
+        'Read packed unsigned 8-bit interleaved IQ bytes.'
+        return _try_calln("read_bytes", self.token, {
+            "num_bytes": num_bytes,
+        })
+
+    def read_samples(self, num_samples=_NO_ARG):
+        'Read normalized complex64 IQ samples.'
+        return _try_calln("read_samples", self.token, {
+            "num_samples": num_samples,
+        })
+
+    def reset_buffer(self):
+        'Discard pending USB samples before a new capture.'
+        return _try_call("reset_buffer", self.token)