spectre-core 0.0.22__py3-none-any.whl → 0.0.24__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (78) hide show
  1. spectre_core/__init__.py +5 -0
  2. spectre_core/_file_io/__init__.py +4 -4
  3. spectre_core/_file_io/file_handlers.py +60 -106
  4. spectre_core/batches/__init__.py +20 -3
  5. spectre_core/batches/_base.py +85 -134
  6. spectre_core/batches/_batches.py +55 -99
  7. spectre_core/batches/_factory.py +21 -20
  8. spectre_core/batches/_register.py +8 -8
  9. spectre_core/batches/plugins/_batch_keys.py +7 -6
  10. spectre_core/batches/plugins/_callisto.py +65 -97
  11. spectre_core/batches/plugins/_iq_stream.py +105 -169
  12. spectre_core/capture_configs/__init__.py +46 -17
  13. spectre_core/capture_configs/_capture_config.py +25 -52
  14. spectre_core/capture_configs/_capture_modes.py +8 -6
  15. spectre_core/capture_configs/_capture_templates.py +50 -110
  16. spectre_core/capture_configs/_parameters.py +37 -74
  17. spectre_core/capture_configs/_pconstraints.py +40 -40
  18. spectre_core/capture_configs/_pnames.py +36 -34
  19. spectre_core/capture_configs/_ptemplates.py +260 -347
  20. spectre_core/capture_configs/_pvalidators.py +99 -102
  21. spectre_core/config/__init__.py +19 -8
  22. spectre_core/config/_paths.py +25 -47
  23. spectre_core/config/_time_formats.py +6 -5
  24. spectre_core/exceptions.py +38 -0
  25. spectre_core/jobs/__init__.py +3 -6
  26. spectre_core/jobs/_duration.py +12 -0
  27. spectre_core/jobs/_jobs.py +72 -43
  28. spectre_core/jobs/_workers.py +55 -105
  29. spectre_core/logs/__init__.py +7 -2
  30. spectre_core/logs/_configure.py +13 -17
  31. spectre_core/logs/_decorators.py +6 -4
  32. spectre_core/logs/_logs.py +37 -89
  33. spectre_core/logs/_process_types.py +5 -3
  34. spectre_core/plotting/__init__.py +19 -3
  35. spectre_core/plotting/_base.py +112 -177
  36. spectre_core/plotting/_format.py +10 -8
  37. spectre_core/plotting/_panel_names.py +7 -5
  38. spectre_core/plotting/_panel_stack.py +138 -130
  39. spectre_core/plotting/_panels.py +152 -162
  40. spectre_core/post_processing/__init__.py +6 -3
  41. spectre_core/post_processing/_base.py +41 -55
  42. spectre_core/post_processing/_factory.py +14 -11
  43. spectre_core/post_processing/_post_processor.py +16 -12
  44. spectre_core/post_processing/_register.py +10 -7
  45. spectre_core/post_processing/plugins/_event_handler_keys.py +4 -3
  46. spectre_core/post_processing/plugins/_fixed_center_frequency.py +54 -47
  47. spectre_core/post_processing/plugins/_swept_center_frequency.py +199 -174
  48. spectre_core/receivers/__init__.py +9 -2
  49. spectre_core/receivers/_base.py +82 -148
  50. spectre_core/receivers/_factory.py +20 -30
  51. spectre_core/receivers/_register.py +7 -10
  52. spectre_core/receivers/_spec_names.py +17 -15
  53. spectre_core/receivers/plugins/_b200mini.py +47 -60
  54. spectre_core/receivers/plugins/_receiver_names.py +8 -6
  55. spectre_core/receivers/plugins/_rsp1a.py +44 -40
  56. spectre_core/receivers/plugins/_rspduo.py +59 -44
  57. spectre_core/receivers/plugins/_sdrplay_receiver.py +67 -83
  58. spectre_core/receivers/plugins/_test.py +136 -129
  59. spectre_core/receivers/plugins/_usrp.py +93 -85
  60. spectre_core/receivers/plugins/gr/__init__.py +1 -1
  61. spectre_core/receivers/plugins/gr/_base.py +14 -22
  62. spectre_core/receivers/plugins/gr/_rsp1a.py +53 -60
  63. spectre_core/receivers/plugins/gr/_rspduo.py +77 -89
  64. spectre_core/receivers/plugins/gr/_test.py +49 -57
  65. spectre_core/receivers/plugins/gr/_usrp.py +61 -59
  66. spectre_core/spectrograms/__init__.py +21 -13
  67. spectre_core/spectrograms/_analytical.py +108 -99
  68. spectre_core/spectrograms/_array_operations.py +39 -46
  69. spectre_core/spectrograms/_spectrogram.py +293 -324
  70. spectre_core/spectrograms/_transform.py +106 -73
  71. spectre_core/wgetting/__init__.py +1 -3
  72. spectre_core/wgetting/_callisto.py +87 -93
  73. {spectre_core-0.0.22.dist-info → spectre_core-0.0.24.dist-info}/METADATA +9 -23
  74. spectre_core-0.0.24.dist-info/RECORD +79 -0
  75. {spectre_core-0.0.22.dist-info → spectre_core-0.0.24.dist-info}/WHEEL +1 -1
  76. spectre_core-0.0.22.dist-info/RECORD +0 -78
  77. {spectre_core-0.0.22.dist-info → spectre_core-0.0.24.dist-info}/licenses/LICENSE +0 -0
  78. {spectre_core-0.0.22.dist-info → spectre_core-0.0.24.dist-info}/top_level.txt +0 -0
spectre_core/receivers/plugins/gr/_base.py CHANGED
@@ -10,31 +10,24 @@ from gnuradio import gr
10
10
 
11
11
  from spectre_core.capture_configs import Parameters
12
12
 
13
+
13
14
  class spectre_top_block(gr.top_block):
14
15
  """A thin wrapper around GNU Radio's `gr.top_block` class.
15
-
16
+
16
17
  Propagate through the input tag and parameters to `flowgraph` in the constructor,
17
18
  to make the GNU Radio flow graphs easily configurable.
18
19
  """
19
- def flowgraph(
20
- self,
21
- tag: str,
22
- parameters: Parameters
23
- ) -> None:
20
+
21
+ def flowgraph(self, tag: str, parameters: Parameters) -> None:
24
22
  """Define the flowgraph for the block.
25
-
26
- This method uses inline imports to allow the `spectre_core.receivers`
27
- module to work without requiring all Out-Of-Tree (OOT) modules to be installed.
23
+
24
+ This method uses inline imports to allow the `spectre_core.receivers`
25
+ module to work without requiring all Out-Of-Tree (OOT) modules to be installed.
28
26
  Only import the necessary OOT modules when implementing this method.
29
27
  """
30
28
  raise NotImplementedError()
31
-
32
-
33
- def __init__(
34
- self,
35
- tag: str,
36
- parameters: Parameters
37
- ) -> None:
29
+
30
+ def __init__(self, tag: str, parameters: Parameters) -> None:
38
31
  """Create an instance of `spectre_top_block`.
39
32
 
40
33
  :param tag: The capture config tag.
@@ -48,17 +41,17 @@ def capture(
48
41
  tag: str,
49
42
  parameters: Parameters,
50
43
  top_block_cls: Type[spectre_top_block],
51
- max_noutput_items: int = 10000000
44
+ max_noutput_items: int = 10000000,
52
45
  ) -> None:
53
46
  """
54
47
  Run a GNU Radio flowgraph with the given number of output items.
55
48
 
56
49
  Typically, this should be used with `partial` from `functools` to create
57
- a capture method. For example,
50
+ a capture method. For example,
58
51
 
59
52
  .. code-block:: python
60
53
  capture_method = partial(capture, top_block_cls=<your GNU Radio top block>)
61
-
54
+
62
55
  :param tag: The capture config tag
63
56
  :param parameters: The parameters stored in the capture config
64
57
  :param top_block_cls: The subclass of `spectre_top_block`, defining the GNURadio flowgraph.
@@ -66,8 +59,7 @@ def capture(
66
59
  the maximum number of output items any block will handle during a call to work. Defaults to 10000000
67
60
  (which has been chosen as per GNU Radio source code).
68
61
  """
69
- tb = top_block_cls(tag,
70
- parameters)
62
+ tb = top_block_cls(tag, parameters)
71
63
 
72
64
  def sig_handler(sig=None, frame=None):
73
65
  tb.stop()
@@ -77,4 +69,4 @@ def capture(
77
69
  signal.signal(signal.SIGINT, sig_handler)
78
70
  signal.signal(signal.SIGTERM, sig_handler)
79
71
 
80
- tb.run(max_noutput_items)
72
+ tb.run(max_noutput_items)
spectre_core/receivers/plugins/gr/_rsp1a.py CHANGED
@@ -9,43 +9,35 @@ from spectre_core.capture_configs import Parameters, PName
9
9
  from spectre_core.config import get_batches_dir_path
10
10
  from ._base import capture, spectre_top_block
11
11
 
12
+
12
13
  class _fixed_center_frequency(spectre_top_block):
13
- def flowgraph(
14
- self,
15
- tag: str,
16
- parameters: Parameters
17
- ) -> None:
18
- # OOT Module inline imports
14
+ def flowgraph(self, tag: str, parameters: Parameters) -> None:
15
+ # OOT Module inline imports
19
16
  from gnuradio import spectre
20
17
  from gnuradio import sdrplay3
21
18
 
22
19
  # Unpack the capture config parameters
23
20
  sample_rate = parameters.get_parameter_value(PName.SAMPLE_RATE)
24
- batch_size = parameters.get_parameter_value(PName.BATCH_SIZE)
21
+ batch_size = parameters.get_parameter_value(PName.BATCH_SIZE)
25
22
  center_freq = parameters.get_parameter_value(PName.CENTER_FREQUENCY)
26
- bandwidth = parameters.get_parameter_value(PName.BANDWIDTH)
27
- if_gain = parameters.get_parameter_value(PName.IF_GAIN)
28
- rf_gain = parameters.get_parameter_value(PName.RF_GAIN)
29
-
23
+ bandwidth = parameters.get_parameter_value(PName.BANDWIDTH)
24
+ if_gain = parameters.get_parameter_value(PName.IF_GAIN)
25
+ rf_gain = parameters.get_parameter_value(PName.RF_GAIN)
30
26
 
31
27
  # Blocks
32
- self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_batches_dir_path(),
33
- tag,
34
- batch_size,
35
- sample_rate)
28
+ self.spectre_batched_file_sink_0 = spectre.batched_file_sink(
29
+ get_batches_dir_path(), tag, batch_size, sample_rate
30
+ )
36
31
  self.sdrplay3_rsp1a_0 = sdrplay3.rsp1a(
37
- '',
38
- stream_args=sdrplay3.stream_args(
39
- output_type='fc32',
40
- channels_size=1
41
- ),
32
+ "",
33
+ stream_args=sdrplay3.stream_args(output_type="fc32", channels_size=1),
42
34
  )
43
35
  self.sdrplay3_rsp1a_0.set_sample_rate(sample_rate)
44
36
  self.sdrplay3_rsp1a_0.set_center_freq(center_freq)
45
37
  self.sdrplay3_rsp1a_0.set_bandwidth(bandwidth)
46
38
  self.sdrplay3_rsp1a_0.set_gain_mode(False)
47
- self.sdrplay3_rsp1a_0.set_gain(if_gain, 'IF')
48
- self.sdrplay3_rsp1a_0.set_gain(rf_gain, 'RF')
39
+ self.sdrplay3_rsp1a_0.set_gain(if_gain, "IF")
40
+ self.sdrplay3_rsp1a_0.set_gain(rf_gain, "RF")
49
41
  self.sdrplay3_rsp1a_0.set_freq_corr(0)
50
42
  self.sdrplay3_rsp1a_0.set_dc_offset_mode(False)
51
43
  self.sdrplay3_rsp1a_0.set_iq_balance_mode(False)
@@ -62,54 +54,50 @@ class _fixed_center_frequency(spectre_top_block):
62
54
 
63
55
 
64
56
  class _swept_center_frequency(spectre_top_block):
65
- def flowgraph(
66
- self,
67
- tag: str,
68
- parameters: Parameters
69
- ) -> None:
70
- # OOT Module inline imports
57
+ def flowgraph(self, tag: str, parameters: Parameters) -> None:
58
+ # OOT Module inline imports
71
59
  from gnuradio import spectre
72
60
  from gnuradio import sdrplay3
73
61
 
74
62
  # Unpack the capture config parameters
75
- sample_rate = parameters.get_parameter_value(PName.SAMPLE_RATE)
76
- bandwidth = parameters.get_parameter_value(PName.BANDWIDTH)
77
- min_frequency = parameters.get_parameter_value(PName.MIN_FREQUENCY)
78
- max_frequency = parameters.get_parameter_value(PName.MAX_FREQUENCY)
79
- frequency_step = parameters.get_parameter_value(PName.FREQUENCY_STEP)
63
+ sample_rate = parameters.get_parameter_value(PName.SAMPLE_RATE)
64
+ bandwidth = parameters.get_parameter_value(PName.BANDWIDTH)
65
+ min_frequency = parameters.get_parameter_value(PName.MIN_FREQUENCY)
66
+ max_frequency = parameters.get_parameter_value(PName.MAX_FREQUENCY)
67
+ frequency_step = parameters.get_parameter_value(PName.FREQUENCY_STEP)
80
68
  samples_per_step = parameters.get_parameter_value(PName.SAMPLES_PER_STEP)
81
- if_gain = parameters.get_parameter_value(PName.IF_GAIN)
82
- rf_gain = parameters.get_parameter_value(PName.RF_GAIN)
83
- batch_size = parameters.get_parameter_value(PName.BATCH_SIZE)
84
-
69
+ if_gain = parameters.get_parameter_value(PName.IF_GAIN)
70
+ rf_gain = parameters.get_parameter_value(PName.RF_GAIN)
71
+ batch_size = parameters.get_parameter_value(PName.BATCH_SIZE)
85
72
 
86
73
  # Blocks
87
- self.spectre_sweep_driver_0 = spectre.sweep_driver(min_frequency,
88
- max_frequency,
89
- frequency_step,
90
- sample_rate,
91
- samples_per_step,
92
- 'freq')
93
- self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_batches_dir_path(),
94
- tag,
95
- batch_size,
96
- sample_rate,
97
- True,
98
- 'freq',
99
- min_frequency)
74
+ self.spectre_sweep_driver_0 = spectre.sweep_driver(
75
+ min_frequency,
76
+ max_frequency,
77
+ frequency_step,
78
+ sample_rate,
79
+ samples_per_step,
80
+ "freq",
81
+ )
82
+ self.spectre_batched_file_sink_0 = spectre.batched_file_sink(
83
+ get_batches_dir_path(),
84
+ tag,
85
+ batch_size,
86
+ sample_rate,
87
+ True,
88
+ "freq",
89
+ min_frequency,
90
+ )
100
91
  self.sdrplay3_rsp1a_0 = sdrplay3.rsp1a(
101
- '',
102
- stream_args=sdrplay3.stream_args(
103
- output_type='fc32',
104
- channels_size=1
105
- ),
92
+ "",
93
+ stream_args=sdrplay3.stream_args(output_type="fc32", channels_size=1),
106
94
  )
107
95
  self.sdrplay3_rsp1a_0.set_sample_rate(sample_rate, True)
108
96
  self.sdrplay3_rsp1a_0.set_center_freq(min_frequency, True)
109
97
  self.sdrplay3_rsp1a_0.set_bandwidth(bandwidth)
110
98
  self.sdrplay3_rsp1a_0.set_gain_mode(False)
111
- self.sdrplay3_rsp1a_0.set_gain(if_gain, 'IF', True)
112
- self.sdrplay3_rsp1a_0.set_gain(rf_gain, 'RF', True)
99
+ self.sdrplay3_rsp1a_0.set_gain(if_gain, "IF", True)
100
+ self.sdrplay3_rsp1a_0.set_gain(rf_gain, "RF", True)
113
101
  self.sdrplay3_rsp1a_0.set_freq_corr(0)
114
102
  self.sdrplay3_rsp1a_0.set_dc_offset_mode(False)
115
103
  self.sdrplay3_rsp1a_0.set_iq_balance_mode(False)
@@ -123,12 +111,17 @@ class _swept_center_frequency(spectre_top_block):
123
111
  self.sdrplay3_rsp1a_0.set_show_gain_changes(False)
124
112
 
125
113
  # Connections
126
- self.msg_connect((self.spectre_sweep_driver_0, 'retune_command'), (self.sdrplay3_rsp1a_0, 'command'))
114
+ self.msg_connect(
115
+ (self.spectre_sweep_driver_0, "retune_command"),
116
+ (self.sdrplay3_rsp1a_0, "command"),
117
+ )
127
118
  self.connect((self.sdrplay3_rsp1a_0, 0), (self.spectre_batched_file_sink_0, 0))
128
119
  self.connect((self.sdrplay3_rsp1a_0, 0), (self.spectre_sweep_driver_0, 0))
129
120
 
130
121
 
131
122
  @dataclass(frozen=True)
132
123
  class CaptureMethod:
133
- fixed_center_frequency = partial(capture, top_block_cls=_fixed_center_frequency)
134
- swept_center_frequency = partial(capture, top_block_cls=_swept_center_frequency, max_noutput_items=1024)
124
+ fixed_center_frequency = partial(capture, top_block_cls=_fixed_center_frequency)
125
+ swept_center_frequency = partial(
126
+ capture, top_block_cls=_swept_center_frequency, max_noutput_items=1024
127
+ )
spectre_core/receivers/plugins/gr/_rspduo.py CHANGED
@@ -25,44 +25,36 @@ from ._base import capture, spectre_top_block
25
25
 
26
26
 
27
27
  class _tuner_1_fixed_center_frequency(spectre_top_block):
28
- def flowgraph(
29
- self,
30
- tag: str,
31
- parameters: Parameters
32
- ) -> None:
33
- # OOT Module inline imports
28
+ def flowgraph(self, tag: str, parameters: Parameters) -> None:
29
+ # OOT Module inline imports
34
30
  from gnuradio import spectre
35
31
  from gnuradio import sdrplay3
36
-
32
+
37
33
  # Unpack the capture config parameters
38
34
  sample_rate = parameters.get_parameter_value(PName.SAMPLE_RATE)
39
- batch_size = parameters.get_parameter_value(PName.BATCH_SIZE)
35
+ batch_size = parameters.get_parameter_value(PName.BATCH_SIZE)
40
36
  center_freq = parameters.get_parameter_value(PName.CENTER_FREQUENCY)
41
- bandwidth = parameters.get_parameter_value(PName.BANDWIDTH)
42
- if_gain = parameters.get_parameter_value(PName.IF_GAIN)
43
- rf_gain = parameters.get_parameter_value(PName.RF_GAIN)
37
+ bandwidth = parameters.get_parameter_value(PName.BANDWIDTH)
38
+ if_gain = parameters.get_parameter_value(PName.IF_GAIN)
39
+ rf_gain = parameters.get_parameter_value(PName.RF_GAIN)
44
40
 
45
41
  # Blocks
46
- self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_batches_dir_path(),
47
- tag,
48
- batch_size,
49
- sample_rate)
42
+ self.spectre_batched_file_sink_0 = spectre.batched_file_sink(
43
+ get_batches_dir_path(), tag, batch_size, sample_rate
44
+ )
50
45
  self.sdrplay3_rspduo_0 = sdrplay3.rspduo(
51
- '',
46
+ "",
52
47
  rspduo_mode="Single Tuner",
53
48
  antenna="Tuner 1 50 ohm",
54
- stream_args=sdrplay3.stream_args(
55
- output_type='fc32',
56
- channels_size=1
57
- ),
49
+ stream_args=sdrplay3.stream_args(output_type="fc32", channels_size=1),
58
50
  )
59
51
  self.sdrplay3_rspduo_0.set_sample_rate(sample_rate)
60
52
  self.sdrplay3_rspduo_0.set_center_freq(center_freq)
61
53
  self.sdrplay3_rspduo_0.set_bandwidth(bandwidth)
62
54
  self.sdrplay3_rspduo_0.set_antenna("Tuner 1 50 ohm")
63
55
  self.sdrplay3_rspduo_0.set_gain_mode(False)
64
- self.sdrplay3_rspduo_0.set_gain(if_gain, 'IF')
65
- self.sdrplay3_rspduo_0.set_gain(rf_gain, 'RF')
56
+ self.sdrplay3_rspduo_0.set_gain(if_gain, "IF")
57
+ self.sdrplay3_rspduo_0.set_gain(rf_gain, "RF")
66
58
  self.sdrplay3_rspduo_0.set_freq_corr(0)
67
59
  self.sdrplay3_rspduo_0.set_dc_offset_mode(False)
68
60
  self.sdrplay3_rspduo_0.set_iq_balance_mode(False)
@@ -77,47 +69,39 @@ class _tuner_1_fixed_center_frequency(spectre_top_block):
77
69
 
78
70
  # Connections
79
71
  self.connect((self.sdrplay3_rspduo_0, 0), (self.spectre_batched_file_sink_0, 0))
80
-
81
-
72
+
73
+
82
74
  class _tuner_2_fixed_center_frequency(spectre_top_block):
83
- def flowgraph(
84
- self,
85
- tag: str,
86
- parameters: Parameters
87
- ) -> None:
88
- # OOT Module inline imports
75
+ def flowgraph(self, tag: str, parameters: Parameters) -> None:
76
+ # OOT Module inline imports
89
77
  from gnuradio import spectre
90
78
  from gnuradio import sdrplay3
91
-
79
+
92
80
  # Unpack the capture config parameters
93
81
  sample_rate = parameters.get_parameter_value(PName.SAMPLE_RATE)
94
- batch_size = parameters.get_parameter_value(PName.BATCH_SIZE)
82
+ batch_size = parameters.get_parameter_value(PName.BATCH_SIZE)
95
83
  center_freq = parameters.get_parameter_value(PName.CENTER_FREQUENCY)
96
- bandwidth = parameters.get_parameter_value(PName.BANDWIDTH)
97
- if_gain = parameters.get_parameter_value(PName.IF_GAIN)
98
- rf_gain = parameters.get_parameter_value(PName.RF_GAIN)
84
+ bandwidth = parameters.get_parameter_value(PName.BANDWIDTH)
85
+ if_gain = parameters.get_parameter_value(PName.IF_GAIN)
86
+ rf_gain = parameters.get_parameter_value(PName.RF_GAIN)
99
87
 
100
88
  # Blocks
101
- self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_batches_dir_path(),
102
- tag,
103
- batch_size,
104
- sample_rate)
89
+ self.spectre_batched_file_sink_0 = spectre.batched_file_sink(
90
+ get_batches_dir_path(), tag, batch_size, sample_rate
91
+ )
105
92
  self.sdrplay3_rspduo_0 = sdrplay3.rspduo(
106
- '',
93
+ "",
107
94
  rspduo_mode="Single Tuner",
108
95
  antenna="Tuner 2 50 ohm",
109
- stream_args=sdrplay3.stream_args(
110
- output_type='fc32',
111
- channels_size=1
112
- ),
96
+ stream_args=sdrplay3.stream_args(output_type="fc32", channels_size=1),
113
97
  )
114
98
  self.sdrplay3_rspduo_0.set_sample_rate(sample_rate)
115
99
  self.sdrplay3_rspduo_0.set_center_freq(center_freq)
116
100
  self.sdrplay3_rspduo_0.set_bandwidth(bandwidth)
117
101
  self.sdrplay3_rspduo_0.set_antenna("Tuner 2 50 ohm")
118
102
  self.sdrplay3_rspduo_0.set_gain_mode(False)
119
- self.sdrplay3_rspduo_0.set_gain(if_gain, 'IF')
120
- self.sdrplay3_rspduo_0.set_gain(rf_gain, 'RF', False)
103
+ self.sdrplay3_rspduo_0.set_gain(if_gain, "IF")
104
+ self.sdrplay3_rspduo_0.set_gain(rf_gain, "RF", False)
121
105
  self.sdrplay3_rspduo_0.set_freq_corr(0)
122
106
  self.sdrplay3_rspduo_0.set_dc_offset_mode(False)
123
107
  self.sdrplay3_rspduo_0.set_iq_balance_mode(False)
@@ -131,62 +115,58 @@ class _tuner_2_fixed_center_frequency(spectre_top_block):
131
115
  self.sdrplay3_rspduo_0.set_sample_sequence_gaps_check(False)
132
116
  self.sdrplay3_rspduo_0.set_show_gain_changes(False)
133
117
 
134
-
135
118
  # Connections
136
- self.connect((self.sdrplay3_rspduo_0, 0), (self.spectre_batched_file_sink_0, 0))
119
+ self.connect((self.sdrplay3_rspduo_0, 0), (self.spectre_batched_file_sink_0, 0))
137
120
 
138
121
 
139
122
  class _tuner_1_swept_center_frequency(spectre_top_block):
140
- def flowgraph(
141
- self,
142
- tag: str,
143
- parameters: Parameters
144
- ) -> None:
145
- # OOT Module inline imports
123
+ def flowgraph(self, tag: str, parameters: Parameters) -> None:
124
+ # OOT Module inline imports
146
125
  from gnuradio import spectre
147
126
  from gnuradio import sdrplay3
148
127
 
149
128
  # Unpack the capture config parameters
150
- sample_rate = parameters.get_parameter_value(PName.SAMPLE_RATE)
151
- bandwidth = parameters.get_parameter_value(PName.BANDWIDTH)
152
- min_frequency = parameters.get_parameter_value(PName.MIN_FREQUENCY)
153
- max_frequency = parameters.get_parameter_value(PName.MAX_FREQUENCY)
154
- frequency_step = parameters.get_parameter_value(PName.FREQUENCY_STEP)
129
+ sample_rate = parameters.get_parameter_value(PName.SAMPLE_RATE)
130
+ bandwidth = parameters.get_parameter_value(PName.BANDWIDTH)
131
+ min_frequency = parameters.get_parameter_value(PName.MIN_FREQUENCY)
132
+ max_frequency = parameters.get_parameter_value(PName.MAX_FREQUENCY)
133
+ frequency_step = parameters.get_parameter_value(PName.FREQUENCY_STEP)
155
134
  samples_per_step = parameters.get_parameter_value(PName.SAMPLES_PER_STEP)
156
- if_gain = parameters.get_parameter_value(PName.IF_GAIN)
157
- rf_gain = parameters.get_parameter_value(PName.RF_GAIN)
158
- batch_size = parameters.get_parameter_value(PName.BATCH_SIZE)
135
+ if_gain = parameters.get_parameter_value(PName.IF_GAIN)
136
+ rf_gain = parameters.get_parameter_value(PName.RF_GAIN)
137
+ batch_size = parameters.get_parameter_value(PName.BATCH_SIZE)
159
138
 
160
139
  # Blocks
161
- self.spectre_sweep_driver_0 = spectre.sweep_driver(min_frequency,
162
- max_frequency,
163
- frequency_step,
164
- sample_rate,
165
- samples_per_step,
166
- 'freq')
167
- self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_batches_dir_path(),
168
- tag,
169
- batch_size,
170
- sample_rate,
171
- True,
172
- 'freq',
173
- min_frequency)
140
+ self.spectre_sweep_driver_0 = spectre.sweep_driver(
141
+ min_frequency,
142
+ max_frequency,
143
+ frequency_step,
144
+ sample_rate,
145
+ samples_per_step,
146
+ "freq",
147
+ )
148
+ self.spectre_batched_file_sink_0 = spectre.batched_file_sink(
149
+ get_batches_dir_path(),
150
+ tag,
151
+ batch_size,
152
+ sample_rate,
153
+ True,
154
+ "freq",
155
+ min_frequency,
156
+ )
174
157
  self.sdrplay3_rspduo_0 = sdrplay3.rspduo(
175
- '',
158
+ "",
176
159
  rspduo_mode="Single Tuner",
177
160
  antenna="Tuner 1 50 ohm",
178
- stream_args=sdrplay3.stream_args(
179
- output_type='fc32',
180
- channels_size=1
181
- ),
161
+ stream_args=sdrplay3.stream_args(output_type="fc32", channels_size=1),
182
162
  )
183
163
  self.sdrplay3_rspduo_0.set_sample_rate(sample_rate, True)
184
164
  self.sdrplay3_rspduo_0.set_center_freq(min_frequency, True)
185
165
  self.sdrplay3_rspduo_0.set_bandwidth(bandwidth)
186
166
  self.sdrplay3_rspduo_0.set_antenna("Tuner 1 50 ohm")
187
167
  self.sdrplay3_rspduo_0.set_gain_mode(False)
188
- self.sdrplay3_rspduo_0.set_gain(if_gain, 'IF', True)
189
- self.sdrplay3_rspduo_0.set_gain(rf_gain, 'RF', True)
168
+ self.sdrplay3_rspduo_0.set_gain(if_gain, "IF", True)
169
+ self.sdrplay3_rspduo_0.set_gain(rf_gain, "RF", True)
190
170
  self.sdrplay3_rspduo_0.set_freq_corr(0)
191
171
  self.sdrplay3_rspduo_0.set_dc_offset_mode(False)
192
172
  self.sdrplay3_rspduo_0.set_iq_balance_mode(False)
@@ -200,15 +180,23 @@ class _tuner_1_swept_center_frequency(spectre_top_block):
200
180
  self.sdrplay3_rspduo_0.set_sample_sequence_gaps_check(False)
201
181
  self.sdrplay3_rspduo_0.set_show_gain_changes(False)
202
182
 
203
-
204
183
  # Connections
205
- self.msg_connect((self.spectre_sweep_driver_0, 'retune_command'), (self.sdrplay3_rspduo_0, 'command'))
184
+ self.msg_connect(
185
+ (self.spectre_sweep_driver_0, "retune_command"),
186
+ (self.sdrplay3_rspduo_0, "command"),
187
+ )
206
188
  self.connect((self.sdrplay3_rspduo_0, 0), (self.spectre_batched_file_sink_0, 0))
207
189
  self.connect((self.sdrplay3_rspduo_0, 0), (self.spectre_sweep_driver_0, 0))
208
-
209
-
190
+
191
+
210
192
  @dataclass(frozen=True)
211
193
  class CaptureMethod:
212
- tuner_1_fixed_center_frequency = partial(capture, top_block_cls=_tuner_1_fixed_center_frequency)
213
- tuner_2_fixed_center_frequency = partial(capture, top_block_cls=_tuner_2_fixed_center_frequency)
214
- tuner_1_swept_center_frequency = partial(capture, top_block_cls=_tuner_1_swept_center_frequency, max_noutput_items=1024)
194
+ tuner_1_fixed_center_frequency = partial(
195
+ capture, top_block_cls=_tuner_1_fixed_center_frequency
196
+ )
197
+ tuner_2_fixed_center_frequency = partial(
198
+ capture, top_block_cls=_tuner_2_fixed_center_frequency
199
+ )
200
+ tuner_1_swept_center_frequency = partial(
201
+ capture, top_block_cls=_tuner_1_swept_center_frequency, max_noutput_items=1024
202
+ )
spectre_core/receivers/plugins/gr/_test.py CHANGED
@@ -30,87 +30,75 @@ from ._base import capture, spectre_top_block
30
30
 
31
31
 
32
32
  class _cosine_signal_1(spectre_top_block):
33
- def flowgraph(
34
- self,
35
- tag: str,
36
- parameters: Parameters
37
- ) -> None:
38
- # Inline imports
33
+ def flowgraph(self, tag: str, parameters: Parameters) -> None:
34
+ # Inline imports
39
35
  from gnuradio import spectre
40
36
 
41
37
  # Unpack the capture config parameters
42
- samp_rate = parameters.get_parameter_value(PName.SAMPLE_RATE)
43
- batch_size = parameters.get_parameter_value(PName.BATCH_SIZE)
44
- frequency = parameters.get_parameter_value(PName.FREQUENCY)
45
- amplitude = parameters.get_parameter_value(PName.AMPLITUDE)
38
+ samp_rate = parameters.get_parameter_value(PName.SAMPLE_RATE)
39
+ batch_size = parameters.get_parameter_value(PName.BATCH_SIZE)
40
+ frequency = parameters.get_parameter_value(PName.FREQUENCY)
41
+ amplitude = parameters.get_parameter_value(PName.AMPLITUDE)
46
42
 
47
43
  # Blocks
48
- self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_batches_dir_path(),
49
- tag,
50
- batch_size,
51
- samp_rate)
52
- self.blocks_throttle_0_1 = blocks.throttle(gr.sizeof_float*1,
53
- samp_rate,
54
- True)
55
- self.blocks_throttle_0 = blocks.throttle(gr.sizeof_float*1,
56
- samp_rate,
57
- True)
58
- self.blocks_null_source_1 = blocks.null_source(gr.sizeof_float*1)
44
+ self.spectre_batched_file_sink_0 = spectre.batched_file_sink(
45
+ get_batches_dir_path(), tag, batch_size, samp_rate
46
+ )
47
+ self.blocks_throttle_0_1 = blocks.throttle(gr.sizeof_float * 1, samp_rate, True)
48
+ self.blocks_throttle_0 = blocks.throttle(gr.sizeof_float * 1, samp_rate, True)
49
+ self.blocks_null_source_1 = blocks.null_source(gr.sizeof_float * 1)
59
50
  self.blocks_float_to_complex_1 = blocks.float_to_complex(1)
60
- self.analog_sig_source_x_0 = analog.sig_source_f(samp_rate,
61
- analog.GR_COS_WAVE,
62
- frequency,
63
- amplitude,
64
- 0,
65
- 0)
66
-
51
+ self.analog_sig_source_x_0 = analog.sig_source_f(
52
+ samp_rate, analog.GR_COS_WAVE, frequency, amplitude, 0, 0
53
+ )
67
54
 
68
55
  ##################################################
69
56
  # Connections
70
57
  ##################################################
71
58
  self.connect((self.analog_sig_source_x_0, 0), (self.blocks_throttle_0, 0))
72
- self.connect((self.blocks_float_to_complex_1, 0), (self.spectre_batched_file_sink_0, 0))
59
+ self.connect(
60
+ (self.blocks_float_to_complex_1, 0), (self.spectre_batched_file_sink_0, 0)
61
+ )
73
62
  self.connect((self.blocks_null_source_1, 0), (self.blocks_throttle_0_1, 0))
74
63
  self.connect((self.blocks_throttle_0, 0), (self.blocks_float_to_complex_1, 0))
75
64
  self.connect((self.blocks_throttle_0_1, 0), (self.blocks_float_to_complex_1, 1))
76
65
 
77
66
 
78
67
  class _tagged_staircase(spectre_top_block):
79
- def flowgraph(
80
- self,
81
- tag: str,
82
- parameters: Parameters
83
- ) -> None:
84
- # Inline imports
68
+ def flowgraph(self, tag: str, parameters: Parameters) -> None:
69
+ # Inline imports
85
70
  from gnuradio import spectre
86
71
 
87
72
  ##################################################
88
73
  # Unpack capture config
89
74
  ##################################################
90
- step_increment = parameters.get_parameter_value(PName.STEP_INCREMENT)
91
- samp_rate = parameters.get_parameter_value(PName.SAMPLE_RATE)
92
- min_samples_per_step = parameters.get_parameter_value(PName.MIN_SAMPLES_PER_STEP)
93
- max_samples_per_step = parameters.get_parameter_value(PName.MAX_SAMPLES_PER_STEP)
94
- frequency_step = parameters.get_parameter_value(PName.FREQUENCY_STEP)
95
- batch_size = parameters.get_parameter_value(PName.BATCH_SIZE)
75
+ step_increment = parameters.get_parameter_value(PName.STEP_INCREMENT)
76
+ samp_rate = parameters.get_parameter_value(PName.SAMPLE_RATE)
77
+ min_samples_per_step = parameters.get_parameter_value(
78
+ PName.MIN_SAMPLES_PER_STEP
79
+ )
80
+ max_samples_per_step = parameters.get_parameter_value(
81
+ PName.MAX_SAMPLES_PER_STEP
82
+ )
83
+ frequency_step = parameters.get_parameter_value(PName.FREQUENCY_STEP)
84
+ batch_size = parameters.get_parameter_value(PName.BATCH_SIZE)
96
85
 
97
86
  ##################################################
98
87
  # Blocks
99
88
  ##################################################
100
- self.spectre_tagged_staircase_0 = spectre.tagged_staircase(min_samples_per_step,
101
- max_samples_per_step,
102
- frequency_step,
103
- step_increment,
104
- samp_rate)
105
- self.spectre_batched_file_sink_0 = spectre.batched_file_sink(get_batches_dir_path(),
106
- tag,
107
- batch_size,
108
- samp_rate,
109
- True,
110
- 'rx_freq',
111
- 0) # zero means the center frequency is unset
112
- self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, samp_rate, True)
113
-
89
+ self.spectre_tagged_staircase_0 = spectre.tagged_staircase(
90
+ min_samples_per_step,
91
+ max_samples_per_step,
92
+ frequency_step,
93
+ step_increment,
94
+ samp_rate,
95
+ )
96
+ self.spectre_batched_file_sink_0 = spectre.batched_file_sink(
97
+ get_batches_dir_path(), tag, batch_size, samp_rate, True, "rx_freq", 0
98
+ ) # zero means the center frequency is unset
99
+ self.blocks_throttle_0 = blocks.throttle(
100
+ gr.sizeof_gr_complex * 1, samp_rate, True
101
+ )
114
102
 
115
103
  ##################################################
116
104
  # Connections
@@ -121,5 +109,9 @@ class _tagged_staircase(spectre_top_block):
121
109
 
122
110
  @dataclass(frozen=True)
123
111
  class CaptureMethod:
124
- cosine_signal_1 : Callable[[str, Parameters], None] = partial(capture, top_block_cls=_cosine_signal_1)
125
- tagged_staircase: Callable[[str, Parameters], None] = partial(capture, top_block_cls=_tagged_staircase)
112
+ cosine_signal_1: Callable[[str, Parameters], None] = partial(
113
+ capture, top_block_cls=_cosine_signal_1
114
+ )
115
+ tagged_staircase: Callable[[str, Parameters], None] = partial(
116
+ capture, top_block_cls=_tagged_staircase
117
+ )