spectre-core 0.0.13__py3-none-any.whl → 0.0.15__py3-none-any.whl

spectre_core/capture_configs/_pnames.py

@@ -46,4 +46,5 @@ class PName(Enum):
     OBJECT               = "object"
     OBS_LAT              = "obs_lat"
     OBS_LON              = "obs_lon"
-    OBS_ALT              = "obs_alt"
+    OBS_ALT              = "obs_alt"
+    NORMALISED_GAIN      = "normalised_gain"

spectre_core/capture_configs/_ptemplates.py

@@ -7,7 +7,7 @@ from textwrap import dedent
 from copy import deepcopy
 
 from ._pnames import PName
-from ._pconstraints import BasePConstraint, EnforceSign, PowerOfTwo
+from ._pconstraints import BasePConstraint, EnforceSign, PowerOfTwo, Bound
 from ._parameters import Parameter
     
 # value type
@@ -300,6 +300,14 @@ _base_ptemplates: dict[PName, PTemplate] = {
                                             pconstraints=[
                                                 EnforceSign.non_positive
                                                 ]),
+    PName.NORMALISED_GAIN:                  PTemplate(PName.NORMALISED_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)
+                                                ]),
     PName.EVENT_HANDLER_KEY:      PTemplate(PName.EVENT_HANDLER_KEY,      
                                             str,
                                             help = """
@@ -490,4 +498,4 @@ def get_base_ptemplate(
     # A deep copy is required as each receiver instance may mutate the original instance
     # according to its particular use case. Copying preserves the original instance,
     # enabling reuse.
-    return deepcopy( _base_ptemplates[pname] )
+    return deepcopy( _base_ptemplates[pname] )

spectre_core/receivers/__init__.py

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

spectre_core/receivers/_base.py

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

spectre_core/receivers/_factory.py

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

spectre_core/receivers/_spec_names.py

@@ -18,6 +18,8 @@ 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 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"
@@ -28,4 +30,4 @@ class SpecName(Enum):
     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"
+    API_RETUNING_LATENCY     = "api_retuning_latency"

spectre_core/receivers/plugins/_b200mini.py

@@ -0,0 +1,72 @@
+# 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/receivers/plugins/_receiver_names.py

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

spectre_core/receivers/plugins/_rsp1a.py

@@ -6,8 +6,12 @@ from dataclasses import dataclass
 
 from ._receiver_names import ReceiverName
 from .gr._rsp1a import CaptureMethod
+from ._sdrplay_receiver import (
+    get_pvalidator_fixed_center_frequency, get_pvalidator_swept_center_frequency,
+    get_capture_template_fixed_center_frequency, get_capture_template_swept_center_frequency
+)
 from .._spec_names import SpecName
-from ._sdrplay_receiver import SDRPlayReceiver
+from .._base import BaseReceiver
 from .._register import register_receiver
 
 @dataclass(frozen=True)
@@ -18,9 +22,11 @@ class Mode:
 
 
 @register_receiver(ReceiverName.RSP1A)
-class RSP1A(SDRPlayReceiver):
+class RSP1A(BaseReceiver):
     """Receiver implementation for the SDRPlay RSP1A (https://www.sdrplay.com/rsp1a/)"""
-    def _add_specs(self) -> None:
+    def _add_specs(
+            self
+    ) -> None:
         self.add_spec( SpecName.SAMPLE_RATE_LOWER_BOUND, 200e3     )
         self.add_spec( SpecName.SAMPLE_RATE_UPPER_BOUND, 10e6      )
         self.add_spec( SpecName.FREQUENCY_LOWER_BOUND  , 1e3       )
@@ -45,15 +51,15 @@ class RSP1A(SDRPlayReceiver):
         self
     ) -> None:
         self.add_capture_template(Mode.FIXED_CENTER_FREQUENCY,
-                                  self._get_capture_template_fixed_center_frequency())
+                                  get_capture_template_fixed_center_frequency(self))
         self.add_capture_template(Mode.SWEPT_CENTER_FREQUENCY,
-                                  self._get_capture_template_swept_center_frequency())
+                                  get_capture_template_swept_center_frequency(self))
         
     
     def _add_pvalidators(
         self
     ) -> None:
         self.add_pvalidator(Mode.FIXED_CENTER_FREQUENCY,
-                            self._get_pvalidator_fixed_center_frequency())
+                            get_pvalidator_fixed_center_frequency(self))
         self.add_pvalidator(Mode.SWEPT_CENTER_FREQUENCY,
-                            self._get_pvalidator_swept_center_frequency())
+                            get_pvalidator_swept_center_frequency(self))

spectre_core/receivers/plugins/_rspduo.py

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

spectre_core/receivers/plugins/_sdrplay_receiver.py

@@ -12,179 +12,163 @@ from spectre_core.capture_configs import (
 from .._base import BaseReceiver
 from .._spec_names import SpecName
 
-class SDRPlayReceiver(BaseReceiver):
-    """An abstract base class for SDRPlay receivers.
-    
-    Includes ready-to-go pvalidators and capture templates which are shared by all subclasses. 
-    Each subclasses must define the following hardware specifications:
-    
-    .. code-block:: python
-        def _add_specs(self) -> None:
-            self.add_spec( SpecName.SAMPLE_RATE_LOWER_BOUND, <TBD> )
-            self.add_spec( SpecName.SAMPLE_RATE_UPPER_BOUND, <TBD> )
-            self.add_spec( SpecName.FREQUENCY_LOWER_BOUND  , <TBD> )
-            self.add_spec( SpecName.FREQUENCY_UPPER_BOUND  , <TBD> )
-            self.add_spec( SpecName.IF_GAIN_UPPER_BOUND    , <TBD> )
-            self.add_spec( SpecName.RF_GAIN_UPPER_BOUND    , <TBD> )
-            self.add_spec( SpecName.API_RETUNING_LATENCY   , <TBD> )
-            self.add_spec( SpecName.BANDWIDTH_OPTIONS      , <TBD> )
-    """  
-    def _get_pvalidator_fixed_center_frequency(
-        self
-    ) -> Callable[[Parameters], None]:
-        def pvalidator(parameters: Parameters):
-            validate_fixed_center_frequency(parameters)
-        return pvalidator
 
+def get_pvalidator_fixed_center_frequency(
+    sdrplay_receiver: BaseReceiver 
+) -> Callable[[Parameters], None]:
+    def pvalidator(parameters: Parameters) -> None:
+        validate_fixed_center_frequency(parameters)
+    return pvalidator
 
-    def _get_pvalidator_swept_center_frequency(
-        self
-    ) -> Callable[[Parameters], None]:
-        def pvalidator(parameters: Parameters):
-            validate_swept_center_frequency(parameters,
-                                            self.get_spec(SpecName.API_RETUNING_LATENCY))
-        return pvalidator
 
+def get_pvalidator_swept_center_frequency(
+    sdrplay_receiver: BaseReceiver 
+) -> Callable[[Parameters], None]:
+    def pvalidator(parameters: Parameters) -> None:
+        validate_swept_center_frequency(parameters,
+                                        sdrplay_receiver.get_spec(SpecName.API_RETUNING_LATENCY))
+    return pvalidator
 
-    def _get_capture_template_fixed_center_frequency(
-        self
-    ) -> CaptureTemplate:
-        
-        capture_template = get_base_capture_template( CaptureMode.FIXED_CENTER_FREQUENCY )
-        capture_template.add_ptemplate( get_base_ptemplate(PName.BANDWIDTH) )
-        capture_template.add_ptemplate( get_base_ptemplate(PName.IF_GAIN) )
-        capture_template.add_ptemplate( get_base_ptemplate(PName.RF_GAIN) )
 
-        capture_template.set_defaults(
-            (PName.BATCH_SIZE,            3.0),
-            (PName.CENTER_FREQUENCY,      95800000),
-            (PName.SAMPLE_RATE,           600000),
-            (PName.BANDWIDTH,             600000),
-            (PName.WINDOW_HOP,            512),
-            (PName.WINDOW_SIZE,           1024),
-            (PName.WINDOW_TYPE,           "blackman"),
-            (PName.RF_GAIN,               -30),
-            (PName.IF_GAIN,               -30)
-        )   
+def get_capture_template_fixed_center_frequency(
+    sdrplay_receiver: BaseReceiver
+) -> CaptureTemplate:
+    
+    capture_template = get_base_capture_template( CaptureMode.FIXED_CENTER_FREQUENCY )
+    capture_template.add_ptemplate( get_base_ptemplate(PName.BANDWIDTH) )
+    capture_template.add_ptemplate( get_base_ptemplate(PName.IF_GAIN) )
+    capture_template.add_ptemplate( get_base_ptemplate(PName.RF_GAIN) )
+
+    capture_template.set_defaults(
+        (PName.BATCH_SIZE,            3.0),
+        (PName.CENTER_FREQUENCY,      95800000),
+        (PName.SAMPLE_RATE,           600000),
+        (PName.BANDWIDTH,             600000),
+        (PName.WINDOW_HOP,            512),
+        (PName.WINDOW_SIZE,           1024),
+        (PName.WINDOW_TYPE,           "blackman"),
+        (PName.RF_GAIN,               -30),
+        (PName.IF_GAIN,               -30)
+    )   
 
-        capture_template.add_pconstraint(
-            PName.CENTER_FREQUENCY,
-            [
-                Bound(
-                    lower_bound=self.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
-                    upper_bound=self.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
-                )
-            ]
-        )
-        capture_template.add_pconstraint(
-            PName.SAMPLE_RATE,
-            [
-                Bound(
-                    lower_bound=self.get_spec(SpecName.SAMPLE_RATE_LOWER_BOUND),
-                    upper_bound=self.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND)
-                )
-            ]
-        )
-        capture_template.add_pconstraint(
-            PName.BANDWIDTH,
-            [
-                OneOf(
-                    self.get_spec( SpecName.BANDWIDTH_OPTIONS )
-                )
-            ]
-        )
-        capture_template.add_pconstraint(
-            PName.IF_GAIN,
-            [
-                Bound(
-                    upper_bound=self.get_spec(SpecName.IF_GAIN_UPPER_BOUND)
-                )
-            ]
-        )
-        capture_template.add_pconstraint(
-            PName.RF_GAIN,
-            [
-                Bound(
-                    upper_bound=self.get_spec(SpecName.RF_GAIN_UPPER_BOUND)
-                )
-            ]
-        )
-        return capture_template
+    capture_template.add_pconstraint(
+        PName.CENTER_FREQUENCY,
+        [
+            Bound(
+                lower_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
+                upper_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.SAMPLE_RATE,
+        [
+            Bound(
+                lower_bound=sdrplay_receiver.get_spec(SpecName.SAMPLE_RATE_LOWER_BOUND),
+                upper_bound=sdrplay_receiver.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND)
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.BANDWIDTH,
+        [
+            OneOf(
+                sdrplay_receiver.get_spec( SpecName.BANDWIDTH_OPTIONS )
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.IF_GAIN,
+        [
+            Bound(
+                upper_bound=sdrplay_receiver.get_spec(SpecName.IF_GAIN_UPPER_BOUND)
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.RF_GAIN,
+        [
+            Bound(
+                upper_bound=sdrplay_receiver.get_spec(SpecName.RF_GAIN_UPPER_BOUND)
+            )
+        ]
+    )
+    return capture_template
 
 
-    def _get_capture_template_swept_center_frequency(
-        self
-    ) -> CaptureTemplate:
+def get_capture_template_swept_center_frequency(
+    sdrplay_receiver: BaseReceiver
+) -> CaptureTemplate:
 
-        capture_template = get_base_capture_template( CaptureMode.SWEPT_CENTER_FREQUENCY )
-        capture_template.add_ptemplate( get_base_ptemplate(PName.BANDWIDTH) )
-        capture_template.add_ptemplate( get_base_ptemplate(PName.IF_GAIN) )
-        capture_template.add_ptemplate( get_base_ptemplate(PName.RF_GAIN) )
+    capture_template = get_base_capture_template( CaptureMode.SWEPT_CENTER_FREQUENCY )
+    capture_template.add_ptemplate( get_base_ptemplate(PName.BANDWIDTH) )
+    capture_template.add_ptemplate( get_base_ptemplate(PName.IF_GAIN) )
+    capture_template.add_ptemplate( get_base_ptemplate(PName.RF_GAIN) )
 
-        capture_template.set_defaults(
-            (PName.BATCH_SIZE,            4.0),
-            (PName.MIN_FREQUENCY,         95000000),
-            (PName.MAX_FREQUENCY,         100000000),
-            (PName.SAMPLES_PER_STEP,      80000),
-            (PName.FREQUENCY_STEP,        1536000),
-            (PName.SAMPLE_RATE,           1536000),
-            (PName.BANDWIDTH,             1536000),
-            (PName.WINDOW_HOP,            512),
-            (PName.WINDOW_SIZE,           1024),
-            (PName.WINDOW_TYPE,           "blackman"),
-            (PName.RF_GAIN,               -30),
-            (PName.IF_GAIN,               -30)
-        )   
+    capture_template.set_defaults(
+        (PName.BATCH_SIZE,            4.0),
+        (PName.MIN_FREQUENCY,         95000000),
+        (PName.MAX_FREQUENCY,         100000000),
+        (PName.SAMPLES_PER_STEP,      80000),
+        (PName.FREQUENCY_STEP,        1536000),
+        (PName.SAMPLE_RATE,           1536000),
+        (PName.BANDWIDTH,             1536000),
+        (PName.WINDOW_HOP,            512),
+        (PName.WINDOW_SIZE,           1024),
+        (PName.WINDOW_TYPE,           "blackman"),
+        (PName.RF_GAIN,               -30),
+        (PName.IF_GAIN,               -30)
+    )   
 
-        capture_template.add_pconstraint(
-            PName.MIN_FREQUENCY,
-            [
-                Bound(
-                    lower_bound=self.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
-                    upper_bound=self.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
-                )
-            ]
-        )
-        capture_template.add_pconstraint(
-            PName.MAX_FREQUENCY,
-            [
-                Bound(
-                    lower_bound=self.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
-                    upper_bound=self.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
-                )
-            ]
-        )
-        capture_template.add_pconstraint(
-            PName.SAMPLE_RATE,
-            [
-                Bound(
-                    lower_bound=self.get_spec(SpecName.SAMPLE_RATE_LOWER_BOUND),
-                    upper_bound=self.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND)
-                )
-            ]
-        )
-        capture_template.add_pconstraint(
-            PName.BANDWIDTH,
-            [
-                OneOf(
-                    self.get_spec( SpecName.BANDWIDTH_OPTIONS )
-                )
-            ]
-        )
-        capture_template.add_pconstraint(
-            PName.IF_GAIN,
-            [
-                Bound(
-                    upper_bound=self.get_spec(SpecName.IF_GAIN_UPPER_BOUND)
-                )
-            ]
-        )
-        capture_template.add_pconstraint(
-            PName.RF_GAIN,
-            [
-                Bound(
-                    upper_bound=self.get_spec(SpecName.RF_GAIN_UPPER_BOUND)
-                )
-            ]
-        )
-        return capture_template
+    capture_template.add_pconstraint(
+        PName.MIN_FREQUENCY,
+        [
+            Bound(
+                lower_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
+                upper_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.MAX_FREQUENCY,
+        [
+            Bound(
+                lower_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_LOWER_BOUND),
+                upper_bound=sdrplay_receiver.get_spec(SpecName.FREQUENCY_UPPER_BOUND)
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.SAMPLE_RATE,
+        [
+            Bound(
+                lower_bound=sdrplay_receiver.get_spec(SpecName.SAMPLE_RATE_LOWER_BOUND),
+                upper_bound=sdrplay_receiver.get_spec(SpecName.SAMPLE_RATE_UPPER_BOUND)
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.BANDWIDTH,
+        [
+            OneOf(
+                sdrplay_receiver.get_spec( SpecName.BANDWIDTH_OPTIONS )
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.IF_GAIN,
+        [
+            Bound(
+                upper_bound=sdrplay_receiver.get_spec(SpecName.IF_GAIN_UPPER_BOUND)
+            )
+        ]
+    )
+    capture_template.add_pconstraint(
+        PName.RF_GAIN,
+        [
+            Bound(
+                upper_bound=sdrplay_receiver.get_spec(SpecName.RF_GAIN_UPPER_BOUND)
+            )
+        ]
+    )
+    return capture_template

spectre_core/receivers/plugins/_usrp.py

@@ -0,0 +1,70 @@
+# 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/receivers/plugins/gr/_rsp1a.py

@@ -1,17 +1,3 @@
-#!/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
-
 #
 # RSP1A receiver top blocks
 #
@@ -145,4 +131,4 @@ class _swept_center_frequency(spectre_top_block):
 @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)
+    swept_center_frequency  = partial(capture, top_block_cls=_swept_center_frequency, max_noutput_items=1024)

spectre_core/receivers/plugins/gr/_usrp.py

@@ -0,0 +1,62 @@
+# 
+# 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)

spectre_core/spectrograms/_array_operations.py

@@ -186,5 +186,5 @@ def time_elapsed(
     datetimes: npt.NDArray[np.datetime64]
 ) -> npt.NDArray[np.float32]:
     """Convert an array of datetimes to seconds elapsed."""
-    return (datetimes - datetimes[0]).astype('timedelta64[us]').astype(np.float32)
+    return (datetimes - datetimes[0]).astype('timedelta64[us]') / np.timedelta64(1, 's')
 

{spectre_core-0.0.13.dist-info → spectre_core-0.0.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: spectre-core
-Version: 0.0.13
+Version: 0.0.15
 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.13.dist-info → spectre_core-0.0.15.dist-info}/RECORD

@@ -17,8 +17,8 @@ spectre_core/capture_configs/_capture_modes.py,sha256=uFBMwHYJCDqqQfYJvAUKzKXTmS
 spectre_core/capture_configs/_capture_templates.py,sha256=nSAxhOh1DeBzYY16evgOTkDuxRugGG5weJsICUouLPQ,10353
 spectre_core/capture_configs/_parameters.py,sha256=9KoNuwzDKtnyeju53fkImi1SeUjDn89cNwDL8zxX-YU,5563
 spectre_core/capture_configs/_pconstraints.py,sha256=bnl1m6M9iyo5KOsPKT_arwrrAZbxRKXVwTHQACzvs2g,5227
-spectre_core/capture_configs/_pnames.py,sha256=05mrrGfYHudaD2dYyukijbW-YtUnifZRn05xcBGv-fI,1852
-spectre_core/capture_configs/_ptemplates.py,sha256=p4lOi6W5B9gWv0d6ryNK9f_zxLHsj5PWW8Lmdco9ofg,24508
+spectre_core/capture_configs/_pnames.py,sha256=xqBbaR6Hd6NdzGOZU7DDlKYol02HqW8RAjbnhrXIgAk,1898
+spectre_core/capture_configs/_ptemplates.py,sha256=MVx_A2wy8b9zyiAHb2F5LLuYYarkTdv9r-dvMn2C_Fw,25068
 spectre_core/capture_configs/_pvalidators.py,sha256=0W-OMDY1lifRPonwgEAwoMYkA0PWbqlK5nE0zsYVcTw,9596
 spectre_core/config/__init__.py,sha256=CVddibAIWU4cNerXCxfeUn_cvnWWDBm4pWeUifqM6Ko,502
 spectre_core/config/_paths.py,sha256=Qn0KVe27P6Bo65MfHe4LpH_ryPvLgbTxKjc4MTw1BB8,4090
@@ -45,31 +45,34 @@ spectre_core/post_processing/_register.py,sha256=chK5bCQ-0bpMhplbKT3cdS5anLhIA5T
 spectre_core/post_processing/plugins/_event_handler_keys.py,sha256=LPA71kKsaLPyT2vpPJwm88-RWfX-AU0_T9H8-GdjINQ,614
 spectre_core/post_processing/plugins/_fixed_center_frequency.py,sha256=24LB3iDMa2KvgM7jyRnEr7Y45VK46bUT7Nj8bXGiGwc,5231
 spectre_core/post_processing/plugins/_swept_center_frequency.py,sha256=fzPAZ4zK1DRAHushUB-JS2IgKAuXyP4hdBLZJX6jBmo,20971
-spectre_core/receivers/__init__.py,sha256=A-BuCrnIRdRZe6HGXlLzKHGm8Zjfb8I9dzslBTeUHn4,660
-spectre_core/receivers/_base.py,sha256=E2aSYmveSMYxLrm5Uv235KlsehOyq82DvSolCIF6xug,10096
-spectre_core/receivers/_factory.py,sha256=5NdwZzBmUEHZQHltggDmuEoi-DRS6fHPSBzxvmq50zs,1843
+spectre_core/receivers/__init__.py,sha256=uT3XNn12gSfK_M_GE__sK-TRWra92qkttnUJ-_6uViE,714
+spectre_core/receivers/_base.py,sha256=6uilcdMRq0lw4s3IuyWVT_sUJ7fS9va1qUOHuqW9vg4,8993
+spectre_core/receivers/_factory.py,sha256=xViruRYb9kFjndY_GmhK5vNQ0VxCE3rbKB3uzqtp_zE,2018
 spectre_core/receivers/_register.py,sha256=jWS3Q_ZOZcqUFunxJwR5VRZN4_eS3LzcP-5edQdmj4c,1366
-spectre_core/receivers/_spec_names.py,sha256=pLYM9rMoZkT3JmRvSNfWKFiIJmj07vrphDbw-fNhpO8,1611
+spectre_core/receivers/_spec_names.py,sha256=SraBJw2VvO7gZYFEVO8byH_-bp8kpVQDQNhaXrzcLEE,1812
 spectre_core/receivers/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spectre_core/receivers/plugins/_receiver_names.py,sha256=GZi4xznxscLBJXbfkZLtQ-m0U3GH362HiI5-y_FQO1k,426
-spectre_core/receivers/plugins/_rsp1a.py,sha256=LAvjxcxIkZRPpc96wqkco7rQ-H3AvUowsp0WG8vgAkw,2438
-spectre_core/receivers/plugins/_rspduo.py,sha256=ypr4xiEMOq4EJKFECz01PZjUJ2UcsWJVZRou8Ln5Ogw,3049
-spectre_core/receivers/plugins/_sdrplay_receiver.py,sha256=QpQ2sRc9Tz2IZRL_LyBX3UPCQ270RQMHH2mP6Y_n1-o,6899
+spectre_core/receivers/plugins/_b200mini.py,sha256=gpCnyUpNonFs-0sGSlub_oPTFpIIUqGhm39DB8s8RTY,1884
+spectre_core/receivers/plugins/_receiver_names.py,sha256=b8cUln47Ya8rr8vnnHQEGa7j9Hf-hJsNbTNtGuZaWlA,498
+spectre_core/receivers/plugins/_rsp1a.py,sha256=zgPemoRjd93CvI9bRg7PHzgAUHB9xXg5LCvkLHa3jbI,2641
+spectre_core/receivers/plugins/_rspduo.py,sha256=Sim1TXcG_g1ohWKwvMk7XzrQC8NGydCMGZEf9hhvX-0,3230
+spectre_core/receivers/plugins/_sdrplay_receiver.py,sha256=bdfjGvKSFW_jfQFIQQcIIf8UfbuMwW04SK6YMNMIINI,5737
 spectre_core/receivers/plugins/_test.py,sha256=t8oE4zQLYYWJV6SMIZAlNHs9mig263QJmP6XRLyF0RU,8277
+spectre_core/receivers/plugins/_usrp.py,sha256=QAhtdhkknL5C7dvY6SECtsG35FuYpXK6zQqgG-ooklE,2416
 spectre_core/receivers/plugins/gr/__init__.py,sha256=oFSWmGoXQLK5X5xHvWzTdNr9amuaiiGjZirXZVogACU,154
 spectre_core/receivers/plugins/gr/_base.py,sha256=woFF6498aLIDf4EC7aD-TolY9LtZBqlLy-Vai_gfIvc,2571
-spectre_core/receivers/plugins/gr/_rsp1a.py,sha256=Nq0VNWjzfTd4Mruz4FSk6bfso6zh1cMw-C-qn5LpPv8,6614
+spectre_core/receivers/plugins/gr/_rsp1a.py,sha256=JLMRCNouSblNizth7EmLrtWvbnpD-5zd7uhc6Pjcopw,6288
 spectre_core/receivers/plugins/gr/_rspduo.py,sha256=s5g5nOQHiVHCESaHdj2VmgXl_LaiMaqXhTJfUbC7Iew,9811
 spectre_core/receivers/plugins/gr/_test.py,sha256=YA3JKdJ_CT3J93pqHUjltKrQUoaDXzUloEJEXVHH718,5780
+spectre_core/receivers/plugins/gr/_usrp.py,sha256=ZIg-WiiMWYKJbI4KkobeZrgncoRKYnvKlklYBXtmq4Q,2366
 spectre_core/spectrograms/__init__.py,sha256=AsiOmn9XrAAHUvK-fdhRddAxX4M1Wd6TCtdmxGkl3FA,763
 spectre_core/spectrograms/_analytical.py,sha256=Axnt9JOJnWXRRuVU5nHPz5QU09KoWqNZkR5NnTX6kMY,11356
-spectre_core/spectrograms/_array_operations.py,sha256=rhiHjnqFGT1bffJygMbeYWb1H9VGBK6-uAgFh8I9owc,7547
+spectre_core/spectrograms/_array_operations.py,sha256=79vddwWqR5i6OkeD5L_84t8svslpmzW4b8uxbiCQl0I,7553
 spectre_core/spectrograms/_spectrogram.py,sha256=WhHEt_QpmzspDqYlzdZcJ8CAXxRfs8-JfP0T3NHpjLQ,28205
 spectre_core/spectrograms/_transform.py,sha256=WZ5jAe3bOpNldxHDSHPf8Q_1ifBdWqXB_mlF6DL1VuE,11734
 spectre_core/wgetting/__init__.py,sha256=UkS0Z0wuuqpoZ1EL35wJcDpjBiAaZgdZ7064yGESxNE,341
 spectre_core/wgetting/_callisto.py,sha256=m9II6ayswrY4h_ST3TodioZ4C865lN_uOF-BozvjZAg,6952
-spectre_core-0.0.13.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-spectre_core-0.0.13.dist-info/METADATA,sha256=1PBd2ql6_9g9BGrwb1bWhnY4MSqRV1hdkXne6uE184o,42100
-spectre_core-0.0.13.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-spectre_core-0.0.13.dist-info/top_level.txt,sha256=-UsyjpFohXgZpgcZ9QbVeXhsIyF3Am8RxNFNDV_Ta2Y,13
-spectre_core-0.0.13.dist-info/RECORD,,
+spectre_core-0.0.15.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+spectre_core-0.0.15.dist-info/METADATA,sha256=9PWjpA43grOEKj7uhFP4xVseoSzAmkZrOZkZQYrJTt4,42100
+spectre_core-0.0.15.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+spectre_core-0.0.15.dist-info/top_level.txt,sha256=-UsyjpFohXgZpgcZ9QbVeXhsIyF3Am8RxNFNDV_Ta2Y,13
+spectre_core-0.0.15.dist-info/RECORD,,