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

spectre_core/receivers/_base.py

@@ -0,0 +1,352 @@
+# 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.exceptions import ModeNotFoundError
+from ._spec_names import SpecNames
+from spectre_core.capture_configs import (
+    CaptureTemplate, CaptureModes, Parameters, Bound, PValidators, PNames,
+    get_base_capture_template, get_base_ptemplate, OneOf, CaptureConfig
+)
+
+class BaseReceiver(ABC):
+    def __init__(self, 
+                 name: str, 
+                 mode: Optional[str] = None):
+        self._name = name
+
+        self._specs: dict[str, Number | list[Number]] = {}
+        self._add_specs()
+        
+        self._capture_methods: dict[str, Callable] = {}
+        self._add_capture_methods()
+    
+        self._pvalidators: dict[str, Callable] = {}
+        self._add_pvalidators()
+
+        self._capture_templates: dict[str, CaptureTemplate] = {}
+        self._add_capture_templates()
+
+        self.mode = mode
+
+
+    @abstractmethod
+    def _add_specs(self) -> None:
+        pass
+    
+
+    @abstractmethod
+    def _add_capture_methods(self) -> None:
+        pass
+
+
+    @abstractmethod
+    def _add_pvalidators(self) -> None:
+        pass
+
+
+    @abstractmethod
+    def _add_capture_templates(self) -> None:
+        pass
+
+    
+    @property
+    def name(self) -> str:
+        return self._name
+    
+
+    @property
+    def capture_methods(self) -> dict[str, Callable]:
+        return self._capture_methods
+    
+
+    @property
+    def pvalidators(self) -> dict[str, Callable]:
+        return self._pvalidators
+
+
+    @property
+    def capture_templates(self) -> dict[str, CaptureTemplate]:
+        return self._capture_templates
+
+
+    @property
+    def specs(self) -> dict[str, Number]:
+        return self._specs
+
+
+    @property
+    def modes(self) -> list[str]:
+        capture_method_modes    = list(self.capture_methods.keys())
+        pvalidator_modes        = list(self.pvalidators.keys())
+        capture_template_modes  = list(self.capture_templates.keys())
+
+        if capture_method_modes == pvalidator_modes == capture_template_modes:
+            return capture_method_modes
+        else:
+            raise ValueError(f"Mode mismatch for the receiver {self.name}.")
+
+
+    @property
+    def mode(self) -> str:
+        return self._mode
+    
+
+    @mode.setter
+    def mode(self, value: Optional[str]) -> None:
+        if (value is not None) and value not in self.modes:
+            raise ModeNotFoundError((f"{value} is not a defined mode for the receiver {self.name}. "
+                                     f"Expected one of {self.modes}"))
+        self._mode = value
+
+
+    @property
+    def capture_method(self) -> Callable:
+        return self.capture_methods[self.mode]
+
+
+    @property
+    def pvalidator(self) -> Callable:
+        return self.pvalidators[self.mode]
+
+
+    @property
+    def capture_template(self) -> CaptureTemplate:
+        return self._capture_templates[self.mode]
+
+
+    def add_capture_method(self,
+                           mode: str,
+                           capture_method: Callable) -> None:
+        self._capture_methods[mode] = capture_method
+
+
+    def add_pvalidator(self,
+                      mode: str,
+                      pvalidator: Callable) -> None:
+        self._pvalidators[mode] = pvalidator
+
+
+    def add_capture_template(self,
+                             mode: str,
+                             capture_template: CaptureTemplate) -> CaptureTemplate:
+        self._capture_templates[mode] = capture_template
+
+
+    def add_spec(self,
+                 name: str,
+                 value: Number) -> None:
+        self.specs[name] = value
+
+
+    def get_spec(self, 
+                 spec_name: str) -> Number | list[Number]:
+        if spec_name not in self.specs:
+            raise KeyError(f"Spec not found with name '{spec_name}' "
+                           f"for the receiver '{self.name}'")
+        return self.specs[spec_name]
+
+
+    def start_capture(self, 
+                      tag: str) -> None:
+        self.capture_method( tag, self.load_parameters(tag) )
+
+
+    def save_parameters(self,
+                        tag: str,
+                        parameters: Parameters,
+                        force: bool = False) -> None:
+        
+        parameters = self.capture_template.apply_template(parameters)
+        self.pvalidator(parameters)
+
+        capture_config = CaptureConfig(tag)
+        capture_config.save_parameters(self.name,
+                                       self.mode,
+                                       parameters,
+                                       force=force)
+
+    def load_parameters(self,
+                        tag: str) -> Parameters:
+        capture_config = CaptureConfig(tag)
+
+        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

spectre_core/receivers/{factory.py → _factory.py}

@@ -4,9 +4,9 @@
 
 from typing import Optional
 
-from spectre_core.receivers.receiver_register import receivers
-from spectre_core.receivers.base import BaseReceiver
 from spectre_core.exceptions import ReceiverNotFoundError
+from ._register import receivers
+from ._base import BaseReceiver
 
 # used to fetch an instance of the receiver class
 def get_receiver(receiver_name: str, mode: Optional[str] = None) -> BaseReceiver:

spectre_core/receivers/_spec_names.py

@@ -0,0 +1,20 @@
+# 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
+
+@dataclass(frozen=True)
+class SpecNames:
+    """A centralised store of specification names"""
+    FREQUENCY_LOWER_BOUND   : str = "frequency_lower_bound"
+    FREQUENCY_UPPER_BOUND   : str = "frequency_upper_bound"
+    SAMPLE_RATE_LOWER_BOUND : str = "sample_rate_lower_bound"
+    SAMPLE_RATE_UPPER_BOUND : str = "sample_rate_upper_bound"
+    BANDWIDTH_LOWER_BOUND   : str = "bandwidth_lower_bound"
+    BANDWIDTH_UPPER_BOUND   : str = "bandwidth_upper_bound"
+    BANDWIDTH_OPTIONS       : str = "bandwidth_options"
+    DEFINED_BANDWIDTHS      : str = "defined_bandwidths"
+    IF_GAIN_UPPER_BOUND     : str = "if_gain_upper_bound"
+    RF_GAIN_UPPER_BOUND     : str = "rf_gain_upper_bound"
+    API_RETUNING_LATENCY    : str = "api_retuning_latency"

spectre_core/receivers/gr/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later

spectre_core/receivers/gr/_base.py

@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: © 2024 Jimmy Fitzpatrick <jcfitzpatrick12@gmail.com>
+# This file is part of SPECTRE
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+import sys
+import signal
+
+from gnuradio import gr
+from gnuradio import spectre
+
+from spectre_core.capture_configs import Parameters, PNames
+from spectre_core.config import get_chunks_dir_path
+
+from spectre_core.capture_configs import Parameters
+
+
+def capture(tag: str,
+            parameters: Parameters, 
+            top_block_cls: gr.top_block,
+            max_noutput_items: int = 10000000):
+    tb: gr.top_block = top_block_cls(tag,
+                                     parameters)
+
+    def sig_handler(sig=None, frame=None):
+        tb.stop()
+        tb.wait()
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, sig_handler)
+    signal.signal(signal.SIGTERM, sig_handler)
+
+    tb.start(max_noutput_items)
+    tb.wait()

spectre_core/receivers/gr/_rsp1a.py

@@ -0,0 +1,158 @@
+#!/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
+
+#
+# Test 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 _fixed_center_frequency(gr.top_block):
+    def __init__(self, 
+                 tag: str,
+                 parameters: Parameters):
+        gr.top_block.__init__(self, "fixed-center-frequency", 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)
+        is_sweeping = False
+
+        ##################################################
+        # Blocks
+        ##################################################
+        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_chunks_dir_path(), 
+                                                                     tag, 
+                                                                     batch_size, 
+                                                                     sample_rate)
+        self.sdrplay3_rsp1a_0 = sdrplay3.rsp1a(
+            '',
+            stream_args=sdrplay3.stream_args(
+                output_type='fc32',
+                channels_size=1
+            ),
+        )
+        self.sdrplay3_rsp1a_0.set_sample_rate(sample_rate)
+        self.sdrplay3_rsp1a_0.set_center_freq(center_freq)
+        self.sdrplay3_rsp1a_0.set_bandwidth(bandwidth)
+        self.sdrplay3_rsp1a_0.set_gain_mode(False)
+        self.sdrplay3_rsp1a_0.set_gain(if_gain, 'IF')
+        self.sdrplay3_rsp1a_0.set_gain(rf_gain, 'RF')
+        self.sdrplay3_rsp1a_0.set_freq_corr(0)
+        self.sdrplay3_rsp1a_0.set_dc_offset_mode(False)
+        self.sdrplay3_rsp1a_0.set_iq_balance_mode(False)
+        self.sdrplay3_rsp1a_0.set_agc_setpoint(-30)
+        self.sdrplay3_rsp1a_0.set_rf_notch_filter(False)
+        self.sdrplay3_rsp1a_0.set_dab_notch_filter(False)
+        self.sdrplay3_rsp1a_0.set_biasT(False)
+        self.sdrplay3_rsp1a_0.set_debug_mode(False)
+        self.sdrplay3_rsp1a_0.set_sample_sequence_gaps_check(False)
+        self.sdrplay3_rsp1a_0.set_show_gain_changes(False)
+
+
+        ##################################################
+        # Connections
+        ##################################################
+        self.connect((self.sdrplay3_rsp1a_0, 0), (self.spectre_batched_file_sink_0, 0))
+
+
+class _swept_center_frequency(gr.top_block):
+    def __init__(self, 
+                 tag: str,
+                 parameters: Parameters):
+        gr.top_block.__init__(self, "sweep", 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_rsp1a_0 = sdrplay3.rsp1a(
+            '',
+            stream_args=sdrplay3.stream_args(
+                output_type='fc32',
+                channels_size=1
+            ),
+        )
+        self.sdrplay3_rsp1a_0.set_sample_rate(sample_rate, True)
+        self.sdrplay3_rsp1a_0.set_center_freq(min_frequency, True)
+        self.sdrplay3_rsp1a_0.set_bandwidth(bandwidth)
+        self.sdrplay3_rsp1a_0.set_gain_mode(False)
+        self.sdrplay3_rsp1a_0.set_gain(if_gain, 'IF', True)
+        self.sdrplay3_rsp1a_0.set_gain(rf_gain, 'RF', True)
+        self.sdrplay3_rsp1a_0.set_freq_corr(0)
+        self.sdrplay3_rsp1a_0.set_dc_offset_mode(False)
+        self.sdrplay3_rsp1a_0.set_iq_balance_mode(False)
+        self.sdrplay3_rsp1a_0.set_agc_setpoint(-30)
+        self.sdrplay3_rsp1a_0.set_rf_notch_filter(False)
+        self.sdrplay3_rsp1a_0.set_dab_notch_filter(False)
+        self.sdrplay3_rsp1a_0.set_biasT(False)
+        self.sdrplay3_rsp1a_0.set_stream_tags(True)
+        self.sdrplay3_rsp1a_0.set_debug_mode(False)
+        self.sdrplay3_rsp1a_0.set_sample_sequence_gaps_check(False)
+        self.sdrplay3_rsp1a_0.set_show_gain_changes(False)
+
+
+        ##################################################
+        # Connections
+        ##################################################
+        self.msg_connect((self.spectre_sweep_driver_0, 'freq'), (self.sdrplay3_rsp1a_0, 'freq'))
+        self.connect((self.sdrplay3_rsp1a_0, 0), (self.spectre_batched_file_sink_0, 0))
+        self.connect((self.sdrplay3_rsp1a_0, 0), (self.spectre_sweep_driver_0, 0))
+
+
+@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)