spectre-core 0.0.25__py3-none-any.whl → 0.0.26__py3-none-any.whl

spectre_core/receivers/plugins/_b200mini.py

@@ -3,22 +3,217 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 from dataclasses import dataclass
+from functools import partial
+from typing import Callable, Optional
 
-from ._receiver_names import ReceiverName
-from ._usrp import (
-    get_pvalidator_fixed_center_frequency,
-    get_pvalidator_swept_center_frequency,
-    get_capture_template_fixed_center_frequency,
-    get_capture_template_swept_center_frequency,
+from spectre_core.capture_configs import (
+    CaptureTemplate,
+    CaptureMode,
+    Parameters,
+    Bound,
+    PName,
+    OneOf,
+    get_base_capture_template,
+    get_base_ptemplate,
+    validate_fixed_center_frequency,
+    validate_swept_center_frequency,
+    validate_sample_rate_with_master_clock_rate,
 )
-from .gr._usrp import CaptureMethod
-from .._spec_names import SpecName
-from .._base import BaseReceiver
+
+from ._receiver_names import ReceiverName
+from ._gr import capture
+from ._b200mini_gr import fixed_center_frequency, swept_center_frequency
+from .._receiver import Receiver
+from .._specs import SpecName
 from .._register import register_receiver
 
 
+def _make_pvalidator_fixed_center_frequency(
+    receiver: Receiver,
+) -> Callable[[Parameters], None]:
+    def pvalidator(parameters: Parameters) -> None:
+        validate_fixed_center_frequency(parameters)
+        validate_sample_rate_with_master_clock_rate(parameters)
+
+    return pvalidator
+
+
+def _make_pvalidator_swept_center_frequency(
+    receiver: Receiver,
+) -> Callable[[Parameters], None]:
+    def pvalidator(parameters: Parameters) -> None:
+        validate_swept_center_frequency(
+            parameters, receiver.get_spec(SpecName.API_RETUNING_LATENCY)
+        )
+        validate_sample_rate_with_master_clock_rate(parameters)
+
+    return pvalidator
+
+
+def _make_capture_template_fixed_center_frequency(
+    receiver: Receiver,
+) -> CaptureTemplate:
+
+    capture_template = get_base_capture_template(CaptureMode.FIXED_CENTER_FREQUENCY)
+    capture_template.add_ptemplate(get_base_ptemplate(PName.BANDWIDTH))
+    capture_template.add_ptemplate(get_base_ptemplate(PName.GAIN))
+    capture_template.add_ptemplate(get_base_ptemplate(PName.WIRE_FORMAT))
+    capture_template.add_ptemplate(get_base_ptemplate(PName.MASTER_CLOCK_RATE))
+
+    # TODO: Delegate defaults to receiver subclasses. Currently, these are sensible defaults for the b200mini
+    capture_template.set_defaults(
+        (PName.BATCH_SIZE, 4.0),
+        (PName.CENTER_FREQUENCY, 95800000),
+        (PName.SAMPLE_RATE, 2000000),
+        (PName.BANDWIDTH, 2000000),
+        (PName.WINDOW_HOP, 512),
+        (PName.WINDOW_SIZE, 1024),
+        (PName.WINDOW_TYPE, "blackman"),
+        (PName.GAIN, 35),
+        (PName.WIRE_FORMAT, "sc16"),
+        (PName.MASTER_CLOCK_RATE, 40e6),
+    )
+
+    capture_template.add_pconstraint(
+        PName.CENTER_FREQUENCY,
+        [
+            Bound(
+                lower_bound=receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
+                upper_bound=receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND),
+            )
+        ],
+    )
+    capture_template.add_pconstraint(
+        PName.SAMPLE_RATE,
+        [
+            Bound(
+                lower_bound=receiver.get_spec(SpecName.SAMPLE_RATE_LOWER_BOUND),
+                upper_bound=receiver.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND),
+            )
+        ],
+    )
+    capture_template.add_pconstraint(
+        PName.BANDWIDTH,
+        [
+            Bound(
+                lower_bound=receiver.get_spec(SpecName.BANDWIDTH_LOWER_BOUND),
+                upper_bound=receiver.get_spec(SpecName.BANDWIDTH_UPPER_BOUND),
+            )
+        ],
+    )
+    capture_template.add_pconstraint(
+        PName.GAIN,
+        [
+            Bound(
+                lower_bound=0,
+                upper_bound=receiver.get_spec(SpecName.GAIN_UPPER_BOUND),
+            )
+        ],
+    )
+    capture_template.add_pconstraint(
+        PName.WIRE_FORMAT, [OneOf(receiver.get_spec(SpecName.WIRE_FORMATS))]
+    )
+    capture_template.add_pconstraint(
+        PName.MASTER_CLOCK_RATE,
+        [
+            Bound(
+                lower_bound=receiver.get_spec(SpecName.MASTER_CLOCK_RATE_LOWER_BOUND),
+                upper_bound=receiver.get_spec(SpecName.MASTER_CLOCK_RATE_UPPER_BOUND),
+            )
+        ],
+    )
+    return capture_template
+
+
+def _make_capture_template_swept_center_frequency(
+    receiver: Receiver,
+) -> CaptureTemplate:
+
+    capture_template = get_base_capture_template(CaptureMode.SWEPT_CENTER_FREQUENCY)
+    capture_template.add_ptemplate(get_base_ptemplate(PName.BANDWIDTH))
+    capture_template.add_ptemplate(get_base_ptemplate(PName.GAIN))
+    capture_template.add_ptemplate(get_base_ptemplate(PName.WIRE_FORMAT))
+    capture_template.add_ptemplate(get_base_ptemplate(PName.MASTER_CLOCK_RATE))
+
+    # TODO: Delegate defaults to receiver subclasses. Currently, these are sensible defaults for the b200mini
+    capture_template.set_defaults(
+        (PName.BATCH_SIZE, 4.0),
+        (PName.MIN_FREQUENCY, 95000000),
+        (PName.MAX_FREQUENCY, 105000000),
+        (PName.SAMPLES_PER_STEP, 30000),
+        (PName.FREQUENCY_STEP, 2000000),
+        (PName.SAMPLE_RATE, 2000000),
+        (PName.BANDWIDTH, 2000000),
+        (PName.WINDOW_HOP, 512),
+        (PName.WINDOW_SIZE, 1024),
+        (PName.WINDOW_TYPE, "blackman"),
+        (PName.GAIN, 35),
+        (PName.WIRE_FORMAT, "sc16"),
+        (PName.MASTER_CLOCK_RATE, 40e6),
+    )
+
+    capture_template.add_pconstraint(
+        PName.MIN_FREQUENCY,
+        [
+            Bound(
+                lower_bound=receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
+                upper_bound=receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND),
+            )
+        ],
+    )
+    capture_template.add_pconstraint(
+        PName.MAX_FREQUENCY,
+        [
+            Bound(
+                lower_bound=receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
+                upper_bound=receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND),
+            )
+        ],
+    )
+    capture_template.add_pconstraint(
+        PName.SAMPLE_RATE,
+        [
+            Bound(
+                lower_bound=receiver.get_spec(SpecName.SAMPLE_RATE_LOWER_BOUND),
+                upper_bound=receiver.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND),
+            )
+        ],
+    )
+    capture_template.add_pconstraint(
+        PName.BANDWIDTH,
+        [
+            Bound(
+                lower_bound=receiver.get_spec(SpecName.BANDWIDTH_LOWER_BOUND),
+                upper_bound=receiver.get_spec(SpecName.BANDWIDTH_UPPER_BOUND),
+            )
+        ],
+    )
+    capture_template.add_pconstraint(
+        PName.GAIN,
+        [
+            Bound(
+                lower_bound=0,
+                upper_bound=receiver.get_spec(SpecName.GAIN_UPPER_BOUND),
+            )
+        ],
+    )
+    capture_template.add_pconstraint(
+        PName.WIRE_FORMAT, [OneOf(receiver.get_spec(SpecName.WIRE_FORMATS))]
+    )
+    capture_template.add_pconstraint(
+        PName.MASTER_CLOCK_RATE,
+        [
+            Bound(
+                lower_bound=receiver.get_spec(SpecName.MASTER_CLOCK_RATE_LOWER_BOUND),
+                upper_bound=receiver.get_spec(SpecName.MASTER_CLOCK_RATE_UPPER_BOUND),
+            )
+        ],
+    )
+    return capture_template
+
+
 @dataclass(frozen=True)
-class Mode:
+class _Mode:
     """An operating mode for the `B200mini` receiver."""
 
     FIXED_CENTER_FREQUENCY = "fixed_center_frequency"
@@ -26,10 +221,12 @@ class Mode:
 
 
 @register_receiver(ReceiverName.B200MINI)
-class B200mini(BaseReceiver):
+class B200mini(Receiver):
     """Receiver implementation for the USRP B200mini (https://www.ettus.com/all-products/usrp-b200mini/)"""
 
-    def _add_specs(self) -> None:
+    def __init__(self, name: ReceiverName, mode: Optional[str] = None) -> None:
+        super().__init__(name, mode)
+
         self.add_spec(SpecName.SAMPLE_RATE_LOWER_BOUND, 200e3)
         self.add_spec(SpecName.SAMPLE_RATE_UPPER_BOUND, 56e6)
         self.add_spec(SpecName.FREQUENCY_LOWER_BOUND, 70e6)
@@ -44,28 +241,16 @@ class B200mini(BaseReceiver):
             SpecName.API_RETUNING_LATENCY, 1e-5
         )  # TODO: This is a ballpark, pending empirical testing
 
-    def _add_capture_methods(self) -> None:
-        self.add_capture_method(
-            Mode.FIXED_CENTER_FREQUENCY, CaptureMethod.fixed_center_frequency
-        )
-        self.add_capture_method(
-            Mode.SWEPT_CENTER_FREQUENCY, CaptureMethod.swept_center_frequency
-        )
-
-    def _add_capture_templates(self) -> None:
-        self.add_capture_template(
-            Mode.FIXED_CENTER_FREQUENCY,
-            get_capture_template_fixed_center_frequency(self),
-        )
-        self.add_capture_template(
-            Mode.SWEPT_CENTER_FREQUENCY,
-            get_capture_template_swept_center_frequency(self),
+        self.add_mode(
+            _Mode.FIXED_CENTER_FREQUENCY,
+            partial(capture, top_block_cls=fixed_center_frequency),
+            _make_capture_template_fixed_center_frequency(self),
+            _make_pvalidator_fixed_center_frequency(self),
         )
 
-    def _add_pvalidators(self) -> None:
-        self.add_pvalidator(
-            Mode.FIXED_CENTER_FREQUENCY, get_pvalidator_fixed_center_frequency(self)
-        )
-        self.add_pvalidator(
-            Mode.SWEPT_CENTER_FREQUENCY, get_pvalidator_swept_center_frequency(self)
+        self.add_mode(
+            _Mode.SWEPT_CENTER_FREQUENCY,
+            partial(capture, top_block_cls=swept_center_frequency),
+            _make_capture_template_swept_center_frequency(self),
+            _make_pvalidator_swept_center_frequency(self),
         )

spectre_core/receivers/plugins/{gr/_usrp.py → _b200mini_gr.py}

@@ -1,25 +1,19 @@
-#
-# USRP top blocks
-#
+# SPDX-FileCopyrightText: © 2024-2025 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
 
-from functools import partial
-from dataclasses import dataclass
 import time
 
-from logging import getLogger
-
-_LOGGER = getLogger(__name__)
+from gnuradio import spectre
+from gnuradio import uhd
 
 from spectre_core.capture_configs import Parameters, PName
 from spectre_core.config import get_batches_dir_path
-from ._base import capture, spectre_top_block
+from ._gr import spectre_top_block
 
 
-class _fixed_center_frequency(spectre_top_block):
+class fixed_center_frequency(spectre_top_block):
     def flowgraph(self, tag: str, parameters: Parameters) -> None:
-        # OOT moudle inline imports
-        from gnuradio import spectre
-        from gnuradio import uhd
 
         # Unpack capture config parameters
         sample_rate = parameters.get_parameter_value(PName.SAMPLE_RATE)
@@ -32,7 +26,7 @@ class _fixed_center_frequency(spectre_top_block):
 
         # Blocks
         master_clock_rate = f"master_clock_rate={master_clock_rate}"
-        self.uhd_usrp_source_0 = uhd.usrp_source(
+        self.uhd_usrp_sourcespecs.get = uhd.usrp_source(
             ",".join(("", "", master_clock_rate)),
             uhd.stream_args(
                 cpu_format="fc32",
@@ -41,30 +35,26 @@ class _fixed_center_frequency(spectre_top_block):
                 channels=[0],
             ),
         )
-        self.uhd_usrp_source_0.set_samp_rate(sample_rate)
-        self.uhd_usrp_source_0.set_time_now(uhd.time_spec(time.time()), uhd.ALL_MBOARDS)
-
-        self.uhd_usrp_source_0.set_center_freq(center_freq, 0)
-        self.uhd_usrp_source_0.set_antenna("RX2", 0)
-        self.uhd_usrp_source_0.set_bandwidth(bandwidth, 0)
-        self.uhd_usrp_source_0.set_rx_agc(False, 0)
-        self.uhd_usrp_source_0.set_auto_dc_offset(False, 0)
-        self.uhd_usrp_source_0.set_auto_iq_balance(False, 0)
-        self.uhd_usrp_source_0.set_gain(gain, 0)
-        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(
+        self.uhd_usrp_source.set_samp_rate(sample_rate)
+        self.uhd_usrp_source.set_time_now(uhd.time_spec(time.time()), uhd.ALL_MBOARDS)
+
+        self.uhd_usrp_source.set_center_freq(center_freq, 0)
+        self.uhd_usrp_source.set_antenna("RX2", 0)
+        self.uhd_usrp_source.set_bandwidth(bandwidth, 0)
+        self.uhd_usrp_source.set_rx_agc(False, 0)
+        self.uhd_usrp_source.set_auto_dc_offset(False, 0)
+        self.uhd_usrp_source.set_auto_iq_balance(False, 0)
+        self.uhd_usrp_source.set_gain(gain, 0)
+        self.spectre_batched_file_sink = spectre.batched_file_sink(
             get_batches_dir_path(), tag, batch_size, sample_rate, False, "rx_freq", 0
         )
 
         # Connections
-        self.connect((self.uhd_usrp_source_0, 0), (self.spectre_batched_file_sink_0, 0))
+        self.connect((self.uhd_usrp_source, 0), (self.spectre_batched_file_sink, 0))
 
 
-class _swept_center_frequency(spectre_top_block):
+class swept_center_frequency(spectre_top_block):
     def flowgraph(self, tag: str, parameters: Parameters) -> None:
-        # OOT module inline imports
-        from gnuradio import spectre
-        from gnuradio import uhd
-
         # Unpack capture config parameters
         sample_rate = parameters.get_parameter_value(PName.SAMPLE_RATE)
         bandwidth = parameters.get_parameter_value(PName.BANDWIDTH)
@@ -80,13 +70,8 @@ class _swept_center_frequency(spectre_top_block):
         gain = parameters.get_parameter_value(PName.GAIN)
         batch_size = parameters.get_parameter_value(PName.BATCH_SIZE)
 
-        # Blocks
-        _LOGGER.warning(
-            f"USRP frequency sweep modes will not work as expected until a known bug is fixed in the USRP source block. "
-            f"Please refer to this GitHub issue for more information: https://github.com/gnuradio/gnuradio/issues/7725"
-        )
         master_clock_rate = f"master_clock_rate={master_clock_rate}"
-        self.uhd_usrp_source_0 = uhd.usrp_source(
+        self.uhd_usrp_source = uhd.usrp_source(
             ",".join(("", "", master_clock_rate)),
             uhd.stream_args(
                 cpu_format="fc32",
@@ -95,17 +80,17 @@ class _swept_center_frequency(spectre_top_block):
                 channels=[0],
             ),
         )
-        self.uhd_usrp_source_0.set_samp_rate(sample_rate)
-        self.uhd_usrp_source_0.set_time_now(uhd.time_spec(time.time()), uhd.ALL_MBOARDS)
-        self.uhd_usrp_source_0.set_center_freq(min_frequency, 0)
-        self.uhd_usrp_source_0.set_antenna("RX2", 0)
-        self.uhd_usrp_source_0.set_bandwidth(bandwidth, 0)
-        self.uhd_usrp_source_0.set_rx_agc(False, 0)
-        self.uhd_usrp_source_0.set_auto_dc_offset(False, 0)
-        self.uhd_usrp_source_0.set_auto_iq_balance(False, 0)
-        self.uhd_usrp_source_0.set_gain(gain, 0)
-
-        self.spectre_sweep_driver_0 = spectre.sweep_driver(
+        self.uhd_usrp_source.set_samp_rate(sample_rate)
+        self.uhd_usrp_source.set_time_now(uhd.time_spec(time.time()), uhd.ALL_MBOARDS)
+        self.uhd_usrp_source.set_center_freq(min_frequency, 0)
+        self.uhd_usrp_source.set_antenna("RX2", 0)
+        self.uhd_usrp_source.set_bandwidth(bandwidth, 0)
+        self.uhd_usrp_source.set_rx_agc(False, 0)
+        self.uhd_usrp_source.set_auto_dc_offset(False, 0)
+        self.uhd_usrp_source.set_auto_iq_balance(False, 0)
+        self.uhd_usrp_source.set_gain(gain, 0)
+
+        self.spectre_sweep_driver = spectre.sweep_driver(
             min_frequency,
             max_frequency,
             frequency_step,
@@ -114,7 +99,7 @@ class _swept_center_frequency(spectre_top_block):
             "freq",
         )
 
-        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(
+        self.spectre_batched_file_sink = spectre.batched_file_sink(
             get_batches_dir_path(),
             tag,
             batch_size,
@@ -126,16 +111,8 @@ class _swept_center_frequency(spectre_top_block):
 
         # Connections
         self.msg_connect(
-            (self.spectre_sweep_driver_0, "retune_command"),
-            (self.uhd_usrp_source_0, "command"),
+            (self.spectre_sweep_driver, "retune_command"),
+            (self.uhd_usrp_source, "command"),
         )
-        self.connect((self.uhd_usrp_source_0, 0), (self.spectre_batched_file_sink_0, 0))
-        self.connect((self.uhd_usrp_source_0, 0), (self.spectre_sweep_driver_0, 0))
-
-
-@dataclass(frozen=True)
-class CaptureMethod:
-    fixed_center_frequency = partial(capture, top_block_cls=_fixed_center_frequency)
-    swept_center_frequency = partial(
-        capture, top_block_cls=_swept_center_frequency, max_noutput_items=1024
-    )
+        self.connect((self.uhd_usrp_source, 0), (self.spectre_batched_file_sink, 0))
+        self.connect((self.uhd_usrp_source, 0), (self.spectre_sweep_driver, 0))

spectre_core/receivers/plugins/_custom.py

@@ -0,0 +1,20 @@
+# SPDX-FileCopyrightText: © 2024-2025 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from typing import Optional
+
+from ._receiver_names import ReceiverName
+from .._register import register_receiver
+from .._receiver import Receiver
+
+
+@register_receiver(ReceiverName.CUSTOM)
+class CustomReceiver(Receiver):
+    """A receiver which starts with no operating modes.
+
+    Customise by adding modes using the `add_mode` method.
+    """
+
+    def __init__(self, name: ReceiverName, mode: Optional[str] = None) -> None:
+        super().__init__(name, mode)

spectre_core/receivers/plugins/{gr/_base.py → _gr.py}

@@ -4,7 +4,7 @@
 
 import sys
 import signal
-from typing import Type, TypeVar
+from typing import Type
 
 from gnuradio import gr
 

spectre_core/receivers/plugins/_receiver_names.py

@@ -6,15 +6,17 @@ from enum import Enum
 
 
 class ReceiverName(Enum):
-    """A `spectre` supported receiver.
+    """The name of a supported receiver.
 
     :ivar RSP1A: SDRPlay RSP1A
     :ivar RSPDUO: SDRPlay RSPduo
-    :ivar TEST: `spectre` test receiver.
+    :ivar SIGNAL_GENERATOR: A synthetic signal generator.
     :ivar B200MINI: USRP B200mini.
+    :ivar CUSTOM: A custom receiver, which starts with no operating modes.
     """
 
+    SIGNAL_GENERATOR = "signal_generator"
     RSP1A = "rsp1a"
     RSPDUO = "rspduo"
-    TEST = "test"
     B200MINI = "b200mini"
+    CUSTOM = "custom"

spectre_core/receivers/plugins/_rsp1a.py

@@ -3,22 +3,25 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 from dataclasses import dataclass
+from typing import Optional
+from functools import partial
 
 from ._receiver_names import ReceiverName
-from .gr._rsp1a import CaptureMethod
 from ._sdrplay_receiver import (
-    get_pvalidator_fixed_center_frequency,
-    get_pvalidator_swept_center_frequency,
-    get_capture_template_fixed_center_frequency,
-    get_capture_template_swept_center_frequency,
+    SDRplayReceiver,
+    make_capture_template_fixed_center_frequency,
+    make_capture_template_swept_center_frequency,
+    make_pvalidator_fixed_center_frequency,
+    make_pvalidator_swept_center_frequency,
 )
-from .._spec_names import SpecName
-from .._base import BaseReceiver
+from ._rsp1a_gr import swept_center_frequency, fixed_center_frequency
+from ._receiver_names import ReceiverName
+from ._gr import capture
 from .._register import register_receiver
 
 
 @dataclass(frozen=True)
-class Mode:
+class _Mode:
     """An operating mode for the `RSP1A` receiver."""
 
     FIXED_CENTER_FREQUENCY = "fixed_center_frequency"
@@ -26,44 +29,36 @@ class Mode:
 
 
 @register_receiver(ReceiverName.RSP1A)
-class RSP1A(BaseReceiver):
+class RSP1A(SDRplayReceiver):
     """Receiver implementation for the SDRPlay RSP1A (https://www.sdrplay.com/rsp1a/)"""
 
-    def _add_specs(self) -> None:
-        self.add_spec(SpecName.SAMPLE_RATE_LOWER_BOUND, 200e3)
-        self.add_spec(SpecName.SAMPLE_RATE_UPPER_BOUND, 10e6)
-        self.add_spec(SpecName.FREQUENCY_LOWER_BOUND, 1e3)
-        self.add_spec(SpecName.FREQUENCY_UPPER_BOUND, 2e9)
-        self.add_spec(SpecName.IF_GAIN_UPPER_BOUND, -20)
-        self.add_spec(SpecName.RF_GAIN_UPPER_BOUND, 0)
-        self.add_spec(SpecName.API_RETUNING_LATENCY, 25 * 1e-3)
-        self.add_spec(
-            SpecName.BANDWIDTH_OPTIONS,
-            [200000, 300000, 600000, 1536000, 5000000, 6000000, 7000000, 8000000],
-        )
+    def __init__(self, name: ReceiverName, mode: Optional[str] = None) -> None:
+        """Initialise an instance of an `RSP1A`."""
+        super().__init__(name, mode)
 
-    def _add_capture_methods(self) -> None:
-        self.add_capture_method(
-            Mode.FIXED_CENTER_FREQUENCY, CaptureMethod.fixed_center_frequency
+        self.add_mode(
+            _Mode.FIXED_CENTER_FREQUENCY,
+            partial(capture, top_block_cls=fixed_center_frequency),
+            make_capture_template_fixed_center_frequency(self),
+            make_pvalidator_fixed_center_frequency(self),
         )
-        self.add_capture_method(
-            Mode.SWEPT_CENTER_FREQUENCY, CaptureMethod.swept_center_frequency
+        self.add_mode(
+            _Mode.SWEPT_CENTER_FREQUENCY,
+            partial(
+                capture, top_block_cls=swept_center_frequency, max_noutput_items=1024
+            ),
+            make_capture_template_swept_center_frequency(self),
+            make_pvalidator_swept_center_frequency(self),
         )
 
-    def _add_capture_templates(self) -> None:
-        self.add_capture_template(
-            Mode.FIXED_CENTER_FREQUENCY,
-            get_capture_template_fixed_center_frequency(self),
-        )
-        self.add_capture_template(
-            Mode.SWEPT_CENTER_FREQUENCY,
-            get_capture_template_swept_center_frequency(self),
-        )
-
-    def _add_pvalidators(self) -> None:
-        self.add_pvalidator(
-            Mode.FIXED_CENTER_FREQUENCY, get_pvalidator_fixed_center_frequency(self)
-        )
-        self.add_pvalidator(
-            Mode.SWEPT_CENTER_FREQUENCY, get_pvalidator_swept_center_frequency(self)
-        )
+    def get_rf_gains(self, center_frequency: float) -> list[int]:
+        if center_frequency <= 60e6:
+            return [0, -6, -12, -18, -37, -42, -61]
+        elif center_frequency <= 420e6:
+            return [0, -6, -12, -18, -20, -26, -32, -38, -57, -62]
+        elif center_frequency <= 1e9:
+            return [0, -7, -13, -19, -20, -27, -33, -39, -45, -64]
+        elif center_frequency <= 2e9:
+            return [0, -6, -12, -20, -26, -32, -38, -43, -62]
+        else:
+            return []