From f994554bb6fee893d1a824aefbb7383d5dd7e37d Mon Sep 17 00:00:00 2001 From: Jeff Moe Date: Thu, 19 Jan 2023 10:23:57 -0700 Subject: [PATCH] New gnuradio GRC at 10 gain --- pfb-gain-10.grc | 862 ++++++++++++++ pfb.grc.orig | 2821 +++++++++++++++++++++++++++++++++++++++++++++ top_block.py | 126 +- top_block.py.orig | 202 ++++ 4 files changed, 3958 insertions(+), 53 deletions(-) create mode 100644 pfb-gain-10.grc create mode 100644 pfb.grc.orig mode change 100644 => 100755 top_block.py create mode 100644 top_block.py.orig diff --git a/pfb-gain-10.grc b/pfb-gain-10.grc new file mode 100644 index 0000000..cf20c8e --- /dev/null +++ b/pfb-gain-10.grc @@ -0,0 +1,862 @@ +options: + parameters: + author: '' + catch_exceptions: 'True' + category: '[GRC Hier Blocks]' + cmake_opt: '' + comment: '' + copyright: '' + description: '' + gen_cmake: 'On' + gen_linking: dynamic + generate_options: no_gui + hier_block_src_path: '.:' + id: top_block + max_nouts: '0' + output_language: python + placement: (0,0) + qt_qss_theme: '' + realtime_scheduling: '' + run: 'True' + run_command: '{python} -u {filename}' + run_options: run + sizing_mode: fixed + thread_safe_setters: '' + title: '' + window_size: '' + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [8, 8] + rotation: 0 + state: enabled + +blocks: +- name: custom_window + id: variable + parameters: + comment: '' + value: sinc*np.hamming(4*nchan) + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [536, 12] + rotation: 0 + state: enabled +- name: sinc + id: variable + parameters: + comment: '' + value: np.sinc(sinc_sample_locations/np.pi) + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [368, 12] + rotation: 0 + state: enabled +- name: sinc_sample_locations + id: variable + parameters: + comment: '' + value: np.arange(-np.pi*4/2.0, np.pi*4/2.0, np.pi/nchan) + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [200, 12] + rotation: 0 + state: enabled +- name: RTL820T + id: rtlsdr_source + parameters: + affinity: '' + alias: '' + ant0: '' + ant1: '' + ant10: '' + ant11: '' + ant12: '' + ant13: '' + ant14: '' + ant15: '' + ant16: '' + ant17: '' + ant18: '' + ant19: '' + ant2: '' + ant20: '' + ant21: '' + ant22: '' + ant23: '' + ant24: '' + ant25: '' + ant26: '' + ant27: '' + ant28: '' + ant29: '' + ant3: '' + ant30: '' + ant31: '' + ant4: '' + ant5: '' + ant6: '' + ant7: '' + ant8: '' + ant9: '' + args: '' + bb_gain0: '10' + bb_gain1: '20' + bb_gain10: '20' + bb_gain11: '20' + bb_gain12: '20' + bb_gain13: '20' + bb_gain14: '20' + bb_gain15: '20' + bb_gain16: '20' + bb_gain17: '20' + bb_gain18: '20' + bb_gain19: '20' + bb_gain2: '20' + bb_gain20: '20' + bb_gain21: '20' + bb_gain22: '20' + bb_gain23: '20' + bb_gain24: '20' + bb_gain25: '20' + bb_gain26: '20' + bb_gain27: '20' + bb_gain28: '20' + bb_gain29: '20' + bb_gain3: '20' + bb_gain30: '20' + bb_gain31: '20' + bb_gain4: '20' + bb_gain5: '20' + bb_gain6: '20' + bb_gain7: '20' + bb_gain8: '20' + bb_gain9: '20' + bw0: '0' + bw1: '0' + bw10: '0' + bw11: '0' + bw12: '0' + bw13: '0' + bw14: '0' + bw15: '0' + bw16: '0' + bw17: '0' + bw18: '0' + bw19: '0' + bw2: '0' + bw20: '0' + bw21: '0' + bw22: '0' + bw23: '0' + bw24: '0' + bw25: '0' + bw26: '0' + bw27: '0' + bw28: '0' + bw29: '0' + bw3: '0' + bw30: '0' + bw31: '0' + bw4: '0' + bw5: '0' + bw6: '0' + bw7: '0' + bw8: '0' + bw9: '0' + clock_source0: '' + clock_source1: '' + clock_source2: '' + clock_source3: '' + clock_source4: '' + clock_source5: '' + clock_source6: '' + clock_source7: '' + comment: '' + corr0: '0' + corr1: '0' + corr10: '0' + corr11: '0' + corr12: '0' + corr13: '0' + corr14: '0' + corr15: '0' + corr16: '0' + corr17: '0' + corr18: '0' + corr19: '0' + corr2: '0' + corr20: '0' + corr21: '0' + corr22: '0' + corr23: '0' + corr24: '0' + corr25: '0' + corr26: '0' + corr27: '0' + corr28: '0' + corr29: '0' + corr3: '0' + corr30: '0' + corr31: '0' + corr4: '0' + corr5: '0' + corr6: '0' + corr7: '0' + corr8: '0' + corr9: '0' + dc_offset_mode0: '0' + dc_offset_mode1: '0' + dc_offset_mode10: '0' + dc_offset_mode11: '0' + dc_offset_mode12: '0' + dc_offset_mode13: '0' + dc_offset_mode14: '0' + dc_offset_mode15: '0' + dc_offset_mode16: '0' + dc_offset_mode17: '0' + dc_offset_mode18: '0' + dc_offset_mode19: '0' + dc_offset_mode2: '0' + dc_offset_mode20: '0' + dc_offset_mode21: '0' + dc_offset_mode22: '0' + dc_offset_mode23: '0' + dc_offset_mode24: '0' + dc_offset_mode25: '0' + dc_offset_mode26: '0' + dc_offset_mode27: '0' + dc_offset_mode28: '0' + dc_offset_mode29: '0' + dc_offset_mode3: '0' + dc_offset_mode30: '0' + dc_offset_mode31: '0' + dc_offset_mode4: '0' + dc_offset_mode5: '0' + dc_offset_mode6: '0' + dc_offset_mode7: '0' + dc_offset_mode8: '0' + dc_offset_mode9: '0' + freq0: c_freq + freq1: 100e6 + freq10: 100e6 + freq11: 100e6 + freq12: 100e6 + freq13: 100e6 + freq14: 100e6 + freq15: 100e6 + freq16: 100e6 + freq17: 100e6 + freq18: 100e6 + freq19: 100e6 + freq2: 100e6 + freq20: 100e6 + freq21: 100e6 + freq22: 100e6 + freq23: 100e6 + freq24: 100e6 + freq25: 100e6 + freq26: 100e6 + freq27: 100e6 + freq28: 100e6 + freq29: 100e6 + freq3: 100e6 + freq30: 100e6 + freq31: 100e6 + freq4: 100e6 + freq5: 100e6 + freq6: 100e6 + freq7: 100e6 + freq8: 100e6 + freq9: 100e6 + gain0: '10' + gain1: '10' + gain10: '10' + gain11: '10' + gain12: '10' + gain13: '10' + gain14: '10' + gain15: '10' + gain16: '10' + gain17: '10' + gain18: '10' + gain19: '10' + gain2: '10' + gain20: '10' + gain21: '10' + gain22: '10' + gain23: '10' + gain24: '10' + gain25: '10' + gain26: '10' + gain27: '10' + gain28: '10' + gain29: '10' + gain3: '10' + gain30: '10' + gain31: '10' + gain4: '10' + gain5: '10' + gain6: '10' + gain7: '10' + gain8: '10' + gain9: '10' + gain_mode0: 'False' + gain_mode1: 'False' + gain_mode10: 'False' + gain_mode11: 'False' + gain_mode12: 'False' + gain_mode13: 'False' + gain_mode14: 'False' + gain_mode15: 'False' + gain_mode16: 'False' + gain_mode17: 'False' + gain_mode18: 'False' + gain_mode19: 'False' + gain_mode2: 'False' + gain_mode20: 'False' + gain_mode21: 'False' + gain_mode22: 'False' + gain_mode23: 'False' + gain_mode24: 'False' + gain_mode25: 'False' + gain_mode26: 'False' + gain_mode27: 'False' + gain_mode28: 'False' + gain_mode29: 'False' + gain_mode3: 'False' + gain_mode30: 'False' + gain_mode31: 'False' + gain_mode4: 'False' + gain_mode5: 'False' + gain_mode6: 'False' + gain_mode7: 'False' + gain_mode8: 'False' + gain_mode9: 'False' + if_gain0: '10' + if_gain1: '20' + if_gain10: '20' + if_gain11: '20' + if_gain12: '20' + if_gain13: '20' + if_gain14: '20' + if_gain15: '20' + if_gain16: '20' + if_gain17: '20' + if_gain18: '20' + if_gain19: '20' + if_gain2: '20' + if_gain20: '20' + if_gain21: '20' + if_gain22: '20' + if_gain23: '20' + if_gain24: '20' + if_gain25: '20' + if_gain26: '20' + if_gain27: '20' + if_gain28: '20' + if_gain29: '20' + if_gain3: '20' + if_gain30: '20' + if_gain31: '20' + if_gain4: '20' + if_gain5: '20' + if_gain6: '20' + if_gain7: '20' + if_gain8: '20' + if_gain9: '20' + iq_balance_mode0: '0' + iq_balance_mode1: '0' + iq_balance_mode10: '0' + iq_balance_mode11: '0' + iq_balance_mode12: '0' + iq_balance_mode13: '0' + iq_balance_mode14: '0' + iq_balance_mode15: '0' + iq_balance_mode16: '0' + iq_balance_mode17: '0' + iq_balance_mode18: '0' + iq_balance_mode19: '0' + iq_balance_mode2: '0' + iq_balance_mode20: '0' + iq_balance_mode21: '0' + iq_balance_mode22: '0' + iq_balance_mode23: '0' + iq_balance_mode24: '0' + iq_balance_mode25: '0' + iq_balance_mode26: '0' + iq_balance_mode27: '0' + iq_balance_mode28: '0' + iq_balance_mode29: '0' + iq_balance_mode3: '0' + iq_balance_mode30: '0' + iq_balance_mode31: '0' + iq_balance_mode4: '0' + iq_balance_mode5: '0' + iq_balance_mode6: '0' + iq_balance_mode7: '0' + iq_balance_mode8: '0' + iq_balance_mode9: '0' + maxoutbuf: '0' + minoutbuf: '0' + nchan: '1' + num_mboards: '1' + sample_rate: samp_rate + sync: sync + time_source0: '' + time_source1: '' + time_source2: '' + time_source3: '' + time_source4: '' + time_source5: '' + time_source6: '' + time_source7: '' + type: fc32 + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [8, 348] + rotation: 0 + state: enabled +- name: blocks_add_xx_0 + id: blocks_add_xx + parameters: + affinity: '' + alias: '' + comment: '' + maxoutbuf: '0' + minoutbuf: '0' + num_inputs: '4' + type: complex + vlen: nchan + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [992, 136] + rotation: 0 + state: enabled +- name: blocks_complex_to_mag_squared_0 + id: blocks_complex_to_mag_squared + parameters: + affinity: '' + alias: '' + comment: '' + maxoutbuf: '0' + minoutbuf: '0' + vlen: nchan + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [592, 444] + rotation: 0 + state: enabled +- name: blocks_delay_0 + id: blocks_delay + parameters: + affinity: '' + alias: '' + comment: '' + delay: nchan*3 + maxoutbuf: '0' + minoutbuf: '0' + num_ports: '1' + type: complex + vlen: '1' + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [416, 276] + rotation: 0 + state: enabled +- name: blocks_delay_0_0 + id: blocks_delay + parameters: + affinity: '' + alias: '' + comment: '' + delay: nchan*2 + maxoutbuf: '0' + minoutbuf: '0' + num_ports: '1' + type: complex + vlen: '1' + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [416, 212] + rotation: 0 + state: enabled +- name: blocks_delay_0_1 + id: blocks_delay + parameters: + affinity: '' + alias: '' + comment: '' + delay: nchan + maxoutbuf: '0' + minoutbuf: '0' + num_ports: '1' + type: complex + vlen: '1' + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [416, 148] + rotation: 0 + state: enabled +- name: blocks_file_sink_0 + id: blocks_file_sink + parameters: + affinity: '' + alias: '' + append: 'True' + comment: '' + file: observation.dat + type: float + unbuffered: 'False' + vlen: nchan + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [960, 420] + rotation: 0 + state: enabled +- name: blocks_head_0 + id: blocks_head + parameters: + affinity: '' + alias: '' + comment: '' + maxoutbuf: '0' + minoutbuf: '0' + num_items: int(obs_time*samp_rate) + type: complex + vlen: '1' + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [240, 84] + rotation: 0 + state: enabled +- name: blocks_integrate_xx_0 + id: blocks_integrate_xx + parameters: + affinity: '' + alias: '' + comment: '' + decim: nbin + maxoutbuf: '0' + minoutbuf: '0' + type: float + vlen: nchan + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [784, 436] + rotation: 0 + state: enabled +- name: blocks_multiply_const_vxx_0 + id: blocks_multiply_const_vxx + parameters: + affinity: '' + alias: '' + comment: '' + const: custom_window[-nchan:] + maxoutbuf: '0' + minoutbuf: '0' + type: complex + vlen: nchan + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [720, 76] + rotation: 0 + state: enabled +- name: blocks_multiply_const_vxx_0_0 + id: blocks_multiply_const_vxx + parameters: + affinity: '' + alias: '' + comment: '' + const: custom_window[2*nchan:3*nchan] + maxoutbuf: '0' + minoutbuf: '0' + type: complex + vlen: nchan + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [720, 140] + rotation: 0 + state: enabled +- name: blocks_multiply_const_vxx_0_0_0 + id: blocks_multiply_const_vxx + parameters: + affinity: '' + alias: '' + comment: '' + const: custom_window[nchan:2*nchan] + maxoutbuf: '0' + minoutbuf: '0' + type: complex + vlen: nchan + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [720, 204] + rotation: 0 + state: enabled +- name: blocks_multiply_const_vxx_0_0_0_0 + id: blocks_multiply_const_vxx + parameters: + affinity: '' + alias: '' + comment: '' + const: custom_window[0:nchan] + maxoutbuf: '0' + minoutbuf: '0' + type: complex + vlen: nchan + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [720, 268] + rotation: 0 + state: enabled +- name: blocks_stream_to_vector_0 + id: blocks_stream_to_vector + parameters: + affinity: '' + alias: '' + comment: '' + maxoutbuf: '0' + minoutbuf: '0' + num_items: nchan + type: complex + vlen: '1' + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [552, 84] + rotation: 0 + state: enabled +- name: blocks_stream_to_vector_0_0 + id: blocks_stream_to_vector + parameters: + affinity: '' + alias: '' + comment: '' + maxoutbuf: '0' + minoutbuf: '0' + num_items: nchan + type: complex + vlen: '1' + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [552, 212] + rotation: 0 + state: enabled +- name: blocks_stream_to_vector_0_1 + id: blocks_stream_to_vector + parameters: + affinity: '' + alias: '' + comment: '' + maxoutbuf: '0' + minoutbuf: '0' + num_items: nchan + type: complex + vlen: '1' + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [552, 148] + rotation: 0 + state: enabled +- name: blocks_stream_to_vector_0_2 + id: blocks_stream_to_vector + parameters: + affinity: '' + alias: '' + comment: '' + maxoutbuf: '0' + minoutbuf: '0' + num_items: nchan + type: complex + vlen: '1' + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [552, 276] + rotation: 0 + state: enabled +- name: c_freq + id: parameter + parameters: + alias: '' + comment: '' + hide: none + label: '' + short_id: '' + type: eng_float + value: '1420000000' + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [8, 84] + rotation: 0 + state: enabled +- name: fft_vxx_0 + id: fft_vxx + parameters: + affinity: '' + alias: '' + comment: '' + fft_size: nchan + forward: 'True' + maxoutbuf: '0' + minoutbuf: '0' + nthreads: '1' + shift: 'True' + type: complex + window: window.blackmanharris(nchan) + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [352, 412] + rotation: 0 + state: enabled +- name: import_0 + id: import + parameters: + alias: '' + comment: '' + imports: import numpy as np + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [712, 12] + rotation: 0 + state: enabled +- name: nbin + id: parameter + parameters: + alias: '' + comment: '' + hide: none + label: '' + short_id: '' + type: intx + value: '1000' + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [104, 164] + rotation: 0 + state: enabled +- name: nchan + id: parameter + parameters: + alias: '' + comment: '' + hide: none + label: '' + short_id: '' + type: intx + value: '1024' + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [8, 164] + rotation: 0 + state: enabled +- name: obs_time + id: parameter + parameters: + alias: '' + comment: '' + hide: none + label: '' + short_id: '' + type: eng_float + value: '60' + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [8, 244] + rotation: 0 + state: enabled +- name: samp_rate + id: parameter + parameters: + alias: '' + comment: '' + hide: none + label: '' + short_id: '' + type: eng_float + value: '2400000' + states: + bus_sink: false + bus_source: false + bus_structure: null + coordinate: [96, 84] + rotation: 0 + state: enabled + +connections: +- [RTL820T, '0', blocks_head_0, '0'] +- [blocks_add_xx_0, '0', fft_vxx_0, '0'] +- [blocks_complex_to_mag_squared_0, '0', blocks_integrate_xx_0, '0'] +- [blocks_delay_0, '0', blocks_stream_to_vector_0_2, '0'] +- [blocks_delay_0_0, '0', blocks_stream_to_vector_0_0, '0'] +- [blocks_delay_0_1, '0', blocks_stream_to_vector_0_1, '0'] +- [blocks_head_0, '0', blocks_delay_0, '0'] +- [blocks_head_0, '0', blocks_delay_0_0, '0'] +- [blocks_head_0, '0', blocks_delay_0_1, '0'] +- [blocks_head_0, '0', blocks_stream_to_vector_0, '0'] +- [blocks_integrate_xx_0, '0', blocks_file_sink_0, '0'] +- [blocks_multiply_const_vxx_0, '0', blocks_add_xx_0, '0'] +- [blocks_multiply_const_vxx_0_0, '0', blocks_add_xx_0, '1'] +- [blocks_multiply_const_vxx_0_0_0, '0', blocks_add_xx_0, '2'] +- [blocks_multiply_const_vxx_0_0_0_0, '0', blocks_add_xx_0, '3'] +- [blocks_stream_to_vector_0, '0', blocks_multiply_const_vxx_0, '0'] +- [blocks_stream_to_vector_0_0, '0', blocks_multiply_const_vxx_0_0_0, '0'] +- [blocks_stream_to_vector_0_1, '0', blocks_multiply_const_vxx_0_0, '0'] +- [blocks_stream_to_vector_0_2, '0', blocks_multiply_const_vxx_0_0_0_0, '0'] +- [fft_vxx_0, '0', blocks_complex_to_mag_squared_0, '0'] + +metadata: + file_format: 1 + grc_version: 3.10.5.0 diff --git a/pfb.grc.orig b/pfb.grc.orig new file mode 100644 index 0000000..f197838 --- /dev/null +++ b/pfb.grc.orig @@ -0,0 +1,2821 @@ + + + + Fri Apr 26 15:43:14 2019 + + options + + author + + + + window_size + + + + category + [GRC Hier Blocks] + + + comment + + + + description + + + + _enabled + True + + + _coordinate + (8, 8) + + + _rotation + 0 + + + generate_options + no_gui + + + hier_block_src_path + .: + + + id + top_block + + + max_nouts + 0 + + + qt_qss_theme + + + + realtime_scheduling + + + + run_command + {python} -u {filename} + + + run_options + run + + + run + True + + + thread_safe_setters + + + + title + + + + + variable + + comment + + + + _enabled + True + + + _coordinate + (536, 12) + + + _rotation + 0 + + + id + custom_window + + + value + sinc*np.hamming(4*nchan) + + + + variable + + comment + + + + _enabled + True + + + _coordinate + (368, 12) + + + _rotation + 0 + + + id + sinc + + + value + np.sinc(sinc_sample_locations/np.pi) + + + + variable + + comment + + + + _enabled + True + + + _coordinate + (200, 12) + + + _rotation + 0 + + + id + sinc_sample_locations + + + value + np.arange(-np.pi*4/2.0, np.pi*4/2.0, np.pi/nchan) + + + + rtlsdr_source + + alias + + + + ant0 + + + + bb_gain0 + 30 + + + bw0 + 0 + + + dc_offset_mode0 + 0 + + + corr0 + 0 + + + freq0 + c_freq + + + gain_mode0 + False + + + if_gain0 + 30 + + + iq_balance_mode0 + 0 + + + gain0 + 30 + + + ant10 + + + + bb_gain10 + 20 + + + bw10 + 0 + + + dc_offset_mode10 + 0 + + + corr10 + 0 + + + freq10 + 100e6 + + + gain_mode10 + False + + + if_gain10 + 20 + + + iq_balance_mode10 + 0 + + + gain10 + 10 + + + ant11 + + + + bb_gain11 + 20 + + + bw11 + 0 + + + dc_offset_mode11 + 0 + + + corr11 + 0 + + + freq11 + 100e6 + + + gain_mode11 + False + + + if_gain11 + 20 + + + iq_balance_mode11 + 0 + + + gain11 + 10 + + + ant12 + + + + bb_gain12 + 20 + + + bw12 + 0 + + + dc_offset_mode12 + 0 + + + corr12 + 0 + + + freq12 + 100e6 + + + gain_mode12 + False + + + if_gain12 + 20 + + + iq_balance_mode12 + 0 + + + gain12 + 10 + + + ant13 + + + + bb_gain13 + 20 + + + bw13 + 0 + + + dc_offset_mode13 + 0 + + + corr13 + 0 + + + freq13 + 100e6 + + + gain_mode13 + False + + + if_gain13 + 20 + + + iq_balance_mode13 + 0 + + + gain13 + 10 + + + ant14 + + + + bb_gain14 + 20 + + + bw14 + 0 + + + dc_offset_mode14 + 0 + + + corr14 + 0 + + + freq14 + 100e6 + + + gain_mode14 + False + + + if_gain14 + 20 + + + iq_balance_mode14 + 0 + + + gain14 + 10 + + + ant15 + + + + bb_gain15 + 20 + + + bw15 + 0 + + + dc_offset_mode15 + 0 + + + corr15 + 0 + + + freq15 + 100e6 + + + gain_mode15 + False + + + if_gain15 + 20 + + + iq_balance_mode15 + 0 + + + gain15 + 10 + + + ant16 + + + + bb_gain16 + 20 + + + bw16 + 0 + + + dc_offset_mode16 + 0 + + + corr16 + 0 + + + freq16 + 100e6 + + + gain_mode16 + False + + + if_gain16 + 20 + + + iq_balance_mode16 + 0 + + + gain16 + 10 + + + ant17 + + + + bb_gain17 + 20 + + + bw17 + 0 + + + dc_offset_mode17 + 0 + + + corr17 + 0 + + + freq17 + 100e6 + + + gain_mode17 + False + + + if_gain17 + 20 + + + iq_balance_mode17 + 0 + + + gain17 + 10 + + + ant18 + + + + bb_gain18 + 20 + + + bw18 + 0 + + + dc_offset_mode18 + 0 + + + corr18 + 0 + + + freq18 + 100e6 + + + gain_mode18 + False + + + if_gain18 + 20 + + + iq_balance_mode18 + 0 + + + gain18 + 10 + + + ant19 + + + + bb_gain19 + 20 + + + bw19 + 0 + + + dc_offset_mode19 + 0 + + + corr19 + 0 + + + freq19 + 100e6 + + + gain_mode19 + False + + + if_gain19 + 20 + + + iq_balance_mode19 + 0 + + + gain19 + 10 + + + ant1 + + + + bb_gain1 + 20 + + + bw1 + 0 + + + dc_offset_mode1 + 0 + + + corr1 + 0 + + + freq1 + 100e6 + + + gain_mode1 + False + + + if_gain1 + 20 + + + iq_balance_mode1 + 0 + + + gain1 + 10 + + + ant20 + + + + bb_gain20 + 20 + + + bw20 + 0 + + + dc_offset_mode20 + 0 + + + corr20 + 0 + + + freq20 + 100e6 + + + gain_mode20 + False + + + if_gain20 + 20 + + + iq_balance_mode20 + 0 + + + gain20 + 10 + + + ant21 + + + + bb_gain21 + 20 + + + bw21 + 0 + + + dc_offset_mode21 + 0 + + + corr21 + 0 + + + freq21 + 100e6 + + + gain_mode21 + False + + + if_gain21 + 20 + + + iq_balance_mode21 + 0 + + + gain21 + 10 + + + ant22 + + + + bb_gain22 + 20 + + + bw22 + 0 + + + dc_offset_mode22 + 0 + + + corr22 + 0 + + + freq22 + 100e6 + + + gain_mode22 + False + + + if_gain22 + 20 + + + iq_balance_mode22 + 0 + + + gain22 + 10 + + + ant23 + + + + bb_gain23 + 20 + + + bw23 + 0 + + + dc_offset_mode23 + 0 + + + corr23 + 0 + + + freq23 + 100e6 + + + gain_mode23 + False + + + if_gain23 + 20 + + + iq_balance_mode23 + 0 + + + gain23 + 10 + + + ant24 + + + + bb_gain24 + 20 + + + bw24 + 0 + + + dc_offset_mode24 + 0 + + + corr24 + 0 + + + freq24 + 100e6 + + + gain_mode24 + False + + + if_gain24 + 20 + + + iq_balance_mode24 + 0 + + + gain24 + 10 + + + ant25 + + + + bb_gain25 + 20 + + + bw25 + 0 + + + dc_offset_mode25 + 0 + + + corr25 + 0 + + + freq25 + 100e6 + + + gain_mode25 + False + + + if_gain25 + 20 + + + iq_balance_mode25 + 0 + + + gain25 + 10 + + + ant26 + + + + bb_gain26 + 20 + + + bw26 + 0 + + + dc_offset_mode26 + 0 + + + corr26 + 0 + + + freq26 + 100e6 + + + gain_mode26 + False + + + if_gain26 + 20 + + + iq_balance_mode26 + 0 + + + gain26 + 10 + + + ant27 + + + + bb_gain27 + 20 + + + bw27 + 0 + + + dc_offset_mode27 + 0 + + + corr27 + 0 + + + freq27 + 100e6 + + + gain_mode27 + False + + + if_gain27 + 20 + + + iq_balance_mode27 + 0 + + + gain27 + 10 + + + ant28 + + + + bb_gain28 + 20 + + + bw28 + 0 + + + dc_offset_mode28 + 0 + + + corr28 + 0 + + + freq28 + 100e6 + + + gain_mode28 + False + + + if_gain28 + 20 + + + iq_balance_mode28 + 0 + + + gain28 + 10 + + + ant29 + + + + bb_gain29 + 20 + + + bw29 + 0 + + + dc_offset_mode29 + 0 + + + corr29 + 0 + + + freq29 + 100e6 + + + gain_mode29 + False + + + if_gain29 + 20 + + + iq_balance_mode29 + 0 + + + gain29 + 10 + + + ant2 + + + + bb_gain2 + 20 + + + bw2 + 0 + + + dc_offset_mode2 + 0 + + + corr2 + 0 + + + freq2 + 100e6 + + + gain_mode2 + False + + + if_gain2 + 20 + + + iq_balance_mode2 + 0 + + + gain2 + 10 + + + ant30 + + + + bb_gain30 + 20 + + + bw30 + 0 + + + dc_offset_mode30 + 0 + + + corr30 + 0 + + + freq30 + 100e6 + + + gain_mode30 + False + + + if_gain30 + 20 + + + iq_balance_mode30 + 0 + + + gain30 + 10 + + + ant31 + + + + bb_gain31 + 20 + + + bw31 + 0 + + + dc_offset_mode31 + 0 + + + corr31 + 0 + + + freq31 + 100e6 + + + gain_mode31 + False + + + if_gain31 + 20 + + + iq_balance_mode31 + 0 + + + gain31 + 10 + + + ant3 + + + + bb_gain3 + 20 + + + bw3 + 0 + + + dc_offset_mode3 + 0 + + + corr3 + 0 + + + freq3 + 100e6 + + + gain_mode3 + False + + + if_gain3 + 20 + + + iq_balance_mode3 + 0 + + + gain3 + 10 + + + ant4 + + + + bb_gain4 + 20 + + + bw4 + 0 + + + dc_offset_mode4 + 0 + + + corr4 + 0 + + + freq4 + 100e6 + + + gain_mode4 + False + + + if_gain4 + 20 + + + iq_balance_mode4 + 0 + + + gain4 + 10 + + + ant5 + + + + bb_gain5 + 20 + + + bw5 + 0 + + + dc_offset_mode5 + 0 + + + corr5 + 0 + + + freq5 + 100e6 + + + gain_mode5 + False + + + if_gain5 + 20 + + + iq_balance_mode5 + 0 + + + gain5 + 10 + + + ant6 + + + + bb_gain6 + 20 + + + bw6 + 0 + + + dc_offset_mode6 + 0 + + + corr6 + 0 + + + freq6 + 100e6 + + + gain_mode6 + False + + + if_gain6 + 20 + + + iq_balance_mode6 + 0 + + + gain6 + 10 + + + ant7 + + + + bb_gain7 + 20 + + + bw7 + 0 + + + dc_offset_mode7 + 0 + + + corr7 + 0 + + + freq7 + 100e6 + + + gain_mode7 + False + + + if_gain7 + 20 + + + iq_balance_mode7 + 0 + + + gain7 + 10 + + + ant8 + + + + bb_gain8 + 20 + + + bw8 + 0 + + + dc_offset_mode8 + 0 + + + corr8 + 0 + + + freq8 + 100e6 + + + gain_mode8 + False + + + if_gain8 + 20 + + + iq_balance_mode8 + 0 + + + gain8 + 10 + + + ant9 + + + + bb_gain9 + 20 + + + bw9 + 0 + + + dc_offset_mode9 + 0 + + + corr9 + 0 + + + freq9 + 100e6 + + + gain_mode9 + False + + + if_gain9 + 20 + + + iq_balance_mode9 + 0 + + + gain9 + 10 + + + comment + + + + affinity + + + + args + + + + _enabled + 1 + + + _coordinate + (8, 348) + + + _rotation + 0 + + + id + RTL820T + + + maxoutbuf + 0 + + + clock_source0 + + + + time_source0 + + + + clock_source1 + + + + time_source1 + + + + clock_source2 + + + + time_source2 + + + + clock_source3 + + + + time_source3 + + + + clock_source4 + + + + time_source4 + + + + clock_source5 + + + + time_source5 + + + + clock_source6 + + + + time_source6 + + + + clock_source7 + + + + time_source7 + + + + minoutbuf + 0 + + + nchan + 1 + + + num_mboards + 1 + + + type + fc32 + + + sample_rate + samp_rate + + + sync + + + + + blocks_add_xx + + alias + + + + comment + + + + affinity + + + + _enabled + True + + + _coordinate + (992, 136) + + + _rotation + 0 + + + id + blocks_add_xx_0 + + + type + complex + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + num_inputs + 4 + + + vlen + nchan + + + + blocks_complex_to_mag_squared + + alias + + + + comment + + + + affinity + + + + _enabled + 1 + + + _coordinate + (592, 444) + + + _rotation + 0 + + + id + blocks_complex_to_mag_squared_0 + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + vlen + nchan + + + + blocks_delay + + alias + + + + comment + + + + affinity + + + + delay + nchan*3 + + + _enabled + True + + + _coordinate + (416, 276) + + + _rotation + 0 + + + id + blocks_delay_0 + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + num_ports + 1 + + + type + complex + + + vlen + 1 + + + + blocks_delay + + alias + + + + comment + + + + affinity + + + + delay + nchan*2 + + + _enabled + True + + + _coordinate + (416, 212) + + + _rotation + 0 + + + id + blocks_delay_0_0 + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + num_ports + 1 + + + type + complex + + + vlen + 1 + + + + blocks_delay + + alias + + + + comment + + + + affinity + + + + delay + nchan + + + _enabled + True + + + _coordinate + (416, 148) + + + _rotation + 0 + + + id + blocks_delay_0_1 + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + num_ports + 1 + + + type + complex + + + vlen + 1 + + + + blocks_file_sink + + append + True + + + alias + + + + comment + + + + affinity + + + + _enabled + 1 + + + file + observation.dat + + + _coordinate + (960, 420) + + + _rotation + 0 + + + id + blocks_file_sink_0 + + + type + float + + + unbuffered + False + + + vlen + nchan + + + + blocks_head + + alias + + + + comment + + + + affinity + + + + _enabled + True + + + _coordinate + (240, 84) + + + _rotation + 0 + + + id + blocks_head_0 + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + num_items + int(obs_time*samp_rate) + + + type + complex + + + vlen + 1 + + + + blocks_integrate_xx + + alias + + + + comment + + + + affinity + + + + decim + nbin + + + _enabled + 1 + + + _coordinate + (784, 436) + + + _rotation + 0 + + + id + blocks_integrate_xx_0 + + + type + float + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + vlen + nchan + + + + blocks_multiply_const_vxx + + alias + + + + comment + + + + const + custom_window[-nchan:] + + + affinity + + + + _enabled + True + + + _coordinate + (720, 76) + + + _rotation + 0 + + + id + blocks_multiply_const_vxx_0 + + + type + complex + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + vlen + nchan + + + + blocks_multiply_const_vxx + + alias + + + + comment + + + + const + custom_window[2*nchan:3*nchan] + + + affinity + + + + _enabled + True + + + _coordinate + (720, 140) + + + _rotation + 0 + + + id + blocks_multiply_const_vxx_0_0 + + + type + complex + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + vlen + nchan + + + + blocks_multiply_const_vxx + + alias + + + + comment + + + + const + custom_window[nchan:2*nchan] + + + affinity + + + + _enabled + True + + + _coordinate + (720, 204) + + + _rotation + 0 + + + id + blocks_multiply_const_vxx_0_0_0 + + + type + complex + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + vlen + nchan + + + + blocks_multiply_const_vxx + + alias + + + + comment + + + + const + custom_window[0:nchan] + + + affinity + + + + _enabled + True + + + _coordinate + (720, 268) + + + _rotation + 0 + + + id + blocks_multiply_const_vxx_0_0_0_0 + + + type + complex + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + vlen + nchan + + + + blocks_stream_to_vector + + alias + + + + comment + + + + affinity + + + + _enabled + 1 + + + _coordinate + (552, 84) + + + _rotation + 0 + + + id + blocks_stream_to_vector_0 + + + type + complex + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + num_items + nchan + + + vlen + 1 + + + + blocks_stream_to_vector + + alias + + + + comment + + + + affinity + + + + _enabled + 1 + + + _coordinate + (552, 212) + + + _rotation + 0 + + + id + blocks_stream_to_vector_0_0 + + + type + complex + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + num_items + nchan + + + vlen + 1 + + + + blocks_stream_to_vector + + alias + + + + comment + + + + affinity + + + + _enabled + 1 + + + _coordinate + (552, 148) + + + _rotation + 0 + + + id + blocks_stream_to_vector_0_1 + + + type + complex + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + num_items + nchan + + + vlen + 1 + + + + blocks_stream_to_vector + + alias + + + + comment + + + + affinity + + + + _enabled + 1 + + + _coordinate + (552, 276) + + + _rotation + 0 + + + id + blocks_stream_to_vector_0_2 + + + type + complex + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + num_items + nchan + + + vlen + 1 + + + + parameter + + alias + + + + comment + + + + _enabled + True + + + _coordinate + (8, 84) + + + _rotation + 0 + + + id + c_freq + + + label + + + + short_id + + + + type + eng_float + + + value + 1420000000 + + + + fft_vxx + + alias + + + + comment + + + + affinity + + + + _enabled + 1 + + + fft_size + nchan + + + forward + True + + + _coordinate + (352, 412) + + + _rotation + 0 + + + id + fft_vxx_0 + + + type + complex + + + maxoutbuf + 0 + + + minoutbuf + 0 + + + nthreads + 1 + + + shift + True + + + window + window.blackmanharris(nchan) + + + + import + + alias + + + + comment + + + + _enabled + True + + + _coordinate + (712, 12) + + + _rotation + 0 + + + id + import_0 + + + import + import numpy as np + + + + parameter + + alias + + + + comment + + + + _enabled + True + + + _coordinate + (104, 164) + + + _rotation + 0 + + + id + nbin + + + label + + + + short_id + + + + type + intx + + + value + 1000 + + + + parameter + + alias + + + + comment + + + + _enabled + True + + + _coordinate + (8, 164) + + + _rotation + 0 + + + id + nchan + + + label + + + + short_id + + + + type + intx + + + value + 1024 + + + + parameter + + alias + + + + comment + + + + _enabled + True + + + _coordinate + (8, 244) + + + _rotation + 0 + + + id + obs_time + + + label + + + + short_id + + + + type + eng_float + + + value + 60 + + + + parameter + + alias + + + + comment + + + + _enabled + True + + + _coordinate + (96, 84) + + + _rotation + 0 + + + id + samp_rate + + + label + + + + short_id + + + + type + eng_float + + + value + 2400000 + + + + RTL820T + blocks_head_0 + 0 + 0 + + + blocks_add_xx_0 + fft_vxx_0 + 0 + 0 + + + blocks_complex_to_mag_squared_0 + blocks_integrate_xx_0 + 0 + 0 + + + blocks_delay_0 + blocks_stream_to_vector_0_2 + 0 + 0 + + + blocks_delay_0_0 + blocks_stream_to_vector_0_0 + 0 + 0 + + + blocks_delay_0_1 + blocks_stream_to_vector_0_1 + 0 + 0 + + + blocks_head_0 + blocks_delay_0 + 0 + 0 + + + blocks_head_0 + blocks_delay_0_0 + 0 + 0 + + + blocks_head_0 + blocks_delay_0_1 + 0 + 0 + + + blocks_head_0 + blocks_stream_to_vector_0 + 0 + 0 + + + blocks_integrate_xx_0 + blocks_file_sink_0 + 0 + 0 + + + blocks_multiply_const_vxx_0 + blocks_add_xx_0 + 0 + 0 + + + blocks_multiply_const_vxx_0_0 + blocks_add_xx_0 + 0 + 1 + + + blocks_multiply_const_vxx_0_0_0 + blocks_add_xx_0 + 0 + 2 + + + blocks_multiply_const_vxx_0_0_0_0 + blocks_add_xx_0 + 0 + 3 + + + blocks_stream_to_vector_0 + blocks_multiply_const_vxx_0 + 0 + 0 + + + blocks_stream_to_vector_0_0 + blocks_multiply_const_vxx_0_0_0 + 0 + 0 + + + blocks_stream_to_vector_0_1 + blocks_multiply_const_vxx_0_0 + 0 + 0 + + + blocks_stream_to_vector_0_2 + blocks_multiply_const_vxx_0_0_0_0 + 0 + 0 + + + fft_vxx_0 + blocks_complex_to_mag_squared_0 + 0 + 0 + + diff --git a/top_block.py b/top_block.py old mode 100644 new mode 100755 index c395938..943dbd0 --- a/top_block.py +++ b/top_block.py @@ -1,29 +1,34 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # -*- coding: utf-8 -*- -################################################## + +# +# SPDX-License-Identifier: GPL-3.0 +# # GNU Radio Python Flow Graph # Title: Top Block -# Generated: Mon Oct 28 01:00:35 2019 -################################################## - +# GNU Radio version: 3.10.5.0 from gnuradio import blocks -from gnuradio import eng_notation from gnuradio import fft -from gnuradio import gr -from gnuradio.eng_option import eng_option from gnuradio.fft import window +from gnuradio import gr from gnuradio.filter import firdes -from optparse import OptionParser +import sys +import signal +from argparse import ArgumentParser +from gnuradio.eng_arg import eng_float, intx +from gnuradio import eng_notation import numpy as np import osmosdr import time + + class top_block(gr.top_block): def __init__(self, c_freq=1420000000, nbin=1000, nchan=1024, obs_time=60, samp_rate=2400000): - gr.top_block.__init__(self, "Top Block") + gr.top_block.__init__(self, "Top Block", catch_exceptions=True) ################################################## # Parameters @@ -44,34 +49,37 @@ class top_block(gr.top_block): ################################################## # Blocks ################################################## - self.fft_vxx_0 = fft.fft_vcc(nchan, True, (window.blackmanharris(nchan)), True, 1) + self.fft_vxx_0 = fft.fft_vcc(nchan, True, window.blackmanharris(nchan), True, 1) self.blocks_stream_to_vector_0_2 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, nchan) self.blocks_stream_to_vector_0_1 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, nchan) self.blocks_stream_to_vector_0_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, nchan) self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, nchan) - self.blocks_multiply_const_vxx_0_0_0_0 = blocks.multiply_const_vcc((custom_window[0:nchan])) - self.blocks_multiply_const_vxx_0_0_0 = blocks.multiply_const_vcc((custom_window[nchan:2*nchan])) - self.blocks_multiply_const_vxx_0_0 = blocks.multiply_const_vcc((custom_window[2*nchan:3*nchan])) - self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc((custom_window[-nchan:])) + self.blocks_multiply_const_vxx_0_0_0_0 = blocks.multiply_const_vcc(custom_window[0:nchan]) + self.blocks_multiply_const_vxx_0_0_0 = blocks.multiply_const_vcc(custom_window[nchan:2*nchan]) + self.blocks_multiply_const_vxx_0_0 = blocks.multiply_const_vcc(custom_window[2*nchan:3*nchan]) + self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc(custom_window[-nchan:]) self.blocks_integrate_xx_0 = blocks.integrate_ff(nbin, nchan) - self.blocks_head_0 = blocks.head(gr.sizeof_gr_complex*1, int(obs_time*samp_rate)) + self.blocks_head_0 = blocks.head(gr.sizeof_gr_complex*1, (int(obs_time*samp_rate))) self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float*nchan, 'observation.dat', True) self.blocks_file_sink_0.set_unbuffered(False) self.blocks_delay_0_1 = blocks.delay(gr.sizeof_gr_complex*1, nchan) - self.blocks_delay_0_0 = blocks.delay(gr.sizeof_gr_complex*1, nchan*2) - self.blocks_delay_0 = blocks.delay(gr.sizeof_gr_complex*1, nchan*3) + self.blocks_delay_0_0 = blocks.delay(gr.sizeof_gr_complex*1, (nchan*2)) + self.blocks_delay_0 = blocks.delay(gr.sizeof_gr_complex*1, (nchan*3)) self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(nchan) self.blocks_add_xx_0 = blocks.add_vcc(nchan) - self.RTL820T = osmosdr.source( args="numchan=" + str(1) + " " + '' ) + self.RTL820T = osmosdr.source( + args="numchan=" + str(1) + " " + '' + ) + self.RTL820T.set_time_unknown_pps(osmosdr.time_spec_t()) self.RTL820T.set_sample_rate(samp_rate) self.RTL820T.set_center_freq(c_freq, 0) self.RTL820T.set_freq_corr(0, 0) self.RTL820T.set_dc_offset_mode(0, 0) self.RTL820T.set_iq_balance_mode(0, 0) self.RTL820T.set_gain_mode(False, 0) - self.RTL820T.set_gain(30, 0) - self.RTL820T.set_if_gain(30, 0) - self.RTL820T.set_bb_gain(30, 0) + self.RTL820T.set_gain(10, 0) + self.RTL820T.set_if_gain(10, 0) + self.RTL820T.set_bb_gain(10, 0) self.RTL820T.set_antenna('', 0) self.RTL820T.set_bandwidth(0, 0) @@ -100,6 +108,7 @@ class top_block(gr.top_block): self.connect((self.blocks_stream_to_vector_0_2, 0), (self.blocks_multiply_const_vxx_0_0_0_0, 0)) self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0)) + def get_c_freq(self): return self.c_freq @@ -120,28 +129,28 @@ class top_block(gr.top_block): self.nchan = nchan self.set_custom_window(self.sinc*np.hamming(4*self.nchan)) self.set_sinc_sample_locations(np.arange(-np.pi*4/2.0, np.pi*4/2.0, np.pi/self.nchan)) - self.blocks_multiply_const_vxx_0_0_0_0.set_k((self.custom_window[0:self.nchan])) - self.blocks_multiply_const_vxx_0_0_0.set_k((self.custom_window[self.nchan:2*self.nchan])) - self.blocks_multiply_const_vxx_0_0.set_k((self.custom_window[2*self.nchan:3*self.nchan])) - self.blocks_multiply_const_vxx_0.set_k((self.custom_window[-self.nchan:])) - self.blocks_delay_0_1.set_dly(self.nchan) - self.blocks_delay_0_0.set_dly(self.nchan*2) - self.blocks_delay_0.set_dly(self.nchan*3) + self.blocks_delay_0.set_dly(int((self.nchan*3))) + self.blocks_delay_0_0.set_dly(int((self.nchan*2))) + self.blocks_delay_0_1.set_dly(int(self.nchan)) + self.blocks_multiply_const_vxx_0.set_k(self.custom_window[-self.nchan:]) + self.blocks_multiply_const_vxx_0_0.set_k(self.custom_window[2*self.nchan:3*self.nchan]) + self.blocks_multiply_const_vxx_0_0_0.set_k(self.custom_window[self.nchan:2*self.nchan]) + self.blocks_multiply_const_vxx_0_0_0_0.set_k(self.custom_window[0:self.nchan]) def get_obs_time(self): return self.obs_time def set_obs_time(self, obs_time): self.obs_time = obs_time - self.blocks_head_0.set_length(int(self.obs_time*self.samp_rate)) + self.blocks_head_0.set_length((int(self.obs_time*self.samp_rate))) def get_samp_rate(self): return self.samp_rate def set_samp_rate(self, samp_rate): self.samp_rate = samp_rate - self.blocks_head_0.set_length(int(self.obs_time*self.samp_rate)) self.RTL820T.set_sample_rate(self.samp_rate) + self.blocks_head_0.set_length((int(self.obs_time*self.samp_rate))) def get_sinc_sample_locations(self): return self.sinc_sample_locations @@ -163,38 +172,49 @@ class top_block(gr.top_block): def set_custom_window(self, custom_window): self.custom_window = custom_window - self.blocks_multiply_const_vxx_0_0_0_0.set_k((self.custom_window[0:self.nchan])) - self.blocks_multiply_const_vxx_0_0_0.set_k((self.custom_window[self.nchan:2*self.nchan])) - self.blocks_multiply_const_vxx_0_0.set_k((self.custom_window[2*self.nchan:3*self.nchan])) - self.blocks_multiply_const_vxx_0.set_k((self.custom_window[-self.nchan:])) + self.blocks_multiply_const_vxx_0.set_k(self.custom_window[-self.nchan:]) + self.blocks_multiply_const_vxx_0_0.set_k(self.custom_window[2*self.nchan:3*self.nchan]) + self.blocks_multiply_const_vxx_0_0_0.set_k(self.custom_window[self.nchan:2*self.nchan]) + self.blocks_multiply_const_vxx_0_0_0_0.set_k(self.custom_window[0:self.nchan]) + def argument_parser(): - parser = OptionParser(usage="%prog: [options]", option_class=eng_option) - parser.add_option( - "", "--c-freq", dest="c_freq", type="eng_float", default=eng_notation.num_to_str(1420000000), - help="Set c_freq [default=%default]") - parser.add_option( - "", "--nbin", dest="nbin", type="intx", default=1000, - help="Set nbin [default=%default]") - parser.add_option( - "", "--nchan", dest="nchan", type="intx", default=1024, - help="Set nchan [default=%default]") - parser.add_option( - "", "--obs-time", dest="obs_time", type="eng_float", default=eng_notation.num_to_str(60), - help="Set obs_time [default=%default]") - parser.add_option( - "", "--samp-rate", dest="samp_rate", type="eng_float", default=eng_notation.num_to_str(2400000), - help="Set samp_rate [default=%default]") + parser = ArgumentParser() + parser.add_argument( + "--c-freq", dest="c_freq", type=eng_float, default=eng_notation.num_to_str(float(1420000000)), + help="Set c_freq [default=%(default)r]") + parser.add_argument( + "--nbin", dest="nbin", type=intx, default=1000, + help="Set nbin [default=%(default)r]") + parser.add_argument( + "--nchan", dest="nchan", type=intx, default=1024, + help="Set nchan [default=%(default)r]") + parser.add_argument( + "--obs-time", dest="obs_time", type=eng_float, default=eng_notation.num_to_str(float(60)), + help="Set obs_time [default=%(default)r]") + parser.add_argument( + "--samp-rate", dest="samp_rate", type=eng_float, default=eng_notation.num_to_str(float(2400000)), + help="Set samp_rate [default=%(default)r]") return parser def main(top_block_cls=top_block, options=None): if options is None: - options, _ = argument_parser().parse_args() - + options = argument_parser().parse_args() tb = top_block_cls(c_freq=options.c_freq, nbin=options.nbin, nchan=options.nchan, obs_time=options.obs_time, samp_rate=options.samp_rate) + + 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() diff --git a/top_block.py.orig b/top_block.py.orig new file mode 100644 index 0000000..c395938 --- /dev/null +++ b/top_block.py.orig @@ -0,0 +1,202 @@ +#!/usr/bin/env python2 +# -*- coding: utf-8 -*- +################################################## +# GNU Radio Python Flow Graph +# Title: Top Block +# Generated: Mon Oct 28 01:00:35 2019 +################################################## + + +from gnuradio import blocks +from gnuradio import eng_notation +from gnuradio import fft +from gnuradio import gr +from gnuradio.eng_option import eng_option +from gnuradio.fft import window +from gnuradio.filter import firdes +from optparse import OptionParser +import numpy as np +import osmosdr +import time + + +class top_block(gr.top_block): + + def __init__(self, c_freq=1420000000, nbin=1000, nchan=1024, obs_time=60, samp_rate=2400000): + gr.top_block.__init__(self, "Top Block") + + ################################################## + # Parameters + ################################################## + self.c_freq = c_freq + self.nbin = nbin + self.nchan = nchan + self.obs_time = obs_time + self.samp_rate = samp_rate + + ################################################## + # Variables + ################################################## + self.sinc_sample_locations = sinc_sample_locations = np.arange(-np.pi*4/2.0, np.pi*4/2.0, np.pi/nchan) + self.sinc = sinc = np.sinc(sinc_sample_locations/np.pi) + self.custom_window = custom_window = sinc*np.hamming(4*nchan) + + ################################################## + # Blocks + ################################################## + self.fft_vxx_0 = fft.fft_vcc(nchan, True, (window.blackmanharris(nchan)), True, 1) + self.blocks_stream_to_vector_0_2 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, nchan) + self.blocks_stream_to_vector_0_1 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, nchan) + self.blocks_stream_to_vector_0_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, nchan) + self.blocks_stream_to_vector_0 = blocks.stream_to_vector(gr.sizeof_gr_complex*1, nchan) + self.blocks_multiply_const_vxx_0_0_0_0 = blocks.multiply_const_vcc((custom_window[0:nchan])) + self.blocks_multiply_const_vxx_0_0_0 = blocks.multiply_const_vcc((custom_window[nchan:2*nchan])) + self.blocks_multiply_const_vxx_0_0 = blocks.multiply_const_vcc((custom_window[2*nchan:3*nchan])) + self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc((custom_window[-nchan:])) + self.blocks_integrate_xx_0 = blocks.integrate_ff(nbin, nchan) + self.blocks_head_0 = blocks.head(gr.sizeof_gr_complex*1, int(obs_time*samp_rate)) + self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float*nchan, 'observation.dat', True) + self.blocks_file_sink_0.set_unbuffered(False) + self.blocks_delay_0_1 = blocks.delay(gr.sizeof_gr_complex*1, nchan) + self.blocks_delay_0_0 = blocks.delay(gr.sizeof_gr_complex*1, nchan*2) + self.blocks_delay_0 = blocks.delay(gr.sizeof_gr_complex*1, nchan*3) + self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(nchan) + self.blocks_add_xx_0 = blocks.add_vcc(nchan) + self.RTL820T = osmosdr.source( args="numchan=" + str(1) + " " + '' ) + self.RTL820T.set_sample_rate(samp_rate) + self.RTL820T.set_center_freq(c_freq, 0) + self.RTL820T.set_freq_corr(0, 0) + self.RTL820T.set_dc_offset_mode(0, 0) + self.RTL820T.set_iq_balance_mode(0, 0) + self.RTL820T.set_gain_mode(False, 0) + self.RTL820T.set_gain(30, 0) + self.RTL820T.set_if_gain(30, 0) + self.RTL820T.set_bb_gain(30, 0) + self.RTL820T.set_antenna('', 0) + self.RTL820T.set_bandwidth(0, 0) + + + ################################################## + # Connections + ################################################## + self.connect((self.RTL820T, 0), (self.blocks_head_0, 0)) + self.connect((self.blocks_add_xx_0, 0), (self.fft_vxx_0, 0)) + self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.blocks_integrate_xx_0, 0)) + self.connect((self.blocks_delay_0, 0), (self.blocks_stream_to_vector_0_2, 0)) + self.connect((self.blocks_delay_0_0, 0), (self.blocks_stream_to_vector_0_0, 0)) + self.connect((self.blocks_delay_0_1, 0), (self.blocks_stream_to_vector_0_1, 0)) + self.connect((self.blocks_head_0, 0), (self.blocks_delay_0, 0)) + self.connect((self.blocks_head_0, 0), (self.blocks_delay_0_0, 0)) + self.connect((self.blocks_head_0, 0), (self.blocks_delay_0_1, 0)) + self.connect((self.blocks_head_0, 0), (self.blocks_stream_to_vector_0, 0)) + self.connect((self.blocks_integrate_xx_0, 0), (self.blocks_file_sink_0, 0)) + self.connect((self.blocks_multiply_const_vxx_0, 0), (self.blocks_add_xx_0, 0)) + self.connect((self.blocks_multiply_const_vxx_0_0, 0), (self.blocks_add_xx_0, 1)) + self.connect((self.blocks_multiply_const_vxx_0_0_0, 0), (self.blocks_add_xx_0, 2)) + self.connect((self.blocks_multiply_const_vxx_0_0_0_0, 0), (self.blocks_add_xx_0, 3)) + self.connect((self.blocks_stream_to_vector_0, 0), (self.blocks_multiply_const_vxx_0, 0)) + self.connect((self.blocks_stream_to_vector_0_0, 0), (self.blocks_multiply_const_vxx_0_0_0, 0)) + self.connect((self.blocks_stream_to_vector_0_1, 0), (self.blocks_multiply_const_vxx_0_0, 0)) + self.connect((self.blocks_stream_to_vector_0_2, 0), (self.blocks_multiply_const_vxx_0_0_0_0, 0)) + self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0)) + + def get_c_freq(self): + return self.c_freq + + def set_c_freq(self, c_freq): + self.c_freq = c_freq + self.RTL820T.set_center_freq(self.c_freq, 0) + + def get_nbin(self): + return self.nbin + + def set_nbin(self, nbin): + self.nbin = nbin + + def get_nchan(self): + return self.nchan + + def set_nchan(self, nchan): + self.nchan = nchan + self.set_custom_window(self.sinc*np.hamming(4*self.nchan)) + self.set_sinc_sample_locations(np.arange(-np.pi*4/2.0, np.pi*4/2.0, np.pi/self.nchan)) + self.blocks_multiply_const_vxx_0_0_0_0.set_k((self.custom_window[0:self.nchan])) + self.blocks_multiply_const_vxx_0_0_0.set_k((self.custom_window[self.nchan:2*self.nchan])) + self.blocks_multiply_const_vxx_0_0.set_k((self.custom_window[2*self.nchan:3*self.nchan])) + self.blocks_multiply_const_vxx_0.set_k((self.custom_window[-self.nchan:])) + self.blocks_delay_0_1.set_dly(self.nchan) + self.blocks_delay_0_0.set_dly(self.nchan*2) + self.blocks_delay_0.set_dly(self.nchan*3) + + def get_obs_time(self): + return self.obs_time + + def set_obs_time(self, obs_time): + self.obs_time = obs_time + self.blocks_head_0.set_length(int(self.obs_time*self.samp_rate)) + + def get_samp_rate(self): + return self.samp_rate + + def set_samp_rate(self, samp_rate): + self.samp_rate = samp_rate + self.blocks_head_0.set_length(int(self.obs_time*self.samp_rate)) + self.RTL820T.set_sample_rate(self.samp_rate) + + def get_sinc_sample_locations(self): + return self.sinc_sample_locations + + def set_sinc_sample_locations(self, sinc_sample_locations): + self.sinc_sample_locations = sinc_sample_locations + self.set_sinc(np.sinc(self.sinc_sample_locations/np.pi)) + + def get_sinc(self): + return self.sinc + + def set_sinc(self, sinc): + self.sinc = sinc + self.set_custom_window(self.sinc*np.hamming(4*self.nchan)) + self.set_sinc(np.sinc(self.sinc_sample_locations/np.pi)) + + def get_custom_window(self): + return self.custom_window + + def set_custom_window(self, custom_window): + self.custom_window = custom_window + self.blocks_multiply_const_vxx_0_0_0_0.set_k((self.custom_window[0:self.nchan])) + self.blocks_multiply_const_vxx_0_0_0.set_k((self.custom_window[self.nchan:2*self.nchan])) + self.blocks_multiply_const_vxx_0_0.set_k((self.custom_window[2*self.nchan:3*self.nchan])) + self.blocks_multiply_const_vxx_0.set_k((self.custom_window[-self.nchan:])) + + +def argument_parser(): + parser = OptionParser(usage="%prog: [options]", option_class=eng_option) + parser.add_option( + "", "--c-freq", dest="c_freq", type="eng_float", default=eng_notation.num_to_str(1420000000), + help="Set c_freq [default=%default]") + parser.add_option( + "", "--nbin", dest="nbin", type="intx", default=1000, + help="Set nbin [default=%default]") + parser.add_option( + "", "--nchan", dest="nchan", type="intx", default=1024, + help="Set nchan [default=%default]") + parser.add_option( + "", "--obs-time", dest="obs_time", type="eng_float", default=eng_notation.num_to_str(60), + help="Set obs_time [default=%default]") + parser.add_option( + "", "--samp-rate", dest="samp_rate", type="eng_float", default=eng_notation.num_to_str(2400000), + help="Set samp_rate [default=%default]") + return parser + + +def main(top_block_cls=top_block, options=None): + if options is None: + options, _ = argument_parser().parse_args() + + tb = top_block_cls(c_freq=options.c_freq, nbin=options.nbin, nchan=options.nchan, obs_time=options.obs_time, samp_rate=options.samp_rate) + tb.start() + tb.wait() + + +if __name__ == '__main__': + main()