spectre-core 0.0.14__tar.gz → 0.0.16__tar.gz

{spectre_core-0.0.14 → spectre_core-0.0.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: spectre-core
-Version: 0.0.14
+Version: 0.0.16
 Summary: The core Python package used by the spectre program. 
 Maintainer-email: Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{spectre_core-0.0.14 → spectre_core-0.0.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spectre-core"
-version = "0.0.14"
+version = "0.0.16"
 maintainers = [
   { name="Jimmy Fitzpatrick", email="jcfitzpatrick12@gmail.com" },
 ]

{spectre_core-0.0.14 → spectre_core-0.0.16}/src/spectre_core/capture_configs/__init__.py

@@ -9,7 +9,7 @@ from ._capture_modes import CaptureMode
 from ._pvalidators  import (
     validate_fixed_center_frequency, validate_non_overlapping_steps, validate_num_samples_per_step,
     validate_num_steps_per_sweep, validate_nyquist_criterion, validate_step_interval, validate_sweep_interval,
-    validate_swept_center_frequency, validate_window
+    validate_swept_center_frequency, validate_window, validate_sample_rate_with_master_clock_rate
 )
 from ._capture_config import CaptureConfig
 from ._ptemplates import PTemplate, get_base_ptemplate
@@ -29,5 +29,5 @@ __all__ = [
     "PConstraint", "PConstraint", "Bound", "OneOf", "EnforceSign", "PowerOfTwo", "make_base_capture_template", "PName",
     "get_base_ptemplate", "BasePConstraint", "validate_fixed_center_frequency", "validate_non_overlapping_steps",
     "validate_num_samples_per_step", "validate_num_steps_per_sweep", "validate_nyquist_criterion", "validate_step_interval",
-    "validate_sweep_interval", "validate_swept_center_frequency", "validate_window"
-]
+    "validate_sweep_interval", "validate_swept_center_frequency", "validate_window", "validate_sample_rate_with_master_clock_rate"
+]

{spectre_core-0.0.14 → spectre_core-0.0.16}/src/spectre_core/capture_configs/_pnames.py

@@ -46,4 +46,7 @@ class PName(Enum):
     OBJECT               = "object"
     OBS_LAT              = "obs_lat"
     OBS_LON              = "obs_lon"
-    OBS_ALT              = "obs_alt"
+    OBS_ALT              = "obs_alt"
+    GAIN                 = "gain"
+    MASTER_CLOCK_RATE    = "master_clock_rate"
+    WIRE_FORMAT          = "wire_format"

{spectre_core-0.0.14 → spectre_core-0.0.16}/src/spectre_core/capture_configs/_ptemplates.py

@@ -7,7 +7,7 @@ from textwrap import dedent
 from copy import deepcopy
 
 from ._pnames import PName
-from ._pconstraints import BasePConstraint, EnforceSign, PowerOfTwo
+from ._pconstraints import BasePConstraint, EnforceSign, PowerOfTwo, Bound
 from ._parameters import Parameter
     
 # value type
@@ -300,6 +300,24 @@ _base_ptemplates: dict[PName, PTemplate] = {
                                             pconstraints=[
                                                 EnforceSign.non_positive
                                                 ]),
+    PName.GAIN:                   PTemplate(PName.GAIN,
+                                            float,
+                                            help = """
+                                                 The gain value for the SDR, in dB 
+                                                 """
+                                           ),
+    PName.MASTER_CLOCK_RATE:      PTemplate(PName.MASTER_CLOCK_RATE,
+                                            int,
+                                            help = """
+                                                 The primary reference clock for the SDR, specified in Hz. 
+                                                 """
+                                           ),
+    PName.WIRE_FORMAT:            PTemplate(PName.WIRE_FORMAT,
+                                            str,
+                                            help = """
+                                                 Controls the form of the data over the bus/network.
+                                                 """
+                                            ),
     PName.EVENT_HANDLER_KEY:      PTemplate(PName.EVENT_HANDLER_KEY,      
                                             str,
                                             help = """
@@ -490,4 +508,4 @@ def get_base_ptemplate(
     # A deep copy is required as each receiver instance may mutate the original instance
     # according to its particular use case. Copying preserves the original instance,
     # enabling reuse.
-    return deepcopy( _base_ptemplates[pname] )
+    return deepcopy( _base_ptemplates[pname] )

{spectre_core-0.0.14 → spectre_core-0.0.16}/src/spectre_core/capture_configs/_pvalidators.py

@@ -184,6 +184,22 @@ def validate_step_interval(
                          f"derived api latency {api_retuning_latency} [s]; you may experience undefined behaviour!")
 
 
+def validate_sample_rate_with_master_clock_rate(
+    parameters: Parameters,
+) -> None:
+    """Ensure that the master clock rate is an integer multiple of the sample rate.
+
+    :param parameters: The parameters to be validated.
+    :raises ValueError: If the master clock rate is not an integer multiple of the sample rate
+    """
+    master_clock_rate = cast(int, parameters.get_parameter_value(PName.MASTER_CLOCK_RATE))
+    sample_rate       = cast(int, parameters.get_parameter_value(PName.SAMPLE_RATE))
+
+    if master_clock_rate % sample_rate != 0:
+        raise ValueError(f"The master clock rate of {master_clock_rate} [Hz] is not an integer "
+                         f"multiple of the sample rate {sample_rate} [Hz].")
+
+
 def validate_fixed_center_frequency(
     parameters: Parameters
 ) -> None:

{spectre_core-0.0.14 → spectre_core-0.0.16}/src/spectre_core/receivers/__init__.py

@@ -8,6 +8,7 @@ from .plugins._receiver_names import ReceiverName
 from .plugins._test import Test
 from .plugins._rsp1a import RSP1A
 from .plugins._rspduo import RSPduo
+from .plugins._b200mini import B200mini
 
 from ._base import BaseReceiver
 from ._factory import get_receiver
@@ -15,6 +16,6 @@ from ._register import get_registered_receivers
 from ._spec_names import SpecName
 
 __all__ = [
-    "Test", "RSP1A", "RSPduo", "BaseReceiver", "get_receiver", 
+    "Test", "RSP1A", "RSPduo", "B200mini",  "BaseReceiver", "get_receiver", 
     "get_registered_receivers", "SpecName", "ReceiverName"
-]
+]

{spectre_core-0.0.14 → spectre_core-0.0.16}/src/spectre_core/receivers/_base.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 from abc import ABC, abstractmethod
-from typing import Callable, Optional, Literal, overload
+from typing import Callable, Optional, Literal, overload, Any
 
 from spectre_core.exceptions import ModeNotFoundError
 from spectre_core.capture_configs import (
@@ -226,7 +226,7 @@ class BaseReceiver(ABC):
     def add_spec(
         self,
         name: SpecName,
-        value: float|int|list[float|int]
+        value: Any 
     ) -> None:
         """
         Add a hardware specification.
@@ -236,34 +236,11 @@ class BaseReceiver(ABC):
         """
         self.specs[name] = value
 
-
-    # tell static type checkers the type of specification
-    @overload
-    def get_spec(self, spec_name: Literal[SpecName.API_RETUNING_LATENCY]) -> float: ...
-    @overload
-    def get_spec(self, spec_name: Literal[SpecName.FREQUENCY_LOWER_BOUND]) -> float: ...
-    @overload
-    def get_spec(self, spec_name: Literal[SpecName.FREQUENCY_UPPER_BOUND]) -> float: ...
-    @overload
-    def get_spec(self, spec_name: Literal[SpecName.SAMPLE_RATE_LOWER_BOUND]) -> int: ...
-    @overload
-    def get_spec(self, spec_name: Literal[SpecName.SAMPLE_RATE_UPPER_BOUND]) -> int: ...
-    @overload
-    def get_spec(self, spec_name: Literal[SpecName.BANDWIDTH_LOWER_BOUND]) -> float: ...
-    @overload
-    def get_spec(self, spec_name: Literal[SpecName.BANDWIDTH_UPPER_BOUND]) -> float: ...
-    @overload
-    def get_spec(self, spec_name: Literal[SpecName.RF_GAIN_UPPER_BOUND]) -> int: ...
-    @overload
-    def get_spec(self, spec_name: Literal[SpecName.IF_GAIN_UPPER_BOUND]) -> int: ...
-    @overload
-    def get_spec(self, spec_name: Literal[SpecName.BANDWIDTH_OPTIONS]) -> list[float]: ...
-    
     
     def get_spec(
         self, 
         spec_name: SpecName
-    ) -> float|int|list[float|int]:
+    ) -> Any:
         """
         Retrieve a hardware specification.
 
@@ -328,4 +305,4 @@ class BaseReceiver(ABC):
         parameters = self.capture_template.apply_template(capture_config.parameters)
         self.pvalidator(parameters)
         
-        return parameters
+        return parameters

{spectre_core-0.0.14 → spectre_core-0.0.16}/src/spectre_core/receivers/_factory.py

@@ -11,6 +11,7 @@ from .plugins._receiver_names import ReceiverName
 from .plugins._rsp1a import RSP1A
 from .plugins._rspduo import RSPduo
 from .plugins._test import Test
+from .plugins._b200mini import B200mini
 
 
 @overload
@@ -37,6 +38,14 @@ def get_receiver(
     ...
 
 
+@overload
+def get_receiver(
+    receiver_name: Literal[ReceiverName.B200MINI],
+    mode: Optional[str] = None
+) -> B200mini:
+    ...
+
+
 @overload
 def get_receiver(
     receiver_name: ReceiverName,

spectre_core-0.0.16/src/spectre_core/receivers/_spec_names.py

@@ -0,0 +1,41 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from enum import Enum
+
+class SpecName(Enum):
+    """A hardware specification name.
+    
+    :ivar FREQUENCY_LOWER_BOUND: The lower bound for the center frequency, in Hz.
+    :ivar FREQUENCY_UPPER_BOUND: The upper bound for the center frequency, in Hz.
+    :ivar SAMPLE_RATE_LOWER_BOUND: The lower bound for the sampling rate, in Hz.
+    :ivar SAMPLE_RATE_UPPER_BOUND: The upper bound for the sampling rate, in Hz.
+    :ivar BANDWIDTH_LOWER_BOUND: The lower bound for the bandwidth, in Hz.
+    :ivar BANDWIDTH_UPPER_BOUND: The upper bound for the bandwidth, in Hz.
+    :ivar BANDWIDTH_OPTIONS: The permitted bandwidths for the receiver, in Hz.
+    :ivar IF_GAIN_UPPER_BOUND: The upper bound for the intermediate frequency gain, in dB.
+    Negative values indicate attenuation.
+    :ivar RF_GAIN_UPPER_BOUND: The upper bound for the radio frequency gain, in dB. 
+    Negative values indicate attenuation.
+    :ivar GAIN_UPPER_BOUND: The upper bound for the gain, in dB.
+    :ivar WIRE_FORMATS: Supported data types transferred over the bus/network.
+    :ivar MASTER_CLOCK_RATE_LOWER_BOUND:  The lower bound for the SDR reference clock rate, in Hz.
+    :ivar MASTER_CLOCK_RATE_UPPER_BOUND:  The upper bound for the SDR reference clock rate, in Hz.
+    :ivar API_RETUNING_LATENCY: An empirical estimate of the delay between issuing a command
+    for a receiver to retune its center frequency and the actual physical update of the center frequency. 
+    """
+    FREQUENCY_LOWER_BOUND         = "frequency_lower_bound"
+    FREQUENCY_UPPER_BOUND         = "frequency_upper_bound"
+    SAMPLE_RATE_LOWER_BOUND       = "sample_rate_lower_bound"
+    SAMPLE_RATE_UPPER_BOUND       = "sample_rate_upper_bound"
+    BANDWIDTH_LOWER_BOUND         = "bandwidth_lower_bound"
+    BANDWIDTH_UPPER_BOUND         = "bandwidth_upper_bound"
+    BANDWIDTH_OPTIONS             = "bandwidth_options"
+    IF_GAIN_UPPER_BOUND           = "if_gain_upper_bound"
+    RF_GAIN_UPPER_BOUND           = "rf_gain_upper_bound"
+    GAIN_UPPER_BOUND              = "gain_upper_bound"
+    WIRE_FORMATS                  = "wire_formats"
+    MASTER_CLOCK_RATE_LOWER_BOUND = "master_clock_rate_lower_bound"
+    MASTER_CLOCK_RATE_UPPER_BOUND = "master_clock_rate_upper_bound"
+    API_RETUNING_LATENCY          = "api_retuning_latency"

spectre_core-0.0.16/src/spectre_core/receivers/plugins/_b200mini.py

@@ -0,0 +1,84 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from dataclasses import dataclass
+
+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 .gr._usrp import CaptureMethod
+from .._spec_names import SpecName
+from .._base import BaseReceiver
+from .._register import register_receiver 
+
+@dataclass(frozen=True)
+class Mode:
+    """An operating mode for the `B200mini` receiver."""
+    FIXED_CENTER_FREQUENCY = "fixed_center_frequency"
+    SWEPT_CENTER_FREQUENCY = "swept_center_frequency"
+
+
+@register_receiver(ReceiverName.B200MINI)
+class B200mini(BaseReceiver):
+    """Receiver implementation for the USRP B200mini (https://www.ettus.com/all-products/usrp-b200mini/)"""
+    def _add_specs(
+        self
+    ) -> None:
+        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  )
+        self.add_spec( SpecName.FREQUENCY_UPPER_BOUND        , 6e9   )
+        self.add_spec( SpecName.BANDWIDTH_LOWER_BOUND        , 200e3 ) 
+        self.add_spec( SpecName.BANDWIDTH_UPPER_BOUND        , 56e6  )
+        self.add_spec( SpecName.GAIN_UPPER_BOUND             , 76    )
+        self.add_spec( SpecName.WIRE_FORMATS                 , ["sc8", "sc12", "sc16"])
+        self.add_spec( SpecName.MASTER_CLOCK_RATE_LOWER_BOUND, 5e6)
+        self.add_spec( SpecName.MASTER_CLOCK_RATE_UPPER_BOUND, 61.44e6)
+        self.add_spec( 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))
+
+
+    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))
+
+    
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+

{spectre_core-0.0.14 → spectre_core-0.0.16}/src/spectre_core/receivers/plugins/_receiver_names.py

@@ -10,7 +10,9 @@ class ReceiverName(Enum):
     :ivar RSP1A: SDRPlay RSP1A
     :ivar RSPDUO: SDRPlay RSPduo
     :ivar TEST: `spectre` test receiver.
+    :ivar B200MINI: USRP B200mini.
     """
-    RSP1A  = "rsp1a"
-    RSPDUO = "rspduo"
-    TEST   = "test"
+    RSP1A     = "rsp1a"
+    RSPDUO    = "rspduo"
+    TEST      = "test"
+    B200MINI =  "b200mini"

{spectre_core-0.0.14 → spectre_core-0.0.16}/src/spectre_core/receivers/plugins/_rsp1a.py

@@ -6,8 +6,12 @@ from dataclasses import dataclass
 
 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
+)
 from .._spec_names import SpecName
-from ._sdrplay_receiver import SDRPlayReceiver
+from .._base import BaseReceiver
 from .._register import register_receiver
 
 @dataclass(frozen=True)
@@ -18,9 +22,11 @@ class Mode:
 
 
 @register_receiver(ReceiverName.RSP1A)
-class RSP1A(SDRPlayReceiver):
+class RSP1A(BaseReceiver):
     """Receiver implementation for the SDRPlay RSP1A (https://www.sdrplay.com/rsp1a/)"""
-    def _add_specs(self) -> None:
+    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       )
@@ -45,15 +51,15 @@ class RSP1A(SDRPlayReceiver):
         self
     ) -> None:
         self.add_capture_template(Mode.FIXED_CENTER_FREQUENCY,
-                                  self._get_capture_template_fixed_center_frequency())
+                                  get_capture_template_fixed_center_frequency(self))
         self.add_capture_template(Mode.SWEPT_CENTER_FREQUENCY,
-                                  self._get_capture_template_swept_center_frequency())
+                                  get_capture_template_swept_center_frequency(self))
         
     
     def _add_pvalidators(
         self
     ) -> None:
         self.add_pvalidator(Mode.FIXED_CENTER_FREQUENCY,
-                            self._get_pvalidator_fixed_center_frequency())
+                            get_pvalidator_fixed_center_frequency(self))
         self.add_pvalidator(Mode.SWEPT_CENTER_FREQUENCY,
-                            self._get_pvalidator_swept_center_frequency())
+                            get_pvalidator_swept_center_frequency(self))

{spectre_core-0.0.14 → spectre_core-0.0.16}/src/spectre_core/receivers/plugins/_rspduo.py

@@ -7,7 +7,11 @@ from dataclasses import dataclass
 from ._receiver_names import ReceiverName
 from .gr._rspduo import CaptureMethod
 from .._spec_names import SpecName
-from ._sdrplay_receiver import SDRPlayReceiver
+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
+)
+from .._base import BaseReceiver
 from .._register import register_receiver
 
 
@@ -20,7 +24,7 @@ class Mode:
 
 
 @register_receiver(ReceiverName.RSPDUO)
-class RSPduo(SDRPlayReceiver):
+class RSPduo(BaseReceiver):
     """Receiver implementation for the SDRPlay RSPduo (https://www.sdrplay.com/rspduo/)"""
     def _add_specs(self) -> None:
         self.add_spec( SpecName.SAMPLE_RATE_LOWER_BOUND, 200e3     )
@@ -49,19 +53,19 @@ class RSPduo(SDRPlayReceiver):
         self
     ) -> None:
         self.add_capture_template(Mode.TUNER_1_FIXED_CENTER_FREQUENCY,
-                                  self._get_capture_template_fixed_center_frequency())
+                                  get_capture_template_fixed_center_frequency(self))
         self.add_capture_template(Mode.TUNER_2_FIXED_CENTER_FREQUENCY,
-                                  self._get_capture_template_fixed_center_frequency())
+                                  get_capture_template_fixed_center_frequency(self))
         self.add_capture_template(Mode.TUNER_1_SWEPT_CENTER_FREQUENCY,
-                                  self._get_capture_template_swept_center_frequency())
+                                  get_capture_template_swept_center_frequency(self))
         
     
     def _add_pvalidators(
         self
     ) -> None:
         self.add_pvalidator(Mode.TUNER_1_FIXED_CENTER_FREQUENCY,
-                            self._get_pvalidator_fixed_center_frequency())
+                            get_pvalidator_fixed_center_frequency(self))
         self.add_pvalidator(Mode.TUNER_2_FIXED_CENTER_FREQUENCY,
-                            self._get_pvalidator_fixed_center_frequency())
+                            get_pvalidator_fixed_center_frequency(self))
         self.add_pvalidator(Mode.TUNER_1_SWEPT_CENTER_FREQUENCY,
-                            self._get_pvalidator_swept_center_frequency())
+                            get_pvalidator_swept_center_frequency(self))

spectre_core-0.0.16/src/spectre_core/receivers/plugins/_sdrplay_receiver.py

@@ -0,0 +1,174 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from typing import Callable, overload
+
+from spectre_core.capture_configs import (
+    CaptureTemplate, CaptureMode, Parameters, Bound, PName,
+    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
+
+
+def get_pvalidator_fixed_center_frequency(
+    sdrplay_receiver: BaseReceiver 
+) -> Callable[[Parameters], None]:
+    def pvalidator(parameters: Parameters) -> None:
+        validate_fixed_center_frequency(parameters)
+    return pvalidator
+
+
+def get_pvalidator_swept_center_frequency(
+    sdrplay_receiver: BaseReceiver 
+) -> Callable[[Parameters], None]:
+    def pvalidator(parameters: Parameters) -> None:
+        validate_swept_center_frequency(parameters,
+                                        sdrplay_receiver.get_spec(SpecName.API_RETUNING_LATENCY))
+    return pvalidator
+
+
+def get_capture_template_fixed_center_frequency(
+    sdrplay_receiver: BaseReceiver
+) -> 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.IF_GAIN) )
+    capture_template.add_ptemplate( get_base_ptemplate(PName.RF_GAIN) )
+
+    capture_template.set_defaults(
+        (PName.BATCH_SIZE,            3.0),
+        (PName.CENTER_FREQUENCY,      95800000),
+        (PName.SAMPLE_RATE,           600000),
+        (PName.BANDWIDTH,             600000),
+        (PName.WINDOW_HOP,            512),
+        (PName.WINDOW_SIZE,           1024),
+        (PName.WINDOW_TYPE,           "blackman"),
+        (PName.RF_GAIN,               -30),
+        (PName.IF_GAIN,               -30)
+    )   
+
+    capture_template.add_pconstraint(
+        PName.CENTER_FREQUENCY,
+        [
+            Bound(
+                lower_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
+                upper_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        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)
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.BANDWIDTH,
+        [
+            OneOf(
+                sdrplay_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)
+            )
+        ]
+    )
+    return capture_template
+
+
+def get_capture_template_swept_center_frequency(
+    sdrplay_receiver: BaseReceiver
+) -> 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.IF_GAIN) )
+    capture_template.add_ptemplate( get_base_ptemplate(PName.RF_GAIN) )
+
+    capture_template.set_defaults(
+        (PName.BATCH_SIZE,            4.0),
+        (PName.MIN_FREQUENCY,         95000000),
+        (PName.MAX_FREQUENCY,         100000000),
+        (PName.SAMPLES_PER_STEP,      80000),
+        (PName.FREQUENCY_STEP,        1536000),
+        (PName.SAMPLE_RATE,           1536000),
+        (PName.BANDWIDTH,             1536000),
+        (PName.WINDOW_HOP,            512),
+        (PName.WINDOW_SIZE,           1024),
+        (PName.WINDOW_TYPE,           "blackman"),
+        (PName.RF_GAIN,               -30),
+        (PName.IF_GAIN,               -30)
+    )   
+
+    capture_template.add_pconstraint(
+        PName.MIN_FREQUENCY,
+        [
+            Bound(
+                lower_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
+                upper_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.MAX_FREQUENCY,
+        [
+            Bound(
+                lower_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
+                upper_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        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)
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.BANDWIDTH,
+        [
+            OneOf(
+                sdrplay_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)
+            )
+        ]
+    )
+    return capture_template