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

spectre_core/receivers/library/rspduo/gr/tuner_2_sweep.py

@@ -1,119 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-#
-# SPDX-License-Identifier: GPL-3.0
-#
-# GNU Radio Python Flow Graph
-# Title: Not titled yet
-# GNU Radio version: 3.10.1.1
-
-from gnuradio import gr
-from gnuradio.filter import firdes
-from gnuradio.fft import window
-import sys
-import signal
-from argparse import ArgumentParser
-from gnuradio.eng_arg import eng_float, intx
-from gnuradio import eng_notation
-from gnuradio import sdrplay3
-from gnuradio import spectre
-
-from spectre_core.cfg import CHUNKS_DIR_PATH
-from spectre_core.file_handlers.configs import CaptureConfig
-
-
-class tuner_2_sweep(gr.top_block):
-    def __init__(self, 
-                 capture_config: CaptureConfig):
-        gr.top_block.__init__(self, "tuner_2_sweep", catch_exceptions=True)
-
-        ##################################################
-        # Unpack capture config
-        ##################################################
-        samp_rate = capture_config['samp_rate']
-        bandwidth = capture_config['bandwidth']
-        min_freq = capture_config['min_freq']
-        max_freq = capture_config['max_freq']
-        freq_step = capture_config['freq_step']
-        samples_per_step = capture_config['samples_per_step']
-        IF_gain = capture_config['IF_gain']
-        RF_gain = capture_config['RF_gain']
-        chunk_size = capture_config['chunk_size']
-        start_freq = min_freq + samp_rate/2
-        tag = capture_config['tag']
-
-        ##################################################
-        # Blocks
-        ##################################################
-        self.spectre_sweep_driver_0 = spectre.sweep_driver(min_freq, 
-                                                           max_freq, 
-                                                           freq_step, 
-                                                           samp_rate, 
-                                                           samples_per_step,
-                                                           'freq')
-        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(CHUNKS_DIR_PATH, 
-                                                                     tag, 
-                                                                     chunk_size, 
-                                                                     samp_rate, 
-                                                                     True, 
-                                                                     'freq', 
-                                                                     start_freq)
-        self.sdrplay3_rspduo_0 = sdrplay3.rspduo(
-            '',
-            rspduo_mode="Single Tuner",
-            antenna="Tuner 2 50 ohm",
-            stream_args=sdrplay3.stream_args(
-                output_type='fc32',
-                channels_size=1
-            ),
-        )
-        self.sdrplay3_rspduo_0.set_sample_rate(samp_rate, True)
-        self.sdrplay3_rspduo_0.set_center_freq(start_freq, True)
-        self.sdrplay3_rspduo_0.set_bandwidth(bandwidth)
-        self.sdrplay3_rspduo_0.set_antenna("Tuner 2 50 ohm")
-        self.sdrplay3_rspduo_0.set_gain_mode(False)
-        self.sdrplay3_rspduo_0.set_gain(IF_gain, 'IF', True)
-        self.sdrplay3_rspduo_0.set_gain(RF_gain, 'RF', True)
-        self.sdrplay3_rspduo_0.set_freq_corr(0)
-        self.sdrplay3_rspduo_0.set_dc_offset_mode(False)
-        self.sdrplay3_rspduo_0.set_iq_balance_mode(False)
-        self.sdrplay3_rspduo_0.set_agc_setpoint(-30)
-        self.sdrplay3_rspduo_0.set_rf_notch_filter(False)
-        self.sdrplay3_rspduo_0.set_dab_notch_filter(True)
-        self.sdrplay3_rspduo_0.set_am_notch_filter(False)
-        self.sdrplay3_rspduo_0.set_biasT(False)
-        self.sdrplay3_rspduo_0.set_stream_tags(True)
-        self.sdrplay3_rspduo_0.set_debug_mode(False)
-        self.sdrplay3_rspduo_0.set_sample_sequence_gaps_check(False)
-        self.sdrplay3_rspduo_0.set_show_gain_changes(False)
-
-
-        ##################################################
-        # Connections
-        ##################################################
-        self.msg_connect((self.spectre_sweep_driver_0, 'freq'), (self.sdrplay3_rspduo_0, 'freq'))
-        self.connect((self.sdrplay3_rspduo_0, 0), (self.spectre_batched_file_sink_0, 0))
-        self.connect((self.sdrplay3_rspduo_0, 0), (self.spectre_sweep_driver_0, 0))
-
-
-def main(capture_config: CaptureConfig, 
-         top_block_cls=tuner_2_sweep, 
-         options=None):
-    tb = top_block_cls(capture_config)
-
-    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(1024)
-
-    tb.wait()
-
-if __name__ == '__main__':
-    main()

spectre_core/receivers/library/rspduo/receiver.py

@@ -1,97 +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 spectre_core.receivers.base import SDRPlayReceiver
-from spectre_core.receivers.receiver_register import register_receiver
-from spectre_core.receivers.library.rspduo.gr import (
-    tuner_1_fixed, 
-    tuner_1_sweep,
-    tuner_2_fixed,
-    tuner_2_sweep
-)
-from spectre_core.file_handlers.configs import CaptureConfig
-
-
-@register_receiver("rspduo")
-class Receiver(SDRPlayReceiver):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-
-    def _set_capture_methods(self) -> None:
-        self._capture_methods = {
-            "tuner-1-fixed": self.__tuner_1_fixed,
-            "tuner-1-sweep": self.__tuner_1_sweep,
-            "tuner-2-fixed": self.__tuner_2_fixed,
-            "tuner-2-sweep": self.__tuner_2_sweep
-        }
-    
-
-    def _set_validators(self) -> None:
-        self._validators = {
-            "tuner-1-fixed": self.__tuner_1_fixed_validator,
-            "tuner-1-sweep": self.__tuner_1_sweep_validator,
-            "tuner-2-fixed": self.__tuner_2_fixed_validator,
-            "tuner-2-sweep": self.__tuner_2_sweep_validator,
-        }
-        return
-    
-
-    def _set_type_templates(self) -> None:
-        self._type_templates = {
-            "tuner-1-fixed": self._get_default_type_template("fixed"),
-            "tuner-1-sweep": self._get_default_type_template("sweep"),
-            "tuner-2-fixed": self._get_default_type_template("fixed"),
-            "tuner-2-sweep": self._get_default_type_template("sweep"),
-        }
-
-    def _set_specifications(self) -> None:
-        self._specifications = {
-            "center_freq_lower_bound": 1e3, # [Hz]
-            "center_freq_upper_bound": 2e9, # [Hz]
-            "samp_rate_lower_bound": 200e3, # [Hz]
-            "samp_rate_upper_bound": 10e6, # [Hz]
-            "bandwidth_lower_bound": 200e3, # [Hz]
-            "bandwidth_upper_bound": 8e6, # [Hz]
-            "IF_gain_upper_bound": -20, # [dB]
-            "RF_gain_upper_bound": 0, # [dB]
-            "api_latency": 50 * 1e-3 # [s]
-        }
-
-
-    def __tuner_1_fixed(self, capture_config: CaptureConfig) -> None:
-        tuner_1_fixed.main(capture_config)
-    
-
-    def __tuner_1_sweep(self, capture_config: CaptureConfig) -> None:
-        tuner_1_sweep.main(capture_config)
-
-    
-    def __tuner_2_fixed(self, capture_config: CaptureConfig) -> None:
-        tuner_2_fixed.main(capture_config)
-    
-
-    def __tuner_2_sweep(self, capture_config: CaptureConfig) -> None:
-        tuner_2_sweep.main(capture_config)
-
-
-    def __tuner_1_fixed_validator(self, capture_config: CaptureConfig) -> None:
-        self._default_fixed_validator(capture_config)
-        self._sdrplay_validator(capture_config)
- 
-
-    def __tuner_1_sweep_validator(self, capture_config: CaptureConfig) -> None:
-        self._default_sweep_validator(capture_config)
-        self._sdrplay_validator(capture_config)  
-
-
-    def __tuner_2_fixed_validator(self, capture_config: CaptureConfig) -> None:
-        self._default_fixed_validator(capture_config)
-        self._sdrplay_validator(capture_config)
-
-
-    def __tuner_2_sweep_validator(self, capture_config: CaptureConfig) -> None:
-        self._default_sweep_validator(capture_config)
-        self._sdrplay_validator(capture_config)
-    

spectre_core/receivers/library/test/gr/cosine_signal_1.py

@@ -1,83 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-#
-# SPDX-License-Identifier: GPL-3.0
-#
-# GNU Radio Python Flow Graph
-# Title: Not titled yet
-# 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
-
-import sys
-import signal
-from typing import Any
-
-from gnuradio import analog
-from gnuradio import blocks
-from gnuradio import gr
-from gnuradio.filter import firdes
-from gnuradio.fft import window
-from gnuradio.eng_arg import eng_float, intx
-from gnuradio import eng_notation
-from gnuradio import spectre
-
-from spectre_core.cfg import CHUNKS_DIR_PATH
-from spectre_core.file_handlers.configs import CaptureConfig
-
-class cosine_signal_1(gr.top_block):
-
-    def __init__(self, 
-                 capture_config: CaptureConfig):
-        gr.top_block.__init__(self, "cosine-signal-1", catch_exceptions=True)
-
-        ##################################################
-        # Unpack capture config
-        ##################################################
-        samp_rate = capture_config['samp_rate']
-        tag = capture_config['tag']
-        chunk_size = capture_config['chunk_size']
-        frequency = capture_config['frequency']
-        amplitude = capture_config['amplitude']
-
-        ##################################################
-        # Blocks
-        ##################################################
-        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(CHUNKS_DIR_PATH, tag, chunk_size, samp_rate)
-        self.blocks_throttle_0_1 = blocks.throttle(gr.sizeof_float*1, samp_rate,True)
-        self.blocks_throttle_0 = blocks.throttle(gr.sizeof_float*1, samp_rate,True)
-        self.blocks_null_source_1 = blocks.null_source(gr.sizeof_float*1)
-        self.blocks_float_to_complex_1 = blocks.float_to_complex(1)
-        self.analog_sig_source_x_0 = analog.sig_source_f(samp_rate, analog.GR_COS_WAVE, frequency, amplitude, 0, 0)
-
-
-        ##################################################
-        # Connections
-        ##################################################
-        self.connect((self.analog_sig_source_x_0, 0), (self.blocks_throttle_0, 0))
-        self.connect((self.blocks_float_to_complex_1, 0), (self.spectre_batched_file_sink_0, 0))
-        self.connect((self.blocks_null_source_1, 0), (self.blocks_throttle_0_1, 0))
-        self.connect((self.blocks_throttle_0, 0), (self.blocks_float_to_complex_1, 0))
-        self.connect((self.blocks_throttle_0_1, 0), (self.blocks_float_to_complex_1, 1))
-
-
-def main(capture_config: CaptureConfig, 
-         top_block_cls=cosine_signal_1, 
-         options=None):
-    tb = top_block_cls(capture_config)
-
-    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()
-
-    tb.wait()

spectre_core/receivers/library/test/gr/tagged_staircase.py

@@ -1,93 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-#
-# SPDX-License-Identifier: GPL-3.0
-#
-# GNU Radio Python Flow Graph
-# Title: Not titled yet
-# 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
-
-import sys
-import signal
-from argparse import ArgumentParser
-from typing import Any
-
-from gnuradio import blocks
-from gnuradio import gr
-from gnuradio.filter import firdes
-from gnuradio.fft import window
-from gnuradio.eng_arg import eng_float, intx
-from gnuradio import eng_notation
-from gnuradio import spectre
-
-from spectre_core.cfg import CHUNKS_DIR_PATH
-from spectre_core.file_handlers.configs import CaptureConfig
-
-class tagged_staircase(gr.top_block):
-
-    def __init__(self, 
-                 capture_config: CaptureConfig):
-        gr.top_block.__init__(self, "tagged-staircase", catch_exceptions=True)
-
-        ##################################################
-        # Unpack capture config
-        ##################################################
-        tag = capture_config['tag']
-        step_increment = capture_config['step_increment']
-        samp_rate = capture_config['samp_rate']
-        min_samples_per_step = capture_config['min_samples_per_step']
-        max_samples_per_step = capture_config['max_samples_per_step']
-        freq_step = capture_config['freq_step']
-        chunk_size = capture_config['chunk_size']
-        is_sweeping = True
-
-        ##################################################
-        # Blocks
-        ##################################################
-        self.spectre_tagged_staircase_0 = spectre.tagged_staircase(min_samples_per_step, 
-                                                                   max_samples_per_step, 
-                                                                   freq_step,
-                                                                   step_increment, 
-                                                                   samp_rate)
-        self.spectre_batched_file_sink_0 = spectre.batched_file_sink(CHUNKS_DIR_PATH,
-                                                                     tag, 
-                                                                     chunk_size, 
-                                                                     samp_rate, 
-                                                                     is_sweeping,
-                                                                     'rx_freq',
-                                                                     0
-                                                                     )
-        self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, samp_rate, True)
-
-
-        ##################################################
-        # Connections
-        ##################################################
-        self.connect((self.blocks_throttle_0, 0), (self.spectre_batched_file_sink_0, 0))
-        self.connect((self.spectre_tagged_staircase_0, 0), (self.blocks_throttle_0, 0))
-
-
-
-
-def main(capture_config: CaptureConfig, 
-         top_block_cls=tagged_staircase, 
-         options=None):
-    tb = top_block_cls(capture_config)
-
-    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()
-
-    tb.wait()

spectre_core/receivers/library/test/receiver.py

@@ -1,203 +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 spectre_core.receivers import validators
-from spectre_core.receivers.base import SPECTREReceiver
-from spectre_core.receivers.receiver_register import register_receiver
-from spectre_core.receivers.library.test.gr import cosine_signal_1
-from spectre_core.receivers.library.test.gr import tagged_staircase
-from spectre_core.file_handlers.configs import CaptureConfig
-
-
-@register_receiver("test")
-class Receiver(SPECTREReceiver):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-
-    def _set_capture_methods(self) -> None:
-        self._capture_methods = {
-            "cosine-signal-1": self.__cosine_signal_1,
-            "tagged-staircase": self.__tagged_staircase
-        }
-    
-
-    def _set_validators(self) -> None:
-        self._validators = {
-            "cosine-signal-1": self.__cosine_signal_1_validator,
-            "tagged-staircase": self.__tagged_staircase_validator
-        }
-    
-
-    def _set_type_templates(self) -> None:
-        self._type_templates = {
-            "cosine-signal-1": {
-                "samp_rate": int, # [Hz]
-                "frequency": float, # [Hz]
-                "amplitude": float, # unitless
-                "chunk_size": int, # [s]
-                "joining_time": int, # [s]
-                "time_resolution": float, # [s]
-                "frequency_resolution": float, # [Hz]
-                "window_type": str, # the window type for the STFFT
-                "window_kwargs": dict, # keyword arguments for scipy get window function. Must be in order as in scipy documentation.
-                "window_size": int, # number of samples for the window
-                "hop": int, # STFFT hop shifts window by so many samples
-                "chunk_key": str, # maps to the corresponding chunk class
-                "event_handler_key": str, # maps to the event handler used in post processing
-                "watch_extension": str # event handlers watch for files with this extension
-            },
-            "tagged-staircase": {
-                "samp_rate": int, # [Hz]
-                "min_samples_per_step": int, # [samples]
-                "max_samples_per_step": int, # [samples]
-                "freq_step": float, # [Hz]
-                "step_increment": int, # [samples]
-                "chunk_size": int, # [s]
-                "joining_time": int, # [s]
-                "time_resolution": float, # [s]
-                "frequency_resolution": float, # [Hz]
-                "window_type": str, # the window type for the STFFT
-                "window_kwargs": dict, # keyword arguments for scipy get window function. Must be in order as in scipy documentation.
-                "window_size": int, # number of samples for the window
-                "hop": int, # keyword arguments for scipy STFFT class
-                "chunk_key": str, # maps to the corresponding chunk class
-                "event_handler_key": str, # maps to the event handler used in post processing
-                "watch_extension": str # event handlers watch for files with this extension
-            }
-        }
-    
-    def _set_specifications(self) -> None:
-        self._specifications = {
-            "samp_rate_lower_bound": 64000
-        } 
-
-
-    def __cosine_signal_1(self, capture_config: CaptureConfig) -> None:
-        cosine_signal_1.main(capture_config)
-    
-
-    def __tagged_staircase(self, capture_config: CaptureConfig) -> None:
-        tagged_staircase.main(capture_config)
-    
-
-    def __cosine_signal_1_validator(self, capture_config: CaptureConfig) -> None:
-        # unpack the capture config
-        samp_rate = capture_config["samp_rate"]
-        frequency = capture_config["frequency"]
-        amplitude = capture_config["amplitude"]
-        chunk_size = capture_config["chunk_size"]
-        window_type = capture_config["window_type"]
-        window_size = capture_config["window_size"]
-        hop = capture_config["hop"]
-        chunk_key = capture_config["chunk_key"]
-        event_handler_key = capture_config["event_handler_key"]
-        time_resolution = capture_config["time_resolution"]
-        frequency_resolution = capture_config["frequency_resolution"]
-        watch_extension = capture_config["watch_extension"]
-
-        validators.samp_rate_strictly_positive(samp_rate)
-        validators.chunk_size_strictly_positive(chunk_size)
-        validators.time_resolution(time_resolution, chunk_size) 
-        validators.window(window_type, 
-                          {}, 
-                          window_size,
-                          chunk_size,
-                          samp_rate)
-        validators.hop(hop)
-        validators.chunk_key(chunk_key, 
-                             "fixed")
-        validators.event_handler_key(event_handler_key, 
-                                     "fixed")
-        validators.watch_extension(watch_extension, 
-                                   "bin")
-
-        if samp_rate < self.specifications.get("samp_rate_lower_bound"):
-            raise ValueError((f"Sample rate must be greater than or equal to "
-                              f"{self.specifications.get('samp_rate_lower_bound')}"))
-
-        if time_resolution != 0:
-            raise ValueError(f"Time resolution must be zero. "
-                             f"Got {time_resolution} [s]")
-        
-        if frequency_resolution != 0:
-            raise ValueError((f"Frequency resolution must be zero. "
-                              f"Got {frequency_resolution}"))
-        
-        # check that the sample rate is an integer multiple of the underlying signal frequency
-        if samp_rate % frequency != 0:
-            raise ValueError("The sampling rate must be some integer multiple of frequency")
-
-        a = samp_rate/frequency
-        if a < 2:
-            raise ValueError((f"The ratio of sampling rate over frequency must be a natural number greater than two. "
-                             f"Got {a}"))
-        
-        # ensuring the window type is rectangular
-        if window_type != "boxcar":
-            raise ValueError((f"The window type must be 'boxcar'. "
-                              f"Got {window_type}"))
-        
-        # analytical requirement
-        # if p is the number of sampled cycles, we can find that p = window_size / a
-        # the number of sampled cycles must be a positive natural number.
-        p = window_size / a
-        if window_size % a != 0:
-            raise ValueError((f"The number of sampled cycles must be a positive natural number. "
-                              f"Computed that p={p}"))
-    
-    
-        if amplitude <= 0:
-            raise ValueError((f"The amplitude must be strictly positive. "
-                              f"Got {amplitude}"))
-    
-
-    def __tagged_staircase_validator(self, capture_config: CaptureConfig) -> None:
-        samp_rate = capture_config["samp_rate"]
-        min_samples_per_step = capture_config["min_samples_per_step"]
-        max_samples_per_step = capture_config["max_samples_per_step"]
-        freq_step = capture_config["freq_step"]
-        step_increment = capture_config["step_increment"]
-        chunk_size = capture_config["chunk_size"]
-        window_type = capture_config["window_type"]
-        window_kwargs = capture_config["window_kwargs"]
-        window_size = capture_config["window_size"]
-        hop = capture_config["hop"]
-        chunk_key = capture_config["chunk_key"]
-        event_handler_key = capture_config["event_handler_key"]
-        time_resolution = capture_config["time_resolution"]
-        watch_extension = capture_config["watch_extension"]
-        
-        validators.samp_rate_strictly_positive(samp_rate)
-        validators.chunk_size_strictly_positive(chunk_size)
-        validators.time_resolution(time_resolution, chunk_size)
-        validators.window(window_type, 
-                          window_kwargs, 
-                          window_size, 
-                          chunk_size, 
-                          samp_rate)
-        validators.hop(hop)
-        validators.chunk_key(chunk_key, "sweep")
-        validators.event_handler_key(event_handler_key, "sweep")
-        validators.watch_extension(watch_extension, 
-                                   "bin")
-        
-        if freq_step != samp_rate:
-            raise ValueError(f"The frequency step must be equal to the sampling rate")
-        
-        if min_samples_per_step <= 0:
-            raise ValueError((f"Minimum samples per step must be strictly positive. "
-                              f"Got {min_samples_per_step}"))
-        
-        if max_samples_per_step <= 0:
-            raise ValueError((f"Maximum samples per step must be strictly positive. "
-                              f"Got {max_samples_per_step}"))
-        
-        if step_increment <= 0:
-            raise ValueError((f"Step increment must be strictly positive. "
-                              f"Got {step_increment}"))
-        
-        if min_samples_per_step > max_samples_per_step:
-            raise ValueError((f"Minimum samples per step cannot be greater than the maximum samples per step. "
-                              f"Got {min_samples_per_step}, which is greater than {max_samples_per_step}"))