spectre-core 0.0.15__tar.gz → 0.0.17__tar.gz

{spectre_core-0.0.15 → spectre_core-0.0.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: spectre-core
-Version: 0.0.15
+Version: 0.0.17
 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.15 → spectre_core-0.0.17}/pyproject.toml

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

{spectre_core-0.0.15 → spectre_core-0.0.17}/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.15 → spectre_core-0.0.17}/src/spectre_core/capture_configs/_pnames.py

@@ -47,4 +47,6 @@ class PName(Enum):
     OBS_LAT              = "obs_lat"
     OBS_LON              = "obs_lon"
     OBS_ALT              = "obs_alt"
-    NORMALISED_GAIN      = "normalised_gain"
+    GAIN                 = "gain"
+    MASTER_CLOCK_RATE    = "master_clock_rate"
+    WIRE_FORMAT          = "wire_format"

{spectre_core-0.0.15 → spectre_core-0.0.17}/src/spectre_core/capture_configs/_ptemplates.py

@@ -300,14 +300,24 @@ _base_ptemplates: dict[PName, PTemplate] = {
                                             pconstraints=[
                                                 EnforceSign.non_positive
                                                 ]),
-    PName.NORMALISED_GAIN:                  PTemplate(PName.NORMALISED_GAIN,
+    PName.GAIN:                   PTemplate(PName.GAIN,
                                             float,
                                             help = """
-                                                 The normalised gain value, where 1.0 is mapped to the max gain of the receiver being used.
-                                                 """,
-                                            pconstraints=[
-                                                Bound(0.0, 1.0)
-                                                ]),
+                                                 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 = """

{spectre_core-0.0.15 → spectre_core-0.0.17}/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.15 → spectre_core-0.0.17}/src/spectre_core/config/__init__.py

@@ -6,7 +6,8 @@
 """General `spectre` package configurations."""
 
 from ._paths import (
-    get_spectre_data_dir_path, get_batches_dir_path, get_configs_dir_path, get_logs_dir_path
+    get_spectre_data_dir_path, get_batches_dir_path, get_configs_dir_path, 
+    get_logs_dir_path, trim_spectre_data_dir_path
 )
 from ._time_formats import (
     TimeFormat
@@ -14,5 +15,5 @@ from ._time_formats import (
 
 __all__ = [
     "get_spectre_data_dir_path", "get_batches_dir_path", "get_configs_dir_path", "get_logs_dir_path",
-    "TimeFormat"
+    "TimeFormat", "trim_spectre_data_dir_path"
 ]

{spectre_core-0.0.15 → spectre_core-0.0.17}/src/spectre_core/config/_paths.py

@@ -115,3 +115,35 @@ def get_configs_dir_path(
     :return: The directory path for configuration files.
     """
     return _CONFIGS_DIR_PATH
+
+
+def trim_spectre_data_dir_path(
+    full_path: str
+) -> str:
+    """Remove the `SPECTRE_DATA_DIR_PATH` prefix from a full file path.
+
+    This function returns the relative path of `full_path` with respect to
+    `SPECTRE_DATA_DIR_PATH`. It is useful for trimming absolute paths
+    to maintain consistency across different environments where the base
+    directory might differ.
+
+    :param full_path: The full file path to be trimmed.
+    :return: The relative path with `SPECTRE_DATA_DIR_PATH` removed.
+    """
+    return os.path.relpath(full_path, _SPECTRE_DATA_DIR_PATH)
+
+
+def add_spectre_data_dir_path(
+    rel_path: str
+) -> str:
+    """Prepend the `SPECTRE_DATA_DIR_PATH` prefix to a relative file path.
+
+    This function constructs an absolute path by joining the given relative
+    path with `SPECTRE_DATA_DIR_PATH`. It is useful for converting stored
+    relative paths back into full paths within the mounted directory.
+
+    :param rel_path: The relative file path to be appended.
+    :return: The full file path prefixed with `SPECTRE_DATA_DIR_PATH`.
+    """
+    return os.path.join(_SPECTRE_DATA_DIR_PATH, rel_path)
+

{spectre_core-0.0.15 → spectre_core-0.0.17}/src/spectre_core/receivers/_base.py

@@ -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.

{spectre_core-0.0.15 → spectre_core-0.0.17}/src/spectre_core/receivers/_spec_names.py

@@ -18,16 +18,24 @@ class SpecName(Enum):
     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"
-    API_RETUNING_LATENCY     = "api_retuning_latency"
+    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.17/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.17/src/spectre_core/receivers/plugins/_usrp.py

@@ -0,0 +1,205 @@
+# 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_sample_rate_with_master_clock_rate,
+    validate_fixed_center_frequency, validate_swept_center_frequency
+)
+from .._base import BaseReceiver
+from .._spec_names import SpecName
+
+
+def get_pvalidator_fixed_center_frequency(
+    usrp_receiver: BaseReceiver 
+) -> Callable[[Parameters], None]:
+    def pvalidator(parameters: Parameters) -> None:
+        validate_fixed_center_frequency(parameters)
+        validate_sample_rate_with_master_clock_rate(parameters)
+    return pvalidator
+
+
+def get_pvalidator_swept_center_frequency(
+    usrp_receiver: BaseReceiver 
+) -> Callable[[Parameters], None]:
+    def pvalidator(parameters: Parameters) -> None:
+        validate_swept_center_frequency(parameters,
+                                        usrp_receiver.get_spec(SpecName.API_RETUNING_LATENCY))
+        validate_sample_rate_with_master_clock_rate(parameters)
+    return pvalidator
+
+
+def get_capture_template_fixed_center_frequency(
+    usrp_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.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=usrp_receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
+                upper_bound=usrp_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.SAMPLE_RATE,
+        [
+            Bound(
+                lower_bound=usrp_receiver.get_spec(SpecName.SAMPLE_RATE_LOWER_BOUND),
+                upper_bound=usrp_receiver.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND)
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.BANDWIDTH,
+        [
+            Bound(
+                lower_bound=usrp_receiver.get_spec( SpecName.BANDWIDTH_LOWER_BOUND ),
+                upper_bound=usrp_receiver.get_spec( SpecName.BANDWIDTH_UPPER_BOUND )
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.GAIN,
+        [
+            Bound(
+                lower_bound=0,
+                upper_bound=usrp_receiver.get_spec( SpecName.GAIN_UPPER_BOUND )
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.WIRE_FORMAT,
+        [
+            OneOf(
+                usrp_receiver.get_spec( SpecName.WIRE_FORMATS )
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.MASTER_CLOCK_RATE,
+        [
+            Bound(
+                lower_bound=usrp_receiver.get_spec( SpecName.MASTER_CLOCK_RATE_LOWER_BOUND ),
+                upper_bound=usrp_receiver.get_spec( SpecName.MASTER_CLOCK_RATE_UPPER_BOUND )
+            )
+        ]
+    )
+    return capture_template
+
+
+def get_capture_template_swept_center_frequency(
+    usrp_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.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=usrp_receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
+                upper_bound=usrp_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.MAX_FREQUENCY,
+        [
+            Bound(
+                lower_bound=usrp_receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
+                upper_bound=usrp_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.SAMPLE_RATE,
+        [
+            Bound(
+                lower_bound=usrp_receiver.get_spec(SpecName.SAMPLE_RATE_LOWER_BOUND),
+                upper_bound=usrp_receiver.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND)
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.BANDWIDTH,
+        [
+            Bound(
+                lower_bound=usrp_receiver.get_spec(SpecName.BANDWIDTH_LOWER_BOUND),
+                upper_bound=usrp_receiver.get_spec(SpecName.BANDWIDTH_UPPER_BOUND),
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.GAIN,
+        [
+            Bound(
+                lower_bound=0,
+                upper_bound=usrp_receiver.get_spec( SpecName.GAIN_UPPER_BOUND )
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.WIRE_FORMAT,
+        [
+            OneOf(
+                usrp_receiver.get_spec( SpecName.WIRE_FORMATS )
+            )
+        ]
+    )
+    capture_template.add_pconstraint(                                                           
+        PName.MASTER_CLOCK_RATE,
+        [
+            Bound(                                                                              
+                lower_bound=usrp_receiver.get_spec( SpecName.MASTER_CLOCK_RATE_LOWER_BOUND ),   
+                upper_bound=usrp_receiver.get_spec( SpecName.MASTER_CLOCK_RATE_UPPER_BOUND )    
+            )                                                                                   
+        ]                                                                                       
+    )                                                                                           
+    return capture_template

spectre_core-0.0.17/src/spectre_core/receivers/plugins/gr/_usrp.py

@@ -0,0 +1,139 @@
+# 
+# USRP top blocks
+#
+
+from functools import partial
+from dataclasses import dataclass
+import time
+
+from logging import getLogger
+_LOGGER = getLogger(__name__)
+
+from spectre_core.capture_configs import Parameters, PName
+from spectre_core.config import get_batches_dir_path
+from ._base import capture, 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)
+        gain              = parameters.get_parameter_value(PName.GAIN)
+        center_freq       = parameters.get_parameter_value(PName.CENTER_FREQUENCY)
+        master_clock_rate = parameters.get_parameter_value(PName.MASTER_CLOCK_RATE)
+        wire_format       = parameters.get_parameter_value(PName.WIRE_FORMAT)
+        batch_size        = parameters.get_parameter_value(PName.BATCH_SIZE)
+        bandwidth         = parameters.get_parameter_value(PName.BANDWIDTH) 
+
+        # Blocks
+        master_clock_rate = f"master_clock_rate={master_clock_rate}" 
+        self.uhd_usrp_source_0 = uhd.usrp_source(
+            ",".join(("", '', master_clock_rate)),
+            uhd.stream_args(
+                cpu_format="fc32",
+                otw_format=wire_format,
+                args='',
+                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(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))
+
+
+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)
+        min_frequency     = parameters.get_parameter_value(PName.MIN_FREQUENCY)
+        max_frequency     = parameters.get_parameter_value(PName.MAX_FREQUENCY)
+        frequency_step    = parameters.get_parameter_value(PName.FREQUENCY_STEP)
+        samples_per_step  = parameters.get_parameter_value(PName.SAMPLES_PER_STEP)
+        master_clock_rate = parameters.get_parameter_value(PName.MASTER_CLOCK_RATE)
+        master_clock_rate = master_clock_rate = parameters.get_parameter_value(PName.MASTER_CLOCK_RATE)
+        wire_format       = parameters.get_parameter_value(PName.WIRE_FORMAT)
+        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(
+            ",".join(("", '', master_clock_rate)),
+            uhd.stream_args(
+                cpu_format="fc32",
+                otw_format=wire_format,
+                args='',
+                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(min_frequency, 
+                                                           max_frequency, 
+                                                           frequency_step, 
+                                                           sample_rate, 
+                                                           samples_per_step, 
+                                                           'freq')
+       
+        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_batches_dir_path(), 
+                                                                     tag, 
+                                                                     batch_size, 
+                                                                     sample_rate,
+                                                                     True, 
+                                                                     'rx_freq', 
+                                                                     min_frequency)
+
+        # Connections
+        self.msg_connect((self.spectre_sweep_driver_0, 'freq'), (self.uhd_usrp_source_0, '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)

{spectre_core-0.0.15 → spectre_core-0.0.17}/src/spectre_core/wgetting/_callisto.py

@@ -8,7 +8,9 @@ import shutil
 import gzip
 from datetime import datetime
 
-from spectre_core.config import get_spectre_data_dir_path, get_batches_dir_path, TimeFormat
+from spectre_core.config import (
+    get_spectre_data_dir_path, get_batches_dir_path, TimeFormat, trim_spectre_data_dir_path
+)
 
 from enum import Enum
 
@@ -129,30 +131,37 @@ def _get_batch_path(
 
 def _unzip_file_to_batches(
     gz_path: str
-) -> None:
+) -> str:
     """
     Decompress a `.fit.gz` file and save it as a `.fits` batch file.
 
     :param gz_path: Path to the `.fit.gz` file.
+    :return: The file path of the newly created batch file, relative to `SPECTRE_DATA_DIR_PATH`.
     """
     fits_path = _get_batch_path(gz_path)
     with gzip.open(gz_path, "rb") as f_in, open(fits_path, "wb") as f_out:
         shutil.copyfileobj(f_in, f_out)
+        return trim_spectre_data_dir_path(f_out.name)
 
 
 def _unzip_to_batches(
     tmp_dir: str
-) -> None:
+) -> list[str]:
     """
     Decompress all `.gz` files in a temporary directory and save them as `spectre`
     batch files.
 
     :param tmp_dir: Path to the temporary directory containing `.gz` files.
+    :return: A list of file names of all newly created batch files, relative to `SPECTRE_DATA_DIR_PATH`.
     """
+    batch_file_names = []
     for entry in os.scandir(tmp_dir):
         if entry.is_file() and entry.name.endswith(".gz"):
-            _unzip_file_to_batches(entry.path)
+            batch_file_names.append( _unzip_file_to_batches(entry.path) )
             os.remove(entry.path)
+    shutil.rmtree(tmp_dir)
+    return batch_file_names
+            
 
 
 def _wget_callisto_data(
@@ -186,7 +195,7 @@ def download_callisto_data(
     year: int, 
     month: int, 
     day: int
-) -> None:
+) -> list[str]:
     """
     Download and decompress e-Callisto FITS files, saving them as `spectre` batch files.
 
@@ -194,6 +203,7 @@ def download_callisto_data(
     :param year: Year of the observation.
     :param month: Month of the observation.
     :param day: Day of the observation.
+    :return: A list of file names of all newly created batch files, relative to `SPECTRE_DATA_DIR_PATH`.
     """
     tmp_dir = os.path.join(get_spectre_data_dir_path(), "tmp")
     # if there are any residual files in the temporary directory, remove them.
@@ -202,5 +212,4 @@ def download_callisto_data(
     os.makedirs(tmp_dir, exist_ok=True)
     
     _wget_callisto_data(instrument_code.value, year, month, day, tmp_dir)
-    _unzip_to_batches(tmp_dir)
-    shutil.rmtree(tmp_dir)
+    return sorted( _unzip_to_batches(tmp_dir) )

{spectre_core-0.0.15 → spectre_core-0.0.17}/src/spectre_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: spectre-core
-Version: 0.0.15
+Version: 0.0.17
 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.15/src/spectre_core/receivers/plugins/_b200mini.py

@@ -1,72 +0,0 @@
-# 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_capture_template_fixed_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"
-
-
-@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  )
-
-   
-    def _add_capture_methods(
-        self
-    ) -> None:
-       self.add_capture_method(Mode.FIXED_CENTER_FREQUENCY,
-                               CaptureMethod.fixed_center_frequency)
-
-   
-    def _add_capture_templates(
-        self
-    ) -> None:
-        self.add_capture_template(Mode.FIXED_CENTER_FREQUENCY,
-                                  get_capture_template_fixed_center_frequency(self))
-
-
-    def _add_pvalidators(
-        self
-    ) -> None:
-        self.add_pvalidator(Mode.FIXED_CENTER_FREQUENCY,
-                            get_pvalidator_fixed_center_frequency(self))
-
-    
- 
-
-
-
-
-
-
-
-
-
-
-
-
-
-

spectre_core-0.0.15/src/spectre_core/receivers/plugins/_usrp.py

@@ -1,70 +0,0 @@
-# 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(
-    usrp_receiver: BaseReceiver 
-) -> Callable[[Parameters], None]:
-    def pvalidator(parameters: Parameters) -> None:
-        validate_fixed_center_frequency(parameters)
-    return pvalidator
-
-
-def get_capture_template_fixed_center_frequency(
-    usrp_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.NORMALISED_GAIN) )
-
-    capture_template.set_defaults(
-        (PName.BATCH_SIZE,            3.0),
-        (PName.CENTER_FREQUENCY,      95800000),
-        (PName.SAMPLE_RATE,           1000000),
-        (PName.BANDWIDTH,             1000000),
-        (PName.WINDOW_HOP,            512),
-        (PName.WINDOW_SIZE,           1024),
-        (PName.WINDOW_TYPE,           "blackman"),
-        (PName.NORMALISED_GAIN,       0.3),
-    )   
-
-    capture_template.add_pconstraint(
-        PName.CENTER_FREQUENCY,
-        [
-            Bound(
-                lower_bound=usrp_receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
-                upper_bound=usrp_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
-            )
-        ]
-    )
-    capture_template.add_pconstraint(
-        PName.SAMPLE_RATE,
-        [
-            Bound(
-                lower_bound=usrp_receiver.get_spec(SpecName.SAMPLE_RATE_LOWER_BOUND),
-                upper_bound=usrp_receiver.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND)
-            )
-        ]
-    )
-    capture_template.add_pconstraint(
-        PName.BANDWIDTH,
-        [
-            Bound(
-                lower_bound=usrp_receiver.get_spec( SpecName.BANDWIDTH_LOWER_BOUND ),
-                upper_bound=usrp_receiver.get_spec( SpecName.BANDWIDTH_UPPER_BOUND )
-            )
-        ]
-    )
-    return capture_template

spectre_core-0.0.15/src/spectre_core/receivers/plugins/gr/_usrp.py

@@ -1,62 +0,0 @@
-# 
-# USRP top blocks
-#
-
-from functools import partial
-from dataclasses import dataclass
-import time
-
-from spectre_core.capture_configs import Parameters, PName
-from spectre_core.config import get_batches_dir_path
-from ._base import capture, 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
-
-        # Variables
-        sample_rate      = parameters.get_parameter_value(PName.SAMPLE_RATE)
-        normalised_gain  = parameters.get_parameter_value(PName.NORMALISED_GAIN)
-        center_freq      = parameters.get_parameter_value(PName.CENTER_FREQUENCY)
-        batch_size       = parameters.get_parameter_value(PName.BATCH_SIZE)
-        bandwidth        = parameters.get_parameter_value(PName.BANDWIDTH) 
-
-        # Blocks
-        self.uhd_usrp_source_0 = uhd.usrp_source(
-            ",".join(("", '')),
-            uhd.stream_args(
-                cpu_format="fc32",
-                args='',
-                channels=list(range(0,1)),
-            ),
-        )
-        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_normalized_gain(normalised_gain, 0)
-        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_batches_dir_path(), 
-                                                                     tag, 
-                                                                     batch_size, 
-                                                                     sample_rate, False, 
-                                                                     'freq', 
-                                                                     0)
-
-
-        # Connections
-        self.connect((self.uhd_usrp_source_0, 0), (self.spectre_batched_file_sink_0, 0))
-
-
-@dataclass(frozen=True)
-class CaptureMethod:
-    fixed_center_frequency = partial(capture, top_block_cls=_fixed_center_frequency)