spectre-core 0.0.10__py3-none-any.whl → 0.0.11__py3-none-any.whl

spectre_core/capture_configs/_pvalidators.py

@@ -131,10 +131,8 @@ def _validate_step_interval(
 
     step_interval = samples_per_step * 1/ sample_rate # [s]
     if step_interval < api_latency:
-        warning_message = (f"The computed step interval of {step_interval} [s] is of the order of empirically "
-                           f"derived api latency {api_latency} [s]; you may experience undefined behaviour!")
-        warn(warning_message)
-        _LOGGER.warning(warning_message)
+        raise ValueError(f"The computed step interval of {step_interval} [s] is of the order of empirically "
+                         f"derived api latency {api_latency} [s]; you may experience undefined behaviour!")
 
 
 def _validate_fixed_center_frequency_parameters(

spectre_core/post_processing/_base.py

@@ -104,7 +104,7 @@ class BaseEventHandler(ABC, FileSystemEventHandler):
             self._cached_spectrogram = join_spectrograms([self._cached_spectrogram, spectrogram])
 
         # if the time range is not specified
-        time_range = self._capture_config.get_parameter_value(PNames.TIME_RANGE) or self._capture_config.get_parameter_value(PNames.BATCH_SIZE)
+        time_range = self._capture_config.get_parameter_value(PNames.TIME_RANGE) or 0.0
   
         if self._cached_spectrogram.time_range >= time_range:
             self._flush_cache()

spectre_core/receivers/__init__.py

@@ -5,6 +5,7 @@
 # register decorators take effect on import
 from .library._test import _Receiver
 from .library._rsp1a import _Receiver
+from .library._rspduo import _Receiver
 
 from ._base import BaseReceiver
 from ._factory import get_receiver

spectre_core/receivers/_base.py

@@ -177,176 +177,4 @@ class BaseReceiver(ABC):
         parameters = self.capture_template.apply_template(capture_config.parameters)
         self.pvalidator(parameters)
         
-        return parameters
-    
-
-class SDRPlayReceiver(BaseReceiver):
-    def _get_pvalidator_fixed_center_frequency(self) -> Callable:
-        def pvalidator(parameters: Parameters):
-            PValidators.fixed_center_frequency(parameters)
-        return pvalidator
-
-
-    def _get_pvalidator_swept_center_frequency(self) -> None:
-        def pvalidator(parameters: Parameters):
-            PValidators.swept_center_frequency(parameters,
-                                               self.get_spec(SpecNames.API_RETUNING_LATENCY))
-        return pvalidator
-
-
-    def _get_capture_template_fixed_center_frequency(self) -> CaptureTemplate:
-        #
-        # Create the base template
-        #
-        capture_template = get_base_capture_template( CaptureModes.FIXED_CENTER_FREQUENCY )
-        capture_template.add_ptemplate( get_base_ptemplate(PNames.BANDWIDTH) )
-        capture_template.add_ptemplate( get_base_ptemplate(PNames.IF_GAIN) )
-        capture_template.add_ptemplate( get_base_ptemplate(PNames.RF_GAIN) )
-
-        #
-        # Update the defaults
-        #
-        capture_template.set_defaults(
-            (PNames.BATCH_SIZE,            3.0),
-            (PNames.CENTER_FREQUENCY,      95800000),
-            (PNames.SAMPLE_RATE,           600000),
-            (PNames.BANDWIDTH,             600000),
-            (PNames.WINDOW_HOP,            512),
-            (PNames.WINDOW_SIZE,           1024),
-            (PNames.WINDOW_TYPE,           "blackman"),
-            (PNames.RF_GAIN,               -30),
-            (PNames.IF_GAIN,               -30)
-        )   
-
-        #
-        # Adding pconstraints
-        #
-        capture_template.add_pconstraint(
-            PNames.CENTER_FREQUENCY,
-            [
-                Bound(
-                    lower_bound=self.get_spec(SpecNames.FREQUENCY_LOWER_BOUND),
-                    upper_bound=self.get_spec(SpecNames.FREQUENCY_UPPER_BOUND)
-                )
-            ]
-        )
-        capture_template.add_pconstraint(
-            PNames.SAMPLE_RATE,
-            [
-                Bound(
-                    lower_bound=self.get_spec(SpecNames.SAMPLE_RATE_LOWER_BOUND),
-                    upper_bound=self.get_spec(SpecNames.SAMPLE_RATE_UPPER_BOUND)
-                )
-            ]
-        )
-        capture_template.add_pconstraint(
-            PNames.BANDWIDTH,
-            [
-                OneOf(
-                    self.get_spec( SpecNames.BANDWIDTH_OPTIONS )
-                )
-            ]
-        )
-        capture_template.add_pconstraint(
-            PNames.IF_GAIN,
-            [
-                Bound(
-                    upper_bound=self.get_spec(SpecNames.IF_GAIN_UPPER_BOUND)
-                )
-            ]
-        )
-        capture_template.add_pconstraint(
-            PNames.RF_GAIN,
-            [
-                Bound(
-                    upper_bound=self.get_spec(SpecNames.RF_GAIN_UPPER_BOUND)
-                )
-            ]
-        )
-        return capture_template
-
-
-    def _get_capture_template_swept_center_frequency(self) -> CaptureTemplate:
-        #
-        # Create the base template
-        #
-        capture_template = get_base_capture_template( CaptureModes.SWEPT_CENTER_FREQUENCY )
-        capture_template.add_ptemplate( get_base_ptemplate(PNames.BANDWIDTH) )
-        capture_template.add_ptemplate( get_base_ptemplate(PNames.IF_GAIN) )
-        capture_template.add_ptemplate( get_base_ptemplate(PNames.RF_GAIN) )
-
-
-        #
-        # Update the defaults
-        #
-        capture_template.set_defaults(
-            (PNames.BATCH_SIZE,            3.0),
-            (PNames.MIN_FREQUENCY,         90000000),
-            (PNames.MAX_FREQUENCY,         110000000),
-            (PNames.SAMPLES_PER_STEP,      300000),
-            (PNames.FREQUENCY_STEP,        1536000),
-            (PNames.SAMPLE_RATE,           1536000),
-            (PNames.BANDWIDTH,             1536000),
-            (PNames.WINDOW_HOP,            512),
-            (PNames.WINDOW_SIZE,           1024),
-            (PNames.WINDOW_TYPE,           "blackman"),
-            (PNames.RF_GAIN,               -30),
-            (PNames.IF_GAIN,               -30)
-        )   
-
-
-        #
-        # Adding pconstraints
-        #
-        capture_template.add_pconstraint(
-            PNames.MIN_FREQUENCY,
-            [
-                Bound(
-                    lower_bound=self.get_spec(SpecNames.FREQUENCY_LOWER_BOUND),
-                    upper_bound=self.get_spec(SpecNames.FREQUENCY_UPPER_BOUND)
-                )
-            ]
-        )
-        capture_template.add_pconstraint(
-            PNames.MAX_FREQUENCY,
-            [
-                Bound(
-                    lower_bound=self.get_spec(SpecNames.FREQUENCY_LOWER_BOUND),
-                    upper_bound=self.get_spec(SpecNames.FREQUENCY_UPPER_BOUND)
-                )
-            ]
-        )
-        capture_template.add_pconstraint(
-            PNames.SAMPLE_RATE,
-            [
-                Bound(
-                    lower_bound=self.get_spec(SpecNames.SAMPLE_RATE_LOWER_BOUND),
-                    upper_bound=self.get_spec(SpecNames.SAMPLE_RATE_UPPER_BOUND)
-                )
-            ]
-        )
-        capture_template.add_pconstraint(
-            PNames.BANDWIDTH,
-            [
-                OneOf(
-                    self.get_spec( SpecNames.BANDWIDTH_OPTIONS )
-                )
-            ]
-        )
-        capture_template.add_pconstraint(
-            PNames.IF_GAIN,
-            [
-                Bound(
-                    upper_bound=self.get_spec(SpecNames.IF_GAIN_UPPER_BOUND)
-                )
-            ]
-        )
-        capture_template.add_pconstraint(
-            PNames.RF_GAIN,
-            [
-                Bound(
-                    upper_bound=self.get_spec(SpecNames.RF_GAIN_UPPER_BOUND)
-                )
-            ]
-        )
-        return capture_template
+        return parameters

spectre_core/receivers/gr/_rsp1a.py

@@ -13,7 +13,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 #
-# Test receiver top blocks
+# RSP1A receiver top blocks
 #
 
 from functools import partial
@@ -31,7 +31,7 @@ class _fixed_center_frequency(gr.top_block):
     def __init__(self, 
                  tag: str,
                  parameters: Parameters):
-        gr.top_block.__init__(self, "fixed-center-frequency", catch_exceptions=True)
+        gr.top_block.__init__(self, catch_exceptions=True)
 
         ##################################################
         # Unpack capture config
@@ -42,7 +42,7 @@ class _fixed_center_frequency(gr.top_block):
         bandwidth   = parameters.get_parameter_value(PNames.BANDWIDTH)
         if_gain     = parameters.get_parameter_value(PNames.IF_GAIN)
         rf_gain     = parameters.get_parameter_value(PNames.RF_GAIN)
-        is_sweeping = False
+        
 
         ##################################################
         # Blocks
@@ -86,7 +86,7 @@ class _swept_center_frequency(gr.top_block):
     def __init__(self, 
                  tag: str,
                  parameters: Parameters):
-        gr.top_block.__init__(self, "sweep", catch_exceptions=True)
+        gr.top_block.__init__(self, catch_exceptions=True)
 
         ##################################################
         # Unpack capture config
@@ -155,4 +155,4 @@ class _swept_center_frequency(gr.top_block):
 @dataclass(frozen=True)
 class CaptureMethods:
     fixed_center_frequency  = partial(capture, top_block_cls=_fixed_center_frequency)
-    _swept_center_frequency = partial(capture, top_block_cls=_swept_center_frequency)
+    swept_center_frequency  = partial(capture, top_block_cls=_swept_center_frequency)

spectre_core/receivers/gr/_rspduo.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+#
+# SPDX-License-Identifier: GPL-3.0
+#
+# GNU Radio Python Flow Graph
+# Title: Test receiver
+# GNU Radio version: 3.10.1.1
+
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+#
+# RSPduo receiver top blocks
+#
+
+from functools import partial
+from dataclasses import dataclass
+
+from gnuradio import gr
+from gnuradio import spectre
+from gnuradio import sdrplay3
+
+from spectre_core.capture_configs import Parameters, PNames
+from spectre_core.config import get_chunks_dir_path
+from ._base import capture
+
+
+class _tuner_1_fixed_center_frequency(gr.top_block):
+    def __init__(self, 
+                 tag: str,
+                 parameters: Parameters):
+        gr.top_block.__init__(self, catch_exceptions=True)
+        gr.top_block.__init__(self, "tuner_1_fixed", catch_exceptions=True)
+        
+        ##################################################
+        # Unpack capture config
+        ##################################################
+        sample_rate = parameters.get_parameter_value(PNames.SAMPLE_RATE)
+        batch_size  = parameters.get_parameter_value(PNames.BATCH_SIZE)
+        center_freq = parameters.get_parameter_value(PNames.CENTER_FREQUENCY)
+        bandwidth   = parameters.get_parameter_value(PNames.BANDWIDTH)
+        if_gain     = parameters.get_parameter_value(PNames.IF_GAIN)
+        rf_gain     = parameters.get_parameter_value(PNames.RF_GAIN)
+
+        ##################################################
+        # Blocks
+        ##################################################
+        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_chunks_dir_path(), 
+                                                                     tag, 
+                                                                     batch_size, 
+                                                                     sample_rate)
+        self.sdrplay3_rspduo_0 = sdrplay3.rspduo(
+            '',
+            rspduo_mode="Single Tuner",
+            antenna="Tuner 1 50 ohm",
+            stream_args=sdrplay3.stream_args(
+                output_type='fc32',
+                channels_size=1
+            ),
+        )
+        self.sdrplay3_rspduo_0.set_sample_rate(sample_rate)
+        self.sdrplay3_rspduo_0.set_center_freq(center_freq)
+        self.sdrplay3_rspduo_0.set_bandwidth(bandwidth)
+        self.sdrplay3_rspduo_0.set_antenna("Tuner 1 50 ohm")
+        self.sdrplay3_rspduo_0.set_gain_mode(False)
+        self.sdrplay3_rspduo_0.set_gain(if_gain, 'IF')
+        self.sdrplay3_rspduo_0.set_gain(rf_gain, 'RF')
+        self.sdrplay3_rspduo_0.set_freq_corr(0)
+        self.sdrplay3_rspduo_0.set_dc_offset_mode(False)
+        self.sdrplay3_rspduo_0.set_iq_balance_mode(False)
+        self.sdrplay3_rspduo_0.set_agc_setpoint(-30)
+        self.sdrplay3_rspduo_0.set_rf_notch_filter(False)
+        self.sdrplay3_rspduo_0.set_dab_notch_filter(False)
+        self.sdrplay3_rspduo_0.set_am_notch_filter(False)
+        self.sdrplay3_rspduo_0.set_biasT(False)
+        self.sdrplay3_rspduo_0.set_debug_mode(False)
+        self.sdrplay3_rspduo_0.set_sample_sequence_gaps_check(False)
+        self.sdrplay3_rspduo_0.set_show_gain_changes(False)
+
+
+        ##################################################
+        # Connections
+        ##################################################
+        self.connect((self.sdrplay3_rspduo_0, 0), (self.spectre_batched_file_sink_0, 0))
+    
+        
+class _tuner_2_fixed_center_frequency(gr.top_block):
+    def __init__(self, 
+                 tag: str,
+                 parameters: Parameters):
+        gr.top_block.__init__(self, catch_exceptions=True)
+        gr.top_block.__init__(self, "tuner_1_fixed", catch_exceptions=True)
+        
+        ##################################################
+        # Unpack capture config
+        ##################################################
+        sample_rate = parameters.get_parameter_value(PNames.SAMPLE_RATE)
+        batch_size  = parameters.get_parameter_value(PNames.BATCH_SIZE)
+        center_freq = parameters.get_parameter_value(PNames.CENTER_FREQUENCY)
+        bandwidth   = parameters.get_parameter_value(PNames.BANDWIDTH)
+        if_gain     = parameters.get_parameter_value(PNames.IF_GAIN)
+        rf_gain     = parameters.get_parameter_value(PNames.RF_GAIN)
+
+        ##################################################
+        # Blocks
+        ##################################################
+        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_chunks_dir_path(), 
+                                                                     tag, 
+                                                                     batch_size, 
+                                                                     sample_rate)
+        self.sdrplay3_rspduo_0 = sdrplay3.rspduo(
+            '',
+            rspduo_mode="Single Tuner",
+            antenna="Tuner 2 50 ohm",
+            stream_args=sdrplay3.stream_args(
+                output_type='fc32',
+                channels_size=1
+            ),
+        )
+        self.sdrplay3_rspduo_0.set_sample_rate(sample_rate)
+        self.sdrplay3_rspduo_0.set_center_freq(center_freq)
+        self.sdrplay3_rspduo_0.set_bandwidth(bandwidth)
+        self.sdrplay3_rspduo_0.set_antenna("Tuner 2 50 ohm")
+        self.sdrplay3_rspduo_0.set_gain_mode(False)
+        self.sdrplay3_rspduo_0.set_gain(if_gain, 'IF')
+        self.sdrplay3_rspduo_0.set_gain(rf_gain, 'RF', False)
+        self.sdrplay3_rspduo_0.set_freq_corr(0)
+        self.sdrplay3_rspduo_0.set_dc_offset_mode(False)
+        self.sdrplay3_rspduo_0.set_iq_balance_mode(False)
+        self.sdrplay3_rspduo_0.set_agc_setpoint(-30)
+        self.sdrplay3_rspduo_0.set_rf_notch_filter(False)
+        self.sdrplay3_rspduo_0.set_dab_notch_filter(False)
+        self.sdrplay3_rspduo_0.set_am_notch_filter(False)
+        self.sdrplay3_rspduo_0.set_biasT(False)
+        self.sdrplay3_rspduo_0.set_stream_tags(False)
+        self.sdrplay3_rspduo_0.set_debug_mode(False)
+        self.sdrplay3_rspduo_0.set_sample_sequence_gaps_check(False)
+        self.sdrplay3_rspduo_0.set_show_gain_changes(False)
+
+
+        ##################################################
+        # Connections
+        ##################################################
+        self.connect((self.sdrplay3_rspduo_0, 0), (self.spectre_batched_file_sink_0, 0))    
+
+
+class _tuner_1_swept_center_frequency(gr.top_block):
+    def __init__(self, 
+                 tag: str,
+                 parameters: Parameters):
+        gr.top_block.__init__(self, catch_exceptions=True)
+
+        ##################################################
+        # Unpack capture config
+        ##################################################
+        sample_rate      = parameters.get_parameter_value(PNames.SAMPLE_RATE)
+        bandwidth        = parameters.get_parameter_value(PNames.BANDWIDTH)
+        min_frequency    = parameters.get_parameter_value(PNames.MIN_FREQUENCY)
+        max_frequency    = parameters.get_parameter_value(PNames.MAX_FREQUENCY)
+        frequency_step   = parameters.get_parameter_value(PNames.FREQUENCY_STEP)
+        samples_per_step = parameters.get_parameter_value(PNames.SAMPLES_PER_STEP)
+        if_gain          = parameters.get_parameter_value(PNames.IF_GAIN)
+        rf_gain          = parameters.get_parameter_value(PNames.RF_GAIN)
+        batch_size       = parameters.get_parameter_value(PNames.BATCH_SIZE)
+
+        ##################################################
+        # Blocks
+        ##################################################
+        self.spectre_sweep_driver_0 = spectre.sweep_driver(min_frequency, 
+                                                           max_frequency, 
+                                                           frequency_step, 
+                                                           sample_rate, 
+                                                           samples_per_step,
+                                                           'freq')
+        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_chunks_dir_path(), 
+                                                                     tag, 
+                                                                     batch_size, 
+                                                                     sample_rate, 
+                                                                     True, 
+                                                                     'freq', 
+                                                                     min_frequency)
+        self.sdrplay3_rspduo_0 = sdrplay3.rspduo(
+            '',
+            rspduo_mode="Single Tuner",
+            antenna="Tuner 1 50 ohm",
+            stream_args=sdrplay3.stream_args(
+                output_type='fc32',
+                channels_size=1
+            ),
+        )
+        self.sdrplay3_rspduo_0.set_sample_rate(sample_rate, True)
+        self.sdrplay3_rspduo_0.set_center_freq(min_frequency, True)
+        self.sdrplay3_rspduo_0.set_bandwidth(bandwidth)
+        self.sdrplay3_rspduo_0.set_antenna("Tuner 1 50 ohm")
+        self.sdrplay3_rspduo_0.set_gain_mode(False)
+        self.sdrplay3_rspduo_0.set_gain(if_gain, 'IF', True)
+        self.sdrplay3_rspduo_0.set_gain(rf_gain, 'RF', True)
+        self.sdrplay3_rspduo_0.set_freq_corr(0)
+        self.sdrplay3_rspduo_0.set_dc_offset_mode(False)
+        self.sdrplay3_rspduo_0.set_iq_balance_mode(False)
+        self.sdrplay3_rspduo_0.set_agc_setpoint(-30)
+        self.sdrplay3_rspduo_0.set_rf_notch_filter(False)
+        self.sdrplay3_rspduo_0.set_dab_notch_filter(True)
+        self.sdrplay3_rspduo_0.set_am_notch_filter(False)
+        self.sdrplay3_rspduo_0.set_biasT(False)
+        self.sdrplay3_rspduo_0.set_stream_tags(True)
+        self.sdrplay3_rspduo_0.set_debug_mode(False)
+        self.sdrplay3_rspduo_0.set_sample_sequence_gaps_check(False)
+        self.sdrplay3_rspduo_0.set_show_gain_changes(False)
+
+
+        ##################################################
+        # Connections
+        ##################################################
+        self.msg_connect((self.spectre_sweep_driver_0, 'freq'), (self.sdrplay3_rspduo_0, 'freq'))
+        self.connect((self.sdrplay3_rspduo_0, 0), (self.spectre_batched_file_sink_0, 0))
+        self.connect((self.sdrplay3_rspduo_0, 0), (self.spectre_sweep_driver_0, 0))
+        
+        
+@dataclass(frozen=True)
+class CaptureMethods:
+    tuner_1_fixed_center_frequency  = partial(capture, top_block_cls=_tuner_1_fixed_center_frequency)
+    tuner_2_fixed_center_frequency  = partial(capture, top_block_cls=_tuner_2_fixed_center_frequency)
+    tuner_1_swept_center_frequency  = partial(capture, top_block_cls=_tuner_1_swept_center_frequency)

spectre_core/receivers/gr/_test.py

@@ -33,7 +33,7 @@ class _cosine_signal_1(gr.top_block):
     def __init__(self, 
                  tag: str,
                  parameters: Parameters):
-        gr.top_block.__init__(self, "cosine-signal-1", catch_exceptions=True)
+        gr.top_block.__init__(self, catch_exceptions=True)
 
         ##################################################
         # Unpack capture config
@@ -80,7 +80,7 @@ class _tagged_staircase(gr.top_block):
     def __init__(self, 
                  tag: str,
                  parameters: Parameters):
-        gr.top_block.__init__(self, "tagged-staircase", catch_exceptions=True)
+        gr.top_block.__init__(self, catch_exceptions=True)
 
         ##################################################
         # Unpack capture config

spectre_core/receivers/library/_rsp1a.py

@@ -11,7 +11,7 @@ from spectre_core.capture_configs import (
 )
 from ..gr._rsp1a import CaptureMethods
 from .._spec_names import SpecNames
-from .._base import SDRPlayReceiver
+from ._sdrplay_receiver import SDRPlayReceiver
 from .._register import register_receiver
 
 @dataclass
@@ -44,7 +44,7 @@ class _Receiver(SDRPlayReceiver):
         self.add_capture_method(Modes.FIXED_CENTER_FREQUENCY, 
                                 CaptureMethods.fixed_center_frequency)
         self.add_capture_method(Modes.SWEPT_CENTER_FREQUENCY,
-                                CaptureMethods._swept_center_frequency)
+                                CaptureMethods.swept_center_frequency)
     
 
     def _add_capture_templates(self):
@@ -55,7 +55,7 @@ class _Receiver(SDRPlayReceiver):
         
     
     def _add_pvalidators(self):
-        self.add_pvalidator(CaptureModes.FIXED_CENTER_FREQUENCY,
+        self.add_pvalidator(Modes.FIXED_CENTER_FREQUENCY,
                             self._get_pvalidator_fixed_center_frequency())
-        self.add_pvalidator(CaptureModes.SWEPT_CENTER_FREQUENCY,
+        self.add_pvalidator(Modes.SWEPT_CENTER_FREQUENCY,
                             self._get_pvalidator_swept_center_frequency())

spectre_core/receivers/library/_rspduo.py

@@ -0,0 +1,69 @@
+# 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 Optional
+from dataclasses import dataclass
+from functools import partial
+
+from spectre_core.capture_configs import (
+    CaptureModes
+)
+from ..gr._rspduo import CaptureMethods
+from .._spec_names import SpecNames
+from ._sdrplay_receiver import SDRPlayReceiver
+from .._register import register_receiver
+
+@dataclass
+class Modes:
+    TUNER_1_FIXED_CENTER_FREQUENCY  = f"tuner-1-{CaptureModes.FIXED_CENTER_FREQUENCY}"
+    TUNER_2_FIXED_CENTER_FREQUENCY  = f"tuner-2-{CaptureModes.FIXED_CENTER_FREQUENCY}"
+    TUNER_1_SWEPT_CENTER_FREQUENCY  = f"tuner-1-{CaptureModes.SWEPT_CENTER_FREQUENCY}"
+
+
+@register_receiver("rspduo")
+class _Receiver(SDRPlayReceiver):
+    def __init__(self, 
+                 name: str,
+                 mode: Optional[str]):
+        super().__init__(name,
+                         mode)
+        
+
+    def _add_specs(self) -> None:
+        self.add_spec( SpecNames.SAMPLE_RATE_LOWER_BOUND, 200e3     ) # Hz
+        self.add_spec( SpecNames.SAMPLE_RATE_UPPER_BOUND, 10e6      ) # Hz
+        self.add_spec( SpecNames.FREQUENCY_LOWER_BOUND  , 1e3       ) # Hz
+        self.add_spec( SpecNames.FREQUENCY_UPPER_BOUND  , 2e9       ) # Hz
+        self.add_spec( SpecNames.IF_GAIN_UPPER_BOUND    , -20       ) # dB
+        self.add_spec( SpecNames.RF_GAIN_UPPER_BOUND    , 0         ) # dB
+        self.add_spec( SpecNames.API_RETUNING_LATENCY   , 50 * 1e-3 ) # s
+        self.add_spec( SpecNames.BANDWIDTH_OPTIONS, 
+                      [200000, 300000, 600000, 1536000, 5000000, 6000000, 7000000, 8000000])
+
+
+    def _add_capture_methods(self) -> None:
+        self.add_capture_method(Modes.TUNER_1_FIXED_CENTER_FREQUENCY, 
+                                CaptureMethods.tuner_1_fixed_center_frequency)
+        self.add_capture_method(Modes.TUNER_2_FIXED_CENTER_FREQUENCY, 
+                                CaptureMethods.tuner_2_fixed_center_frequency)
+        self.add_capture_method(Modes.TUNER_1_SWEPT_CENTER_FREQUENCY, 
+                                CaptureMethods.tuner_1_swept_center_frequency)
+    
+
+    def _add_capture_templates(self):
+        self.add_capture_template(Modes.TUNER_1_FIXED_CENTER_FREQUENCY,
+                                  self._get_capture_template_fixed_center_frequency())
+        self.add_capture_template(Modes.TUNER_2_FIXED_CENTER_FREQUENCY,
+                                  self._get_capture_template_fixed_center_frequency())
+        self.add_capture_template(Modes.TUNER_1_SWEPT_CENTER_FREQUENCY,
+                                  self._get_capture_template_swept_center_frequency())
+        
+    
+    def _add_pvalidators(self):
+        self.add_pvalidator(Modes.TUNER_1_FIXED_CENTER_FREQUENCY,
+                            self._get_pvalidator_fixed_center_frequency())
+        self.add_pvalidator(Modes.TUNER_2_FIXED_CENTER_FREQUENCY,
+                            self._get_pvalidator_fixed_center_frequency())
+        self.add_pvalidator(Modes.TUNER_1_SWEPT_CENTER_FREQUENCY,
+                            self._get_pvalidator_swept_center_frequency())

spectre_core/receivers/library/_sdrplay_receiver.py

@@ -0,0 +1,185 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+from abc import ABC, abstractmethod
+from typing import Callable, Optional
+from numbers import Number
+
+from spectre_core.capture_configs import (
+    CaptureTemplate, CaptureModes, Parameters, Bound, PValidators, PNames,
+    get_base_capture_template, get_base_ptemplate, OneOf, CaptureConfig
+)
+from .._base import BaseReceiver
+from .._spec_names import SpecNames
+
+class SDRPlayReceiver(BaseReceiver):
+    def _get_pvalidator_fixed_center_frequency(self) -> Callable:
+        def pvalidator(parameters: Parameters):
+            PValidators.fixed_center_frequency(parameters)
+        return pvalidator
+
+
+    def _get_pvalidator_swept_center_frequency(self) -> None:
+        def pvalidator(parameters: Parameters):
+            PValidators.swept_center_frequency(parameters,
+                                               self.get_spec(SpecNames.API_RETUNING_LATENCY))
+        return pvalidator
+
+
+    def _get_capture_template_fixed_center_frequency(self) -> CaptureTemplate:
+        #
+        # Create the base template
+        #
+        capture_template = get_base_capture_template( CaptureModes.FIXED_CENTER_FREQUENCY )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.BANDWIDTH) )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.IF_GAIN) )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.RF_GAIN) )
+
+        #
+        # Update the defaults
+        #
+        capture_template.set_defaults(
+            (PNames.BATCH_SIZE,            3.0),
+            (PNames.CENTER_FREQUENCY,      95800000),
+            (PNames.SAMPLE_RATE,           600000),
+            (PNames.BANDWIDTH,             600000),
+            (PNames.WINDOW_HOP,            512),
+            (PNames.WINDOW_SIZE,           1024),
+            (PNames.WINDOW_TYPE,           "blackman"),
+            (PNames.RF_GAIN,               -30),
+            (PNames.IF_GAIN,               -30)
+        )   
+
+        #
+        # Adding pconstraints
+        #
+        capture_template.add_pconstraint(
+            PNames.CENTER_FREQUENCY,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecNames.FREQUENCY_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecNames.FREQUENCY_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.SAMPLE_RATE,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecNames.SAMPLE_RATE_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecNames.SAMPLE_RATE_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.BANDWIDTH,
+            [
+                OneOf(
+                    self.get_spec( SpecNames.BANDWIDTH_OPTIONS )
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.IF_GAIN,
+            [
+                Bound(
+                    upper_bound=self.get_spec(SpecNames.IF_GAIN_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.RF_GAIN,
+            [
+                Bound(
+                    upper_bound=self.get_spec(SpecNames.RF_GAIN_UPPER_BOUND)
+                )
+            ]
+        )
+        return capture_template
+
+
+    def _get_capture_template_swept_center_frequency(self) -> CaptureTemplate:
+        #
+        # Create the base template
+        #
+        capture_template = get_base_capture_template( CaptureModes.SWEPT_CENTER_FREQUENCY )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.BANDWIDTH) )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.IF_GAIN) )
+        capture_template.add_ptemplate( get_base_ptemplate(PNames.RF_GAIN) )
+
+
+        #
+        # Update the defaults
+        #
+        capture_template.set_defaults(
+            (PNames.BATCH_SIZE,            4.0),
+            (PNames.MIN_FREQUENCY,         95000000),
+            (PNames.MAX_FREQUENCY,         100000000),
+            (PNames.SAMPLES_PER_STEP,      80000),
+            (PNames.FREQUENCY_STEP,        1536000),
+            (PNames.SAMPLE_RATE,           1536000),
+            (PNames.BANDWIDTH,             1536000),
+            (PNames.WINDOW_HOP,            512),
+            (PNames.WINDOW_SIZE,           1024),
+            (PNames.WINDOW_TYPE,           "blackman"),
+            (PNames.RF_GAIN,               -30),
+            (PNames.IF_GAIN,               -30)
+        )   
+
+
+        #
+        # Adding pconstraints
+        #
+        capture_template.add_pconstraint(
+            PNames.MIN_FREQUENCY,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecNames.FREQUENCY_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecNames.FREQUENCY_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.MAX_FREQUENCY,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecNames.FREQUENCY_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecNames.FREQUENCY_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.SAMPLE_RATE,
+            [
+                Bound(
+                    lower_bound=self.get_spec(SpecNames.SAMPLE_RATE_LOWER_BOUND),
+                    upper_bound=self.get_spec(SpecNames.SAMPLE_RATE_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.BANDWIDTH,
+            [
+                OneOf(
+                    self.get_spec( SpecNames.BANDWIDTH_OPTIONS )
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.IF_GAIN,
+            [
+                Bound(
+                    upper_bound=self.get_spec(SpecNames.IF_GAIN_UPPER_BOUND)
+                )
+            ]
+        )
+        capture_template.add_pconstraint(
+            PNames.RF_GAIN,
+            [
+                Bound(
+                    upper_bound=self.get_spec(SpecNames.RF_GAIN_UPPER_BOUND)
+                )
+            ]
+        )
+        return capture_template

{spectre_core-0.0.10.dist-info → spectre_core-0.0.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spectre-core
-Version: 0.0.10
+Version: 0.0.11
 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.10.dist-info → spectre_core-0.0.11.dist-info}/RECORD

@@ -8,7 +8,7 @@ spectre_core/capture_configs/_capture_templates.py,sha256=P-oU_c8ICIuIkXDgfIsWts
 spectre_core/capture_configs/_parameters.py,sha256=TYMrRwdqI8nruBKmZbxOcqmWinBJNro-efHl_0yYLpM,3708
 spectre_core/capture_configs/_pconstraints.py,sha256=262ocQn11v3sJIiaQ-5Ihr4ZoLGTH2_pyFSA2dJb_pc,3241
 spectre_core/capture_configs/_ptemplates.py,sha256=TzOcJG1RthYEXIsekInmV6Hp4kncEQQi9Fn7fozOGQs,23578
-spectre_core/capture_configs/_pvalidators.py,sha256=uXAfyM8xUpLKKCPsQQGWJZKi4M0Wqy1csdP7zcg9MzU,7263
+spectre_core/capture_configs/_pvalidators.py,sha256=uE9ZkQgGWtgTIbMrshj58ItI0GH3Nn-CsGRkXa8qVtQ,7188
 spectre_core/chunks/__init__.py,sha256=w2PPNbw0kyRL7EV4ERRhObX1y3yt_uqSpYL75i1TeVE,604
 spectre_core/chunks/_base.py,sha256=bm9EwsUUqCpaLMWqI9rgcMHpJoYhnlJsz9u1ewqaoUU,3561
 spectre_core/chunks/_chunks.py,sha256=na4dCwdCpIRZzPUJ4wjVGcezyn03E4JMxzfKAQJbWuc,6968
@@ -30,24 +30,25 @@ spectre_core/plotting/_format.py,sha256=3nB3xiiCjjerxkfMdhcOoeknLb2FimoN5sPPkrp1
 spectre_core/plotting/_panel_stack.py,sha256=T1aASyTJEeJcSzy3vkxLcrFg5SpyVnPjV_0mS5t1W8A,5023
 spectre_core/plotting/_panels.py,sha256=dasPkarjfFHmWf6I9a-Te6BXUP_HPM6NsOxLBRrdGp0,8661
 spectre_core/post_processing/__init__.py,sha256=zQlqEEvhPkWQvBRjOWNqmfdo-jczNsusqEnalZotXtk,486
-spectre_core/post_processing/_base.py,sha256=dmKVUKxF1e7wm1ObwbGBk4WVd55AzMtnCzdSKXdv9ww,4981
+spectre_core/post_processing/_base.py,sha256=hYGvUEUB1IXee-ns70ZjFoxx0xAR4qKhOJ33l2wqUdE,4925
 spectre_core/post_processing/_factory.py,sha256=AwTN74mrq87Hraaa8prrEHwKTpfgTUlI9LLjxxSa_ws,1119
 spectre_core/post_processing/_post_processor.py,sha256=2hIBGng5xx_uZJg-EjVg0gBNI_iNKJidoCRTnejCCmA,1414
 spectre_core/post_processing/_register.py,sha256=DwlkU92IFkZ1_qvGfhep_OfuqTOIR_efY5qFpn1perw,498
 spectre_core/post_processing/library/_fixed_center_frequency.py,sha256=ctSDzOTcAroBeV_iN_h4xEgzCO2pXJPzX6-qLZVnLV0,4349
 spectre_core/post_processing/library/_swept_center_frequency.py,sha256=VKo838E17yzkwSLxSVHRxmvj18DelzAVCtEfCFyYv3o,19476
-spectre_core/receivers/__init__.py,sha256=UfLEIjuOhULlbGnqAwIGZaBcdj39LEtYf4QEC287GDM,514
-spectre_core/receivers/_base.py,sha256=7Lhu5Izx7YcRZsPax6wcSpeOywqoEcNVckeeBq78MRU,10833
+spectre_core/receivers/__init__.py,sha256=ZYoKKkv6ml8mOAYameUmuh2b6UESmnGeVMe8fR2wZHs,553
+spectre_core/receivers/_base.py,sha256=hBNs0om8g7uaTNEOuSZE4OVCII8q37rwrmOBNHOKeCw,5011
 spectre_core/receivers/_factory.py,sha256=3P1bxNnt4OxQS0tRNUEZ0Wc1iGc0hgjE9_qS8fGJPRM,822
 spectre_core/receivers/_register.py,sha256=xHcRnT-3NQxyIWL3nyT3P9qT14Wl5liM9HbflOvOUAM,617
 spectre_core/receivers/_spec_names.py,sha256=RlQzzD10V0-_ZyqaMUmG9LCoSLGAzyxmQ_eS7e6qvqY,936
 spectre_core/receivers/gr/__init__.py,sha256=oFSWmGoXQLK5X5xHvWzTdNr9amuaiiGjZirXZVogACU,154
 spectre_core/receivers/gr/_base.py,sha256=uBtV-nFMzfp8YFeoSbfWmxhEtpLplyjdvfGOqPBmzVI,882
-spectre_core/receivers/gr/_rsp1a.py,sha256=9LJ2E_NgQSows06Q7M1Z1zwZ8RYcTgZ_DHPCGaqFXcA,7276
-spectre_core/receivers/gr/_rspduo.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spectre_core/receivers/gr/_test.py,sha256=_nA3VRGglLCgrKBT2pC3J48-KxBUqq8tD_QWCQcJ7XI,5933
-spectre_core/receivers/library/_rsp1a.py,sha256=TjC8B-R4zS82LAL94RID5FH2XL0TpeZ-j9Ji0njt1Ew,2537
-spectre_core/receivers/library/_rspduo.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spectre_core/receivers/gr/_rsp1a.py,sha256=5kDZMYR_xYT2P0Nk4nLtFQAKNSSO00-aqsNHK5ODJOc,7223
+spectre_core/receivers/gr/_rspduo.py,sha256=z17gItngH-iW7qM658rF6PR3_0QVs97uAWpFtr544VQ,10852
+spectre_core/receivers/gr/_test.py,sha256=re0gnHxGcrpT4VabR2EeXA6krziitT3xzeZimbqlHrE,5894
+spectre_core/receivers/library/_rsp1a.py,sha256=a1BY27MzFgrSMH3zf2BbQxwYMRfcl1WZmX6FURe7-04,2533
+spectre_core/receivers/library/_rspduo.py,sha256=T5NIOsyEO1eiS7V44L-GtZSLWp6B6me_7jtusyCX2YQ,3180
+spectre_core/receivers/library/_sdrplay_receiver.py,sha256=br8uX_m-vpZB1Z-TZtSTHREoNm3YMhiL_Kx5BqU0LUM,6334
 spectre_core/receivers/library/_test.py,sha256=VeGveqfQJ4RsgapQEUuul-AFmzEaZlghJmThWWwd1_c,8278
 spectre_core/spectrograms/__init__.py,sha256=3_BmRi41isVW8oEM_-Ce61eg9kaF_WUZFNciITTDlhY,721
 spectre_core/spectrograms/_analytical.py,sha256=k6ZDKwAyVbT4QhQDaso84yENvp6uiV4hoCKn7ID89zo,9054
@@ -56,8 +57,8 @@ spectre_core/spectrograms/_spectrogram.py,sha256=f8q6V3V4_fVMJox1oX-L76FdTcOyFJu
 spectre_core/spectrograms/_transform.py,sha256=GQqL8LlP1EdqK-1HX4nmnQV3YZXZ9hRpeBV0_EQZCZk,12564
 spectre_core/wgetting/__init__.py,sha256=dP7qu__escq8w47x0fRCa4gd481f1Bv4drGTo8b7AEQ,301
 spectre_core/wgetting/_callisto.py,sha256=cOpTaI7L0dNN8R5VsRkcRaPjkV0n5_JwWdspfoyFuWw,4667
-spectre_core-0.0.10.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-spectre_core-0.0.10.dist-info/METADATA,sha256=XUQoFIdLs7r4Q09d47kLUgQ_-BX_Z7GfiymAsAR52SA,42151
-spectre_core-0.0.10.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-spectre_core-0.0.10.dist-info/top_level.txt,sha256=-UsyjpFohXgZpgcZ9QbVeXhsIyF3Am8RxNFNDV_Ta2Y,13
-spectre_core-0.0.10.dist-info/RECORD,,
+spectre_core-0.0.11.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+spectre_core-0.0.11.dist-info/METADATA,sha256=2S0_bvGt_0nmlHJuAoy0vYsEa8Mcw1QLWA4hMWtzdMw,42151
+spectre_core-0.0.11.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+spectre_core-0.0.11.dist-info/top_level.txt,sha256=-UsyjpFohXgZpgcZ9QbVeXhsIyF3Am8RxNFNDV_Ta2Y,13
+spectre_core-0.0.11.dist-info/RECORD,,