remoteRF-server 0.2.3__tar.gz → 1.0.0__tar.gz

{remoterf_server-0.2.3 → remoterf_server-1.0.0}/PKG-INFO

@@ -1,6 +1,8 @@
 Metadata-Version: 2.4
 Name: remoteRF-server
-Version: 0.2.3
+Version: 1.0.0
+Summary: RemoteRF server-side control package
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: grpcio
 Requires-Dist: protobuf

{remoterf_server-0.2.3 → remoterf_server-1.0.0}/pyproject.toml

@@ -4,7 +4,9 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remoteRF-server"
-version = "0.2.3"
+version = "1.0.0"
+description = "RemoteRF server-side control package"
+requires-python = ">=3.8"
 dependencies = [
   "grpcio",
   "protobuf",

remoterf_server-1.0.0/src/remoteRF_server/common/idl/pluto_mimo_schema.py

@@ -0,0 +1,6 @@
+# Built-in import shim for the packaged ADALM Pluto MIMO schema.
+
+from remoteRF_server.drivers.adalm_pluto.pluto_mimo_schema import (  # noqa: F401
+    PlutoMIMOSchema,
+    connect_pluto_mimo,
+)

{remoterf_server-0.2.3 → remoterf_server-1.0.0}/src/remoteRF_server/common/idl/pluto_schema.py

@@ -1,15 +1,14 @@
-# ~/.config/remoterf/drivers/pluto_schema.py
-#
-# Admin-written schema for ADALM-Pluto devices.
-# Drop this file into the drivers folder, restart the server. Done.
+# SAMPLE schema for ADI Pluto SDR.
+# Place into -> ~/.config/remoterf/drivers and restart server to utilize!
 
-from . import *
+
+from remoteRF_server.common.idl import DeviceSchema, idl_register, idl_expose
 
 import subprocess
 import re
 import adi
 
-# ========================= PLUTO Connection Logic =========================
+# == PLUTO Connection Logic ==
 
 def connect_pluto(*, serial: str):
     serial = (serial or "").strip()
@@ -46,10 +45,11 @@ def connect_pluto(*, serial: str):
 
 # ========================= PLUTO Schema =========================
 
-@idl_register("pluto")
+@idl_register("adalm_pluto")
 class PlutoSchema(DeviceSchema):
 
-    device_type = "pluto"
+    device_type = "adalm_pluto"
+    client_class = "Pluto"
     driver_version = "0.0.1"
 
     @staticmethod
@@ -85,11 +85,13 @@ class PlutoSchema(DeviceSchema):
 
     @idl_expose(kind="get")
     def get_rx_hardwaregain_chan0(self):
-        return self.device.rx_hardwaregain_chan0
+        """RX hardware gain (dB). pyadi-iio attribute: hardwaregain_chan0"""
+        return self.device.hardwaregain_chan0
 
     @idl_expose(kind="set")
     def set_rx_hardwaregain_chan0(self, value):
-        self.device.rx_hardwaregain_chan0 = value
+        """RX hardware gain (dB). pyadi-iio attribute: hardwaregain_chan0"""
+        self.device.hardwaregain_chan0 = value
 
     @idl_expose(kind="get")
     def get_tx_hardwaregain_chan0(self):
@@ -171,4 +173,57 @@ class PlutoSchema(DeviceSchema):
 
     @idl_expose(kind="call")
     def call_tx_destroy_buffer(self):
-        self.device.tx_destroy_buffer()
+        self.device.tx_destroy_buffer()
+
+    @idl_expose(kind="call")
+    def call_disable_dds(self):
+        """Disable the internal DDS tone generator."""
+        self.device.disable_dds()
+
+    # endregion
+
+    # region ip / repr
+
+    @idl_expose(kind="call")
+    def call_ip(self):
+        """Return a connection identifier for this device (ping / verify)."""
+        try:
+            return str(self.device.uri)
+        except AttributeError:
+            return str(self.device._uri_auto)
+
+    @idl_expose(kind="get")
+    def get_repr(self):
+        """Return repr() of the underlying device object."""
+        return repr(self.device)
+
+    # endregion
+
+    # region _dec_int_fpga_filter
+
+    @idl_expose(kind="get")
+    def get_rx_dec8_filter_en(self):
+        """rx_dec8_filter_en: Enable decimate-by-8 filter in FPGA"""
+        return bool(self.device.rx_dec8_filter_en)
+
+    @idl_expose(kind="set")
+    def set_rx_dec8_filter_en(self, value):
+        """rx_dec8_filter_en: Enable decimate-by-8 filter in FPGA"""
+        self.device.rx_dec8_filter_en = value
+
+    @idl_expose(kind="get")
+    def get_tx_int8_filter_en(self):
+        """tx_int8_filter_en: Enable interpolate-by-8 filter in FPGA"""
+        return bool(self.device.tx_int8_filter_en)
+
+    @idl_expose(kind="set")
+    def set_tx_int8_filter_en(self, value):
+        """tx_int8_filter_en: Enable interpolate-by-8 filter in FPGA"""
+        self.device.tx_int8_filter_en = value
+
+    @idl_expose(kind="get")
+    def get_rates(self):
+        """Get decimation/interpolation rates from the FPGA filter block."""
+        return self.device._get_rates(self.device._rxadc, False)
+
+    # endregion

{remoterf_server-0.2.3 → remoterf_server-1.0.0}/src/remoteRF_server/common/idl/schema.py

@@ -263,7 +263,7 @@ class DeviceSchema:
             elif ex.kind == "call":
                 calls[name] = entry
 
-        return {
+        body = {
             "schema_version": "1.0",
             "device_type": self.device_type,
             "driver_version": self.driver_version,
@@ -272,6 +272,12 @@ class DeviceSchema:
             "calls": calls,
         }
 
+        client_class = getattr(self, "client_class", "")
+        if client_class:
+            body["client_class"] = str(client_class)
+
+        return body
+
     # ── Dispatch (server RPC layer calls this) ────────────────────
 
     def dispatch(self, method_name: str, args: dict) -> Any:
@@ -355,4 +361,4 @@ class _Exposed:
         self.name = name
         self.fn = fn
         self.kind = kind
-        self.doc = doc
+        self.doc = doc

{remoterf_server-0.2.3 → remoterf_server-1.0.0}/src/remoteRF_server/common/utils/process_arg.py

@@ -23,26 +23,36 @@ def unmap_arg(arg):
 def map_arg(value):
     arg = grpc_pb2.Argument()
     
-    if isinstance(value, int):
-        arg.int64_value = value
-    elif isinstance(value, float):
-        arg.float_value = value
+    if isinstance(value, (bool, np.bool_)):
+        arg.bool_value = bool(value)
+    elif isinstance(value, (int, np.integer)):
+        arg.int64_value = int(value)
+    elif isinstance(value, (float, np.floating)):
+        arg.float_value = float(value)
     elif isinstance(value, str):
         arg.string_value = value
-    elif isinstance(value, bool):
-        arg.bool_value = value
+    elif isinstance(value, (list, tuple)):
+        array = np.asarray(value)
+        if array.dtype == object:
+            try:
+                array = np.stack(value)
+            except Exception as exc:
+                raise ValueError(f"Cannot map ragged/object array value: {value}") from exc
+        return map_arg(array)
     elif isinstance(value, np.ndarray):
+        if value.dtype == object:
+            raise ValueError(f"Cannot map object-dtype array: {value!r}")
         if np.iscomplexobj(value):
             complex_array = arg.complex_array
             complex_array.shape.dim.extend(value.shape)
-            for num in value.ravel():
+            for num in np.asarray(value, dtype=np.complex64).ravel():
                 complex_num = complex_array.data.add()
-                complex_num.real = num.real
-                complex_num.imag = num.imag
+                complex_num.real = float(num.real)
+                complex_num.imag = float(num.imag)
         else:
             float_array = arg.real_array
             float_array.shape.dim.extend(value.shape)
-            float_array.data.extend(value.ravel())
+            float_array.data.extend(np.asarray(value, dtype=np.float32).ravel())
     else:
         raise ValueError(f"Unknown argument type during mapping: {value}")
     return arg
@@ -77,4 +87,3 @@ def unmap_array_proto(arg):
         return np.array(arg.float_array.data, dtype=np.float32)
     else:
         raise ValueError("Argument does not contain a recognizable array.")
-

remoterf_server-1.0.0/src/remoteRF_server/drivers/adalm_pluto/pluto_mimo_schema.py

@@ -0,0 +1,181 @@
+# SAMPLE schema for ADI Pluto SDR in AD9361 MIMO / 2R2T mode.
+# Place into -> ~/.config/remoterf/drivers and restart server to utilize!
+
+from remoteRF_server.common.idl import idl_register, idl_expose
+from remoteRF_server.common.idl.pluto_schema import PlutoSchema
+
+import subprocess
+import re
+import adi
+
+
+def _normalize_channels(value, default):
+    if value is None:
+        return list(default)
+    if isinstance(value, str):
+        if not value.strip():
+            return list(default)
+        return [int(part.strip()) for part in value.split(",") if part.strip()]
+    return [int(ch) for ch in value]
+
+
+def _get_attr(device, *names):
+    for name in names:
+        if hasattr(device, name):
+            return getattr(device, name)
+    raise AttributeError(f"{device!r} has none of: {', '.join(names)}")
+
+
+def _set_attr(device, value, *names):
+    for name in names:
+        if hasattr(device, name):
+            setattr(device, name, value)
+            return
+    raise AttributeError(f"{device!r} has none of: {', '.join(names)}")
+
+
+def _apply_initial_settings(device, settings):
+    int_attrs = (
+        "sample_rate",
+        "rx_lo",
+        "tx_lo",
+        "rx_rf_bandwidth",
+        "tx_rf_bandwidth",
+        "rx_buffer_size",
+    )
+    for attr in int_attrs:
+        value = settings.get(attr)
+        if value is not None:
+            setattr(device, attr, int(value))
+
+
+# == PLUTO MIMO Connection Logic ==
+
+def connect_pluto_mimo(
+    *,
+    serial,
+    rx_enabled_channels=None,
+    tx_enabled_channels=None,
+    initial_settings=None,
+):
+    serial = (serial or "").strip()
+    if not serial:
+        print("An adalm_pluto_mimo serial must be provided")
+        return None
+
+    try:
+        out = subprocess.check_output(
+            ["iio_info", "-s"],
+            text=True,
+            stderr=subprocess.STDOUT,
+        )
+
+        usb = None
+        for line in out.splitlines():
+            if (f"serial={serial}" in line) or (f"hw_serial={serial}" in line):
+                m = re.search(r"\[usb:([^\]]+)\]", line)
+                if m:
+                    usb = m.group(1).strip()
+                    break
+
+        if not usb:
+            print(f"No adalm_pluto_mimo device found with serial {serial}")
+            return None
+
+        dev = adi.ad9361(f"usb:{usb}")
+        dev.rx_enabled_channels = _normalize_channels(rx_enabled_channels, [0, 1])
+        dev.tx_enabled_channels = _normalize_channels(tx_enabled_channels, [0, 1])
+        _apply_initial_settings(dev, initial_settings or {})
+        print(f"Connected to adalm_pluto_mimo serial={serial} via usb:{usb}")
+        return dev
+
+    except Exception as e:
+        print(f"Failed to connect to adalm_pluto_mimo serial={serial}: {e}")
+        return None
+
+
+# ========================= PLUTO MIMO Schema =========================
+
+@idl_register("adalm_pluto_mimo")
+class PlutoMIMOSchema(PlutoSchema):
+
+    device_type = "adalm_pluto_mimo"
+    client_class = "PlutoMIMO"
+    driver_version = "0.0.1"
+
+    @staticmethod
+    def make_device(**kwargs):
+        return connect_pluto_mimo(
+            serial=kwargs.get("serial"),
+            rx_enabled_channels=kwargs.get("rx_enabled_channels"),
+            tx_enabled_channels=kwargs.get("tx_enabled_channels"),
+            initial_settings=kwargs,
+        )
+
+    # region MIMO channel selection
+
+    @idl_expose(kind="get")
+    def get_mode(self):
+        return "mimo"
+
+    @idl_expose(kind="get")
+    def get_rx_enabled_channels(self):
+        return list(self.device.rx_enabled_channels)
+
+    @idl_expose(kind="set")
+    def set_rx_enabled_channels(self, value):
+        self.device.rx_enabled_channels = _normalize_channels(value, [0, 1])
+
+    @idl_expose(kind="get")
+    def get_tx_enabled_channels(self):
+        return list(self.device.tx_enabled_channels)
+
+    @idl_expose(kind="set")
+    def set_tx_enabled_channels(self, value):
+        self.device.tx_enabled_channels = _normalize_channels(value, [0, 1])
+
+    # endregion
+
+    # region channel 1 controls
+
+    @idl_expose(kind="get")
+    def get_gain_control_mode_chan1(self):
+        return self.device.gain_control_mode_chan1
+
+    @idl_expose(kind="set")
+    def set_gain_control_mode_chan1(self, value):
+        self.device.gain_control_mode_chan1 = value
+
+    @idl_expose(kind="get")
+    def get_rx_hardwaregain_chan1(self):
+        """RX channel 1 hardware gain (dB)."""
+        return _get_attr(self.device, "rx_hardwaregain_chan1", "hardwaregain_chan1")
+
+    @idl_expose(kind="set")
+    def set_rx_hardwaregain_chan1(self, value):
+        """RX channel 1 hardware gain (dB)."""
+        _set_attr(self.device, value, "rx_hardwaregain_chan1", "hardwaregain_chan1")
+
+    @idl_expose(kind="get")
+    def get_tx_hardwaregain_chan1(self):
+        return self.device.tx_hardwaregain_chan1
+
+    @idl_expose(kind="set")
+    def set_tx_hardwaregain_chan1(self, value):
+        self.device.tx_hardwaregain_chan1 = value
+
+    # endregion
+
+    # region AD9361 gain compatibility
+
+    @idl_expose(kind="get")
+    def get_rx_hardwaregain_chan0(self):
+        """RX channel 0 hardware gain (dB)."""
+        return _get_attr(self.device, "rx_hardwaregain_chan0", "hardwaregain_chan0")
+
+    @idl_expose(kind="set")
+    def set_rx_hardwaregain_chan0(self, value):
+        """RX channel 0 hardware gain (dB)."""
+        _set_attr(self.device, value, "rx_hardwaregain_chan0", "hardwaregain_chan0")
+
+    # endregion

remoterf_server-1.0.0/src/remoteRF_server/drivers/adalm_pluto/pluto_schema.py

@@ -0,0 +1,229 @@
+# SAMPLE schema for ADI Pluto SDR.
+# Place into -> ~/.config/remoterf/drivers and restart server to utilize!
+
+
+from remoteRF_server.common.idl import DeviceSchema, idl_register, idl_expose
+
+import subprocess
+import re
+import adi
+
+# == PLUTO Connection Logic ==
+
+def connect_pluto(*, serial: str):
+    serial = (serial or "").strip()
+    if not serial:
+        print("A Pluto serial must be provided")
+        return None
+
+    try:
+        out = subprocess.check_output(
+            ["iio_info", "-s"],
+            text=True,
+            stderr=subprocess.STDOUT
+        )
+
+        usb = None
+        for line in out.splitlines():
+            if (f"serial={serial}" in line) or (f"hw_serial={serial}" in line):
+                m = re.search(r"\[usb:([^\]]+)\]", line)
+                if m:
+                    usb = m.group(1).strip()
+                    break
+
+        if not usb:
+            print(f"No device found with serial {serial}")
+            return None
+
+        dev = adi.Pluto(f"usb:{usb}")
+        print(f"Connected to Pluto serial={serial} via usb:{usb}")
+        return dev
+
+    except Exception as e:
+        print(f"Failed to connect to Pluto serial={serial}: {e}")
+        return None
+
+# ========================= PLUTO Schema =========================
+
+@idl_register("adalm_pluto")
+class PlutoSchema(DeviceSchema):
+
+    device_type = "adalm_pluto"
+    client_class = "Pluto"
+    driver_version = "0.0.1"
+
+    @staticmethod
+    def make_device(**kwargs):
+        serial = kwargs.get("serial")
+        return connect_pluto(serial=serial)
+
+    # region ad9364
+
+    @idl_expose(kind="get")
+    def get_filter(self):
+        return self.device.filter
+
+    @idl_expose(kind="set")
+    def set_filter(self, value):
+        self.device.filter = value
+
+    @idl_expose(kind="get")
+    def get_loopback(self):
+        return self.device.loopback
+
+    @idl_expose(kind="set")
+    def set_loopback(self, value):
+        self.device.loopback = value
+
+    @idl_expose(kind="get")
+    def get_gain_control_mode_chan0(self):
+        return self.device.gain_control_mode_chan0
+
+    @idl_expose(kind="set")
+    def set_gain_control_mode_chan0(self, value):
+        self.device.gain_control_mode_chan0 = value
+
+    @idl_expose(kind="get")
+    def get_rx_hardwaregain_chan0(self):
+        """RX hardware gain (dB). pyadi-iio attribute: hardwaregain_chan0"""
+        return self.device.hardwaregain_chan0
+
+    @idl_expose(kind="set")
+    def set_rx_hardwaregain_chan0(self, value):
+        """RX hardware gain (dB). pyadi-iio attribute: hardwaregain_chan0"""
+        self.device.hardwaregain_chan0 = value
+
+    @idl_expose(kind="get")
+    def get_tx_hardwaregain_chan0(self):
+        return self.device.tx_hardwaregain_chan0
+
+    @idl_expose(kind="set")
+    def set_tx_hardwaregain_chan0(self, value):
+        self.device.tx_hardwaregain_chan0 = value
+
+    @idl_expose(kind="get")
+    def get_rx_rf_bandwidth(self):
+        return self.device.rx_rf_bandwidth
+
+    @idl_expose(kind="set")
+    def set_rx_rf_bandwidth(self, value):
+        self.device.rx_rf_bandwidth = value
+
+    @idl_expose(kind="get")
+    def get_tx_rf_bandwidth(self):
+        return self.device.tx_rf_bandwidth
+
+    @idl_expose(kind="set")
+    def set_tx_rf_bandwidth(self, value):
+        self.device.tx_rf_bandwidth = value
+
+    @idl_expose(kind="get")
+    def get_sample_rate(self):
+        return self.device.sample_rate
+
+    @idl_expose(kind="set")
+    def set_sample_rate(self, value):
+        self.device.sample_rate = value
+
+    @idl_expose(kind="get")
+    def get_rx_lo(self):
+        return self.device.rx_lo
+
+    @idl_expose(kind="set")
+    def set_rx_lo(self, value):
+        self.device.rx_lo = value
+
+    @idl_expose(kind="get")
+    def get_tx_lo(self):
+        return self.device.tx_lo
+
+    @idl_expose(kind="set")
+    def set_tx_lo(self, value):
+        self.device.tx_lo = value
+
+    @idl_expose(kind="get")
+    def get_tx_cyclic_buffer(self):
+        return self.device.tx_cyclic_buffer
+
+    @idl_expose(kind="set")
+    def set_tx_cyclic_buffer(self, value):
+        self.device.tx_cyclic_buffer = value
+
+    # region RX/TX
+
+    @idl_expose(kind="call")
+    def call_rx(self):
+        return self.device.rx()
+
+    @idl_expose(kind="get")
+    def get_rx_buffer_size(self):
+        return self.device.rx_buffer_size
+
+    @idl_expose(kind="set")
+    def set_rx_buffer_size(self, value):
+        self.device.rx_buffer_size = value
+
+    @idl_expose(kind="call")
+    def call_rx_destroy_buffer(self):
+        self.device.rx_destroy_buffer()
+
+    @idl_expose(kind="call")
+    def call_tx(self, value):
+        self.device.tx(value)
+
+    @idl_expose(kind="call")
+    def call_tx_destroy_buffer(self):
+        self.device.tx_destroy_buffer()
+
+    @idl_expose(kind="call")
+    def call_disable_dds(self):
+        """Disable the internal DDS tone generator."""
+        self.device.disable_dds()
+
+    # endregion
+
+    # region ip / repr
+
+    @idl_expose(kind="call")
+    def call_ip(self):
+        """Return a connection identifier for this device (ping / verify)."""
+        try:
+            return str(self.device.uri)
+        except AttributeError:
+            return str(self.device._uri_auto)
+
+    @idl_expose(kind="get")
+    def get_repr(self):
+        """Return repr() of the underlying device object."""
+        return repr(self.device)
+
+    # endregion
+
+    # region _dec_int_fpga_filter
+
+    @idl_expose(kind="get")
+    def get_rx_dec8_filter_en(self):
+        """rx_dec8_filter_en: Enable decimate-by-8 filter in FPGA"""
+        return bool(self.device.rx_dec8_filter_en)
+
+    @idl_expose(kind="set")
+    def set_rx_dec8_filter_en(self, value):
+        """rx_dec8_filter_en: Enable decimate-by-8 filter in FPGA"""
+        self.device.rx_dec8_filter_en = value
+
+    @idl_expose(kind="get")
+    def get_tx_int8_filter_en(self):
+        """tx_int8_filter_en: Enable interpolate-by-8 filter in FPGA"""
+        return bool(self.device.tx_int8_filter_en)
+
+    @idl_expose(kind="set")
+    def set_tx_int8_filter_en(self, value):
+        """tx_int8_filter_en: Enable interpolate-by-8 filter in FPGA"""
+        self.device.tx_int8_filter_en = value
+
+    @idl_expose(kind="get")
+    def get_rates(self):
+        """Get decimation/interpolation rates from the FPGA filter block."""
+        return self.device._get_rates(self.device._rxadc, False)
+
+    # endregion