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

spectre_core/receivers/plugins/_sdrplay_receiver.py

@@ -2,7 +2,11 @@
 # This file is part of SPECTRE
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-from typing import Callable, overload
+from abc import ABC, abstractmethod
+from typing import Callable, cast, Optional
+from logging import getLogger
+
+_LOGGER = getLogger(__name__)
 
 from spectre_core.capture_configs import (
     CaptureTemplate,
@@ -10,38 +14,136 @@ from spectre_core.capture_configs import (
     Parameters,
     Bound,
     PName,
+    OneOf,
     get_base_capture_template,
     get_base_ptemplate,
-    OneOf,
     validate_fixed_center_frequency,
     validate_swept_center_frequency,
 )
-from .._base import BaseReceiver
-from .._spec_names import SpecName
 
+from .._receiver import Receiver, ReceiverName
+from .._specs import SpecName
+
+LOW_IF_SAMPLE_RATE_CUTOFF = 2e6
+LOW_IF_PERMITTED_SAMPLE_RATES = [LOW_IF_SAMPLE_RATE_CUTOFF / (2**i) for i in range(6)]
+
+
+class SDRplayReceiver(ABC, Receiver):
+    """An abstract base class for SDRplay devices."""
+
+    def __init__(self, name: ReceiverName, mode: Optional[str]):
+        """Initialise an instance of an `SDRplayReceiver`."""
+        super().__init__(name, mode)
+
+        self.add_spec(SpecName.SAMPLE_RATE_LOWER_BOUND, 62.5e3)
+        self.add_spec(SpecName.SAMPLE_RATE_UPPER_BOUND, 10.66e6)
+        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.IF_GAIN_LOWER_BOUND, -59)
+        self.add_spec(SpecName.API_RETUNING_LATENCY, 25 * 1e-3)
+
+        # bandwidth == 0 means 'AUTO', i.e. the largest bandwidth compatible with the sample rate
+        self.add_spec(
+            SpecName.BANDWIDTH_OPTIONS,
+            [0, 200e3, 300e3, 600e3, 1.536e6, 5e6, 6e6, 7e6, 8e6],
+        )
+
+    @abstractmethod
+    def get_rf_gains(self, center_frequency: float) -> list[int]:
+        """Get an ordered list of RF gain values corresponding to each LNA state at the specified center frequency.
+
+        The values are taken from the gain reduction tables documented in the SDRplay API specification, and are
+        unique to each model. Note that negative gain values represent positive gain reduction.
+        """
+
+
+def _validate_rf_gain(rf_gain: int, expected_rf_gains: list[int]):
+    """Validate the RF gain value against the expected values for the current LNA state.
+
+    The RF gain is determined by the LNA state and can only take specific values as documented in the
+    gain reduction tables of the SDRplay API specification.
+
+    For implementation details, refer to the `gr-sdrplay3` OOT module:
+    https://github.com/fventuri/gr-sdrplay3/blob/v3.11.0.9/lib/rsp_impl.cc#L378-L387
+    """
+    if rf_gain not in expected_rf_gains:
+        raise ValueError(
+            f"The value of RF gain must be one of {expected_rf_gains}. "
+            f"Got {rf_gain}."
+        )
+
+
+def _validate_low_if_sample_rate(sample_rate: int) -> None:
+    """Validate the sample rate if the receiver is operating in low IF mode.
+
+    The minimum physical sampling rate of the SDRplay hardware is 2 MHz. Lower effective rates can be achieved
+    through decimation, as handled by the `gr-sdrplay3` OOT module. This function ensures that the sample rate
+    is not silently adjusted by the backend.
+
+    For implementation details, refer to:
+    https://github.com/fventuri/gr-sdrplay3/blob/v3.11.0.9/lib/rsp_impl.cc#L140-L179
+    """
+    if sample_rate <= LOW_IF_SAMPLE_RATE_CUTOFF:
+        if sample_rate not in LOW_IF_PERMITTED_SAMPLE_RATES:
+            raise ValueError(
+                f"If the requested sample rate is less than or equal to {LOW_IF_SAMPLE_RATE_CUTOFF}, "
+                f"the receiver will be operating in low IF mode. "
+                f"So, the sample rate must be exactly one of {LOW_IF_PERMITTED_SAMPLE_RATES}. "
+                f"Got sample rate {sample_rate} Hz"
+            )
 
-def get_pvalidator_fixed_center_frequency(
-    sdrplay_receiver: BaseReceiver,
+
+def make_pvalidator_fixed_center_frequency(
+    receiver: SDRplayReceiver,
 ) -> Callable[[Parameters], None]:
     def pvalidator(parameters: Parameters) -> None:
         validate_fixed_center_frequency(parameters)
 
+        # Validate the sample rate, in the case the receiver will be operating in low if mode.
+        sample_rate = cast(int, parameters.get_parameter_value(PName.SAMPLE_RATE))
+        _validate_low_if_sample_rate(sample_rate)
+
+        # Validate the rf gain value, which is a function of center frequency.
+        rf_gain = cast(int, parameters.get_parameter_value(PName.RF_GAIN))
+        center_frequency = cast(
+            float, parameters.get_parameter_value(PName.CENTER_FREQUENCY)
+        )
+        _validate_rf_gain(rf_gain, receiver.get_rf_gains(center_frequency))
+
     return pvalidator
 
 
-def get_pvalidator_swept_center_frequency(
-    sdrplay_receiver: BaseReceiver,
+def make_pvalidator_swept_center_frequency(
+    receiver: SDRplayReceiver,
 ) -> Callable[[Parameters], None]:
     def pvalidator(parameters: Parameters) -> None:
         validate_swept_center_frequency(
-            parameters, sdrplay_receiver.get_spec(SpecName.API_RETUNING_LATENCY)
+            parameters, receiver.get_spec(SpecName.API_RETUNING_LATENCY)
         )
 
+        # Validate the sample rate, in the case the receiver will be operating in low if mode.
+        sample_rate = cast(int, parameters.get_parameter_value(PName.SAMPLE_RATE))
+        _validate_low_if_sample_rate(sample_rate)
+
+        # Validate the rf gain value, which is a function of center frequency.
+        rf_gain = cast(int, parameters.get_parameter_value(PName.RF_GAIN))
+        min_frequency = cast(float, parameters.get_parameter_value(PName.MIN_FREQUENCY))
+        max_frequency = cast(float, parameters.get_parameter_value(PName.MAX_FREQUENCY))
+        _validate_rf_gain(rf_gain, receiver.get_rf_gains(min_frequency))
+        _validate_rf_gain(rf_gain, receiver.get_rf_gains(max_frequency))
+
+        # Check that we are not cross a threshold where the LNA state has to change
+        if receiver.get_rf_gains(min_frequency) != receiver.get_rf_gains(max_frequency):
+            _LOGGER.warning(
+                "Crossing a threshold where the LNA state has to change. Performance may be reduced."
+            )
+
     return pvalidator
 
 
-def get_capture_template_fixed_center_frequency(
-    sdrplay_receiver: BaseReceiver,
+def make_capture_template_fixed_center_frequency(
+    receiver: SDRplayReceiver,
 ) -> CaptureTemplate:
 
     capture_template = get_base_capture_template(CaptureMode.FIXED_CENTER_FREQUENCY)
@@ -52,12 +154,12 @@ def get_capture_template_fixed_center_frequency(
     capture_template.set_defaults(
         (PName.BATCH_SIZE, 3.0),
         (PName.CENTER_FREQUENCY, 95800000),
-        (PName.SAMPLE_RATE, 600000),
-        (PName.BANDWIDTH, 600000),
+        (PName.SAMPLE_RATE, 500000),
+        (PName.BANDWIDTH, 300000),
         (PName.WINDOW_HOP, 512),
         (PName.WINDOW_SIZE, 1024),
         (PName.WINDOW_TYPE, "blackman"),
-        (PName.RF_GAIN, -30),
+        (PName.RF_GAIN, 0),
         (PName.IF_GAIN, -30),
     )
 
@@ -65,8 +167,8 @@ def get_capture_template_fixed_center_frequency(
         PName.CENTER_FREQUENCY,
         [
             Bound(
-                lower_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
-                upper_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND),
+                lower_bound=receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
+                upper_bound=receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND),
             )
         ],
     )
@@ -74,27 +176,28 @@ def get_capture_template_fixed_center_frequency(
         PName.SAMPLE_RATE,
         [
             Bound(
-                lower_bound=sdrplay_receiver.get_spec(SpecName.SAMPLE_RATE_LOWER_BOUND),
-                upper_bound=sdrplay_receiver.get_spec(SpecName.SAMPLE_RATE_UPPER_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, [OneOf(sdrplay_receiver.get_spec(SpecName.BANDWIDTH_OPTIONS))]
+        PName.BANDWIDTH, [OneOf(receiver.get_spec(SpecName.BANDWIDTH_OPTIONS))]
     )
     capture_template.add_pconstraint(
         PName.IF_GAIN,
-        [Bound(upper_bound=sdrplay_receiver.get_spec(SpecName.IF_GAIN_UPPER_BOUND))],
-    )
-    capture_template.add_pconstraint(
-        PName.RF_GAIN,
-        [Bound(upper_bound=sdrplay_receiver.get_spec(SpecName.RF_GAIN_UPPER_BOUND))],
+        [
+            Bound(
+                lower_bound=receiver.get_spec(SpecName.IF_GAIN_LOWER_BOUND),
+                upper_bound=receiver.get_spec(SpecName.IF_GAIN_UPPER_BOUND),
+            )
+        ],
     )
     return capture_template
 
 
-def get_capture_template_swept_center_frequency(
-    sdrplay_receiver: BaseReceiver,
+def make_capture_template_swept_center_frequency(
+    receiver: Receiver,
 ) -> CaptureTemplate:
 
     capture_template = get_base_capture_template(CaptureMode.SWEPT_CENTER_FREQUENCY)
@@ -103,17 +206,17 @@ def get_capture_template_swept_center_frequency(
     capture_template.add_ptemplate(get_base_ptemplate(PName.RF_GAIN))
 
     capture_template.set_defaults(
-        (PName.BATCH_SIZE, 4.0),
+        (PName.BATCH_SIZE, 3.0),
         (PName.MIN_FREQUENCY, 95000000),
         (PName.MAX_FREQUENCY, 100000000),
         (PName.SAMPLES_PER_STEP, 80000),
-        (PName.FREQUENCY_STEP, 1536000),
-        (PName.SAMPLE_RATE, 1536000),
+        (PName.FREQUENCY_STEP, 2000000),
+        (PName.SAMPLE_RATE, 2e6),
         (PName.BANDWIDTH, 1536000),
         (PName.WINDOW_HOP, 512),
         (PName.WINDOW_SIZE, 1024),
         (PName.WINDOW_TYPE, "blackman"),
-        (PName.RF_GAIN, -30),
+        (PName.RF_GAIN, 0),
         (PName.IF_GAIN, -30),
     )
 
@@ -121,8 +224,8 @@ def get_capture_template_swept_center_frequency(
         PName.MIN_FREQUENCY,
         [
             Bound(
-                lower_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
-                upper_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND),
+                lower_bound=receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
+                upper_bound=receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND),
             )
         ],
     )
@@ -130,8 +233,8 @@ def get_capture_template_swept_center_frequency(
         PName.MAX_FREQUENCY,
         [
             Bound(
-                lower_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
-                upper_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND),
+                lower_bound=receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
+                upper_bound=receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND),
             )
         ],
     )
@@ -139,20 +242,21 @@ def get_capture_template_swept_center_frequency(
         PName.SAMPLE_RATE,
         [
             Bound(
-                lower_bound=sdrplay_receiver.get_spec(SpecName.SAMPLE_RATE_LOWER_BOUND),
-                upper_bound=sdrplay_receiver.get_spec(SpecName.SAMPLE_RATE_UPPER_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, [OneOf(sdrplay_receiver.get_spec(SpecName.BANDWIDTH_OPTIONS))]
+        PName.BANDWIDTH, [OneOf(receiver.get_spec(SpecName.BANDWIDTH_OPTIONS))]
     )
     capture_template.add_pconstraint(
         PName.IF_GAIN,
-        [Bound(upper_bound=sdrplay_receiver.get_spec(SpecName.IF_GAIN_UPPER_BOUND))],
-    )
-    capture_template.add_pconstraint(
-        PName.RF_GAIN,
-        [Bound(upper_bound=sdrplay_receiver.get_spec(SpecName.RF_GAIN_UPPER_BOUND))],
+        [
+            Bound(
+                lower_bound=receiver.get_spec(SpecName.IF_GAIN_LOWER_BOUND),
+                upper_bound=receiver.get_spec(SpecName.IF_GAIN_UPPER_BOUND),
+            )
+        ],
     )
     return capture_template

spectre_core/receivers/plugins/_signal_generator.py

@@ -0,0 +1,225 @@
+# SPDX-FileCopyrightText: © 2024-2025 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from dataclasses import dataclass
+from typing import Callable, Optional, cast
+from functools import partial
+
+from spectre_core.capture_configs import (
+    CaptureTemplate,
+    CaptureMode,
+    Parameters,
+    Bound,
+    PName,
+    get_base_capture_template,
+    make_base_capture_template,
+    get_base_ptemplate,
+    validate_window,
+)
+from ._signal_generator_gr import cosine_wave, constant_staircase
+from ._gr import capture
+from ._receiver_names import ReceiverName
+from .._receiver import Receiver
+from .._specs import SpecName
+from .._register import register_receiver
+
+
+def _make_capture_template_cos_wave(receiver: Receiver) -> CaptureTemplate:
+    capture_template = get_base_capture_template(CaptureMode.FIXED_CENTER_FREQUENCY)
+    capture_template.add_ptemplate(get_base_ptemplate(PName.AMPLITUDE))
+    capture_template.add_ptemplate(get_base_ptemplate(PName.FREQUENCY))
+
+    capture_template.set_defaults(
+        (PName.BATCH_SIZE, 3.0),
+        (PName.CENTER_FREQUENCY, 16000),
+        (PName.AMPLITUDE, 2.0),
+        (PName.FREQUENCY, 32000),
+        (PName.SAMPLE_RATE, 128000),
+        (PName.WINDOW_HOP, 512),
+        (PName.WINDOW_SIZE, 512),
+        (PName.WINDOW_TYPE, "boxcar"),
+    )
+
+    capture_template.enforce_defaults(
+        PName.TIME_RESOLUTION,
+        PName.TIME_RANGE,
+        PName.FREQUENCY_RESOLUTION,
+        PName.WINDOW_TYPE,
+    )
+
+    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.FREQUENCY,
+        [
+            Bound(
+                lower_bound=receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
+                upper_bound=receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND),
+            )
+        ],
+    )
+    return capture_template
+
+
+def _make_capture_template_constant_staircase(receiver: Receiver) -> CaptureTemplate:
+    capture_template = make_base_capture_template(
+        PName.TIME_RESOLUTION,
+        PName.FREQUENCY_RESOLUTION,
+        PName.TIME_RANGE,
+        PName.SAMPLE_RATE,
+        PName.BATCH_SIZE,
+        PName.WINDOW_TYPE,
+        PName.WINDOW_HOP,
+        PName.WINDOW_SIZE,
+        PName.EVENT_HANDLER_KEY,
+        PName.BATCH_KEY,
+        PName.WATCH_EXTENSION,
+        PName.MIN_SAMPLES_PER_STEP,
+        PName.MAX_SAMPLES_PER_STEP,
+        PName.FREQUENCY_STEP,
+        PName.STEP_INCREMENT,
+        PName.OBS_ALT,
+        PName.OBS_LAT,
+        PName.OBS_LON,
+        PName.OBJECT,
+        PName.ORIGIN,
+        PName.TELESCOPE,
+        PName.INSTRUMENT,
+    )
+
+    capture_template.set_defaults(
+        (PName.BATCH_SIZE, 3.0),
+        (PName.FREQUENCY_STEP, 128000),
+        (PName.MAX_SAMPLES_PER_STEP, 5000),
+        (PName.MIN_SAMPLES_PER_STEP, 4000),
+        (PName.SAMPLE_RATE, 128000),
+        (PName.STEP_INCREMENT, 200),
+        (PName.WINDOW_HOP, 512),
+        (PName.WINDOW_SIZE, 512),
+        (PName.WINDOW_TYPE, "boxcar"),
+        (PName.EVENT_HANDLER_KEY, "swept_center_frequency"),
+        (PName.BATCH_KEY, "iq_stream"),
+        (PName.WATCH_EXTENSION, "bin"),
+    )
+
+    capture_template.enforce_defaults(
+        PName.TIME_RESOLUTION,
+        PName.TIME_RANGE,
+        PName.FREQUENCY_RESOLUTION,
+        PName.WINDOW_TYPE,
+        PName.EVENT_HANDLER_KEY,
+        PName.BATCH_KEY,
+        PName.WATCH_EXTENSION,
+    )
+
+    return capture_template
+
+
+def _make_pvalidator_cosine_wave(receiver: Receiver) -> Callable[[Parameters], None]:
+    def pvalidator(parameters: Parameters) -> None:
+        validate_window(parameters)
+
+        sample_rate = cast(int, parameters.get_parameter_value(PName.SAMPLE_RATE))
+        window_size = cast(int, parameters.get_parameter_value(PName.WINDOW_SIZE))
+        frequency = cast(float, parameters.get_parameter_value(PName.FREQUENCY))
+
+        # check that the sample rate is an integer multiple of the underlying signal frequency
+        if sample_rate % frequency != 0:
+            raise ValueError(
+                "The sampling rate must be some integer multiple of frequency"
+            )
+
+        a = sample_rate / frequency
+        if a < 2:
+            raise ValueError(
+                (
+                    f"The ratio of sampling rate over frequency must be greater than two. "
+                    f"Got {a}"
+                )
+            )
+
+        # analytical requirement
+        # if p is the number of sampled cycles, we can find that p = window_size / a
+        # the number of sampled cycles must be a positive natural number.
+        p = window_size / a
+        if window_size % a != 0:
+            raise ValueError(
+                (
+                    f"The number of sampled cycles must be a positive natural number. "
+                    f"Computed that p={p}"
+                )
+            )
+
+    return pvalidator
+
+
+def _make_pvalidator_constant_staircase(
+    receiver: Receiver,
+) -> Callable[[Parameters], None]:
+    def pvalidator(parameters: Parameters) -> None:
+        validate_window(parameters)
+
+        freq_step = cast(float, parameters.get_parameter_value(PName.FREQUENCY_STEP))
+        sample_rate = cast(int, parameters.get_parameter_value(PName.SAMPLE_RATE))
+        min_samples_per_step = cast(
+            int, parameters.get_parameter_value(PName.MIN_SAMPLES_PER_STEP)
+        )
+        max_samples_per_step = cast(
+            int, parameters.get_parameter_value(PName.MAX_SAMPLES_PER_STEP)
+        )
+
+        if freq_step != sample_rate:
+            raise ValueError(f"The frequency step must be equal to the sampling rate")
+
+        if min_samples_per_step > max_samples_per_step:
+            raise ValueError(
+                (
+                    f"Minimum samples per step cannot be greater than the maximum samples per step. "
+                    f"Got {min_samples_per_step}, which is greater than {max_samples_per_step}"
+                )
+            )
+
+    return pvalidator
+
+
+@dataclass(frozen=True)
+class _Mode:
+    """An operating mode for the `SignalGenerator` receiver."""
+
+    COSINE_WAVE = "cosine_wave"
+    CONSTANT_STAIRCASE = "constant_staircase"
+
+
+@register_receiver(ReceiverName.SIGNAL_GENERATOR)
+class SignalGenerator(Receiver):
+    """An entirely software-defined receiver, which generates synthetic signals."""
+
+    def __init__(self, name: ReceiverName, mode: Optional[str] = None) -> None:
+        super().__init__(name, mode)
+
+        self.add_spec(SpecName.SAMPLE_RATE_LOWER_BOUND, 64000)
+        self.add_spec(SpecName.SAMPLE_RATE_UPPER_BOUND, 640000)
+        self.add_spec(SpecName.FREQUENCY_LOWER_BOUND, 16000)
+        self.add_spec(SpecName.FREQUENCY_UPPER_BOUND, 160000)
+
+        self.add_mode(
+            _Mode.COSINE_WAVE,
+            partial(capture, top_block_cls=cosine_wave),
+            _make_capture_template_cos_wave(self),
+            _make_pvalidator_cosine_wave(self),
+        )
+
+        self.add_mode(
+            _Mode.CONSTANT_STAIRCASE,
+            partial(capture, top_block_cls=constant_staircase),
+            _make_capture_template_constant_staircase(self),
+            _make_pvalidator_constant_staircase(self),
+        )

spectre_core/receivers/plugins/_signal_generator_gr.py

@@ -0,0 +1,77 @@
+# SPDX-FileCopyrightText: © 2024-2025 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from gnuradio import gr
+from gnuradio import blocks
+from gnuradio import analog
+from gnuradio import spectre
+
+from spectre_core.capture_configs import Parameters, PName
+from spectre_core.config import get_batches_dir_path
+from ._gr import spectre_top_block
+
+
+class cosine_wave(spectre_top_block):
+    def flowgraph(self, tag: str, parameters: Parameters) -> None:
+
+        # Unpack the capture config parameters
+        samp_rate = parameters.get_parameter_value(PName.SAMPLE_RATE)
+        batch_size = parameters.get_parameter_value(PName.BATCH_SIZE)
+        frequency = parameters.get_parameter_value(PName.FREQUENCY)
+        amplitude = parameters.get_parameter_value(PName.AMPLITUDE)
+
+        # Blocks
+        self.spectre_batched_file_sink = spectre.batched_file_sink(
+            get_batches_dir_path(), tag, batch_size, samp_rate
+        )
+        self.blocks_throttle_0 = blocks.throttle(gr.sizeof_float * 1, samp_rate, True)
+        self.blocks_throttle_1 = blocks.throttle(gr.sizeof_float * 1, samp_rate, True)
+        self.blocks_null_source = blocks.null_source(gr.sizeof_float * 1)
+        self.blocks_float_to_complex = blocks.float_to_complex(1)
+        self.analog_sig_source = analog.sig_source_f(
+            samp_rate, analog.GR_COS_WAVE, frequency, amplitude, 0, 0
+        )
+
+        # Connections
+        self.connect((self.analog_sig_source, 0), (self.blocks_throttle_0, 0))
+        self.connect((self.blocks_null_source, 0), (self.blocks_throttle_1, 0))
+        self.connect((self.blocks_throttle_0, 0), (self.blocks_float_to_complex, 0))
+        self.connect((self.blocks_throttle_1, 0), (self.blocks_float_to_complex, 1))
+        self.connect(
+            (self.blocks_float_to_complex, 0), (self.spectre_batched_file_sink, 0)
+        )
+
+
+class constant_staircase(spectre_top_block):
+    def flowgraph(self, tag: str, parameters: Parameters) -> None:
+        # Unpack the capture config parameters
+        step_increment = parameters.get_parameter_value(PName.STEP_INCREMENT)
+        samp_rate = parameters.get_parameter_value(PName.SAMPLE_RATE)
+        min_samples_per_step = parameters.get_parameter_value(
+            PName.MIN_SAMPLES_PER_STEP
+        )
+        max_samples_per_step = parameters.get_parameter_value(
+            PName.MAX_SAMPLES_PER_STEP
+        )
+        frequency_step = parameters.get_parameter_value(PName.FREQUENCY_STEP)
+        batch_size = parameters.get_parameter_value(PName.BATCH_SIZE)
+
+        # Blocks
+        self.spectre_constant_staircase = spectre.tagged_staircase(
+            min_samples_per_step,
+            max_samples_per_step,
+            frequency_step,
+            step_increment,
+            samp_rate,
+        )
+        self.spectre_batched_file_sink = spectre.batched_file_sink(
+            get_batches_dir_path(), tag, batch_size, samp_rate, True, "rx_freq", 0
+        )  # zero means the center frequency is unset
+        self.blocks_throttle = blocks.throttle(
+            gr.sizeof_gr_complex * 1, samp_rate, True
+        )
+
+        # Connections
+        self.connect((self.spectre_constant_staircase, 0), (self.blocks_throttle, 0))
+        self.connect((self.blocks_throttle, 0), (self.spectre_batched_file_sink, 0))