def __init__(self): gr.top_block.__init__(self, "Dttsprx") ################################################## # Variables ################################################## self.samp_rate = samp_rate = 8000000 ################################################## # Blocks ################################################## self.low_pass_filter_0 = filter.fir_filter_ccf(int(samp_rate/48000), firdes.low_pass( 1, samp_rate, 48000, 1000, firdes.WIN_HAMMING, 6.76)) self.blocks_interleaved_char_to_complex_0 = blocks.interleaved_char_to_complex(False) self.blocks_file_source_0 = blocks.file_source(gr.sizeof_char*1, "/tmp/iqdata", False) self.blocks_complex_to_float_0 = blocks.complex_to_float(1) self.audio_sink_0 = audio.sink(48000, "", True) ################################################## # Connections ################################################## self.connect((self.blocks_complex_to_float_0, 1), (self.audio_sink_0, 1)) self.connect((self.blocks_complex_to_float_0, 0), (self.audio_sink_0, 0)) self.connect((self.blocks_file_source_0, 0), (self.blocks_interleaved_char_to_complex_0, 0)) self.connect((self.blocks_interleaved_char_to_complex_0, 0), (self.low_pass_filter_0, 0)) self.connect((self.low_pass_filter_0, 0), (self.blocks_complex_to_float_0, 0))
def __init__(self): gr.top_block.__init__(self) self.samp_rate = samp_rate = 32000 #parse the options parser = OptionParser(option_class=eng_option) parser.add_option("--inputfile", type="string", default="/tmp/arfcn.bin", help="set the input file") (options, args) = parser.parse_args () fichero_entrada = options.inputfile self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc((1.0/128, )) self.blocks_interleaved_char_to_complex_0 = blocks.interleaved_char_to_complex(False) self.blocks_file_source_0 = blocks.file_source(gr.sizeof_char*1, fichero_entrada, False) self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_gr_complex*1, "/opt/airprobe-hopping/gsm-receiver/src/python/out/out.cf", False) self.blocks_file_sink_0.set_unbuffered(False) self.connect((self.blocks_file_source_0, 0), (self.blocks_interleaved_char_to_complex_0, 0)) self.connect((self.blocks_interleaved_char_to_complex_0, 0), (self.blocks_multiply_const_vxx_0, 0)) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.blocks_file_sink_0, 0))
def __init__(self): gr.top_block.__init__(self, "Top Block") Qt.QWidget.__init__(self) self.setWindowTitle("Top Block") try: self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc')) except: pass self.top_scroll_layout = Qt.QVBoxLayout() self.setLayout(self.top_scroll_layout) self.top_scroll = Qt.QScrollArea() self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame) self.top_scroll_layout.addWidget(self.top_scroll) self.top_scroll.setWidgetResizable(True) self.top_widget = Qt.QWidget() self.top_scroll.setWidget(self.top_widget) self.top_layout = Qt.QVBoxLayout(self.top_widget) self.top_grid_layout = Qt.QGridLayout() self.top_layout.addLayout(self.top_grid_layout) self.settings = Qt.QSettings("GNU Radio", "top_block") self.restoreGeometry(self.settings.value("geometry").toByteArray()) ################################################## # Variables ################################################## self.samp_rate = samp_rate = 32000 ################################################## # Blocks ################################################## self.qtgui_sink_x_0_0 = qtgui.sink_c( 1024, #fftsize firdes.WIN_BLACKMAN_hARRIS, #wintype 0, #fc samp_rate, #bw "", #name True, #plotfreq True, #plotwaterfall True, #plottime True, #plotconst ) self.qtgui_sink_x_0_0.set_update_time(1.0 / 10) self._qtgui_sink_x_0_0_win = sip.wrapinstance( self.qtgui_sink_x_0_0.pyqwidget(), Qt.QWidget) self.top_layout.addWidget(self._qtgui_sink_x_0_0_win) self.qtgui_sink_x_0_0.enable_rf_freq(False) self.qtgui_sink_x_0 = qtgui.sink_c( 1024, #fftsize firdes.WIN_BLACKMAN_hARRIS, #wintype 0, #fc samp_rate, #bw "", #name True, #plotfreq True, #plotwaterfall True, #plottime True, #plotconst ) self.qtgui_sink_x_0.set_update_time(1.0 / 10) self._qtgui_sink_x_0_win = sip.wrapinstance( self.qtgui_sink_x_0.pyqwidget(), Qt.QWidget) self.top_layout.addWidget(self._qtgui_sink_x_0_win) self.qtgui_sink_x_0.enable_rf_freq(False) self.digital_pn_correlator_cc_0 = digital.pn_correlator_cc(9, 1, 56) self.blocks_throttle_0 = blocks.throttle(gr.sizeof_char * 1, samp_rate, True) self.blocks_interleaved_char_to_complex_0 = blocks.interleaved_char_to_complex( False) self.analog_random_source_x_0 = blocks.vector_source_b( map(int, numpy.random.randint(0, 2, 1000)), True) ################################################## # Connections ################################################## self.connect((self.analog_random_source_x_0, 0), (self.blocks_throttle_0, 0)) self.connect((self.blocks_interleaved_char_to_complex_0, 0), (self.digital_pn_correlator_cc_0, 0)) self.connect((self.blocks_interleaved_char_to_complex_0, 0), (self.qtgui_sink_x_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.blocks_interleaved_char_to_complex_0, 0)) self.connect((self.digital_pn_correlator_cc_0, 0), (self.qtgui_sink_x_0_0, 0))
def __init__(self, filenames, dev_addrs, onebit, iq, noise, mix, gain, fs, fc, unint, sync_pps): gr.top_block.__init__(self) if mix: raise NotImplementedError("TODO: Hilbert remix mode not implemented.") uhd_sinks = [ uhd.usrp_sink(",".join( [addr, "send_frame_size=32768,num_send_frames=128"]), uhd.stream_args( cpu_format="fc32", otwformat="sc8", channels=[0])) for addr in dev_addrs] for sink in uhd_sinks: sink.set_clock_rate(fs*2, uhd.ALL_MBOARDS) sink.set_samp_rate(fs) sink.set_center_freq(fc, 0) sink.set_gain(gain, 0) # TODO Use offset tuning? if sync_pps: sink.set_clock_source("external") # 10 MHz sink.set_time_source("external") # PPS if unint: if noise or onebit or not iq: raise NotImplementedError("TODO: RX channel-interleaved mode only " "supported for noiseless 8-bit complex.") BLOCK_N=16*1024*1024 demux = blocks.vector_to_streams(2, len(uhd_sinks)) self.connect(blocks.file_source(2*len(uhd_sinks)*BLOCK_N, filenames[0], False), blocks.vector_to_stream(2*len(uhd_sinks), BLOCK_N), demux) for ix, sink in enumerate(uhd_sinks): self.connect((demux, ix), blocks.vector_to_stream(1, 2), blocks.interleaved_char_to_complex(), # [-128.0, +127.0] blocks.multiply_const_cc(1.0/1024), # [-0.125, 0.125) # blocks.vector_to_stream(8, 16*1024), sink) else: file_srcs = [blocks.file_source(gr.sizeof_char*1, f, False) for f in filenames] for src, sink in zip(file_srcs, uhd_sinks): if iq: node = blocks.multiply_const_cc(1.0/1024) if onebit: self.connect(src, blocks.unpack_k_bits_bb(8), blocks.char_to_short(), # [0, 1] -> [0, 256] blocks.add_const_ss(-128), # [-128, +128], blocks.interleaved_short_to_complex(), # [ -128.0, +128.0] node) # [-0.125, +0.125] else: self.connect(src, # [-128..127] blocks.interleaved_char_to_complex(), # [-128.0, +127.0] node) # [-0.125, +0.125) else: node = blocks.float_to_complex(1) if onebit: self.connect(src, blocks.unpack_k_bits_bb(8), # [0, 1] -> [-0.125, +0.125] blocks.char_to_float(vlen=1, scale=4), blocks.add_const_vff((-0.125, )), node) else: self.connect(src, # [-128..127] -> [-0.125, +0.125) blocks.char_to_float(vlen=1, scale=1024), node) if noise: combiner = blocks.add_vcc(1) self.connect(node, combiner, sink) self.connect(analog.fastnoise_source_c(analog.GR_GAUSSIAN, noise, -222, 8192), (combiner, 1)) else: self.connect(node, sink) print "Setting clocks..." if sync_pps: time.sleep(1.1) # Ensure there's been an edge. TODO: necessary? last_pps_time = uhd_sinks[0].get_time_last_pps() while last_pps_time == uhd_sinks[0].get_time_last_pps(): time.sleep(0.1) print "Got edge" [sink.set_time_next_pps(uhd.time_spec(round(time.time())+1)) for sink in uhd_sinks] time.sleep(1.0) # Wait for edge to set the clocks else: # No external PPS/10 MHz. Just set each clock and accept some skew. t = time.time() [sink.set_time_now(uhd.time_spec(time.time())) for sink in uhd_sinks] if len(uhd_sinks) > 1: print "Uncabled; loosely synced only. Initial skew ~ %.1f ms" % ( (time.time()-t) * 1000) t_start = uhd.time_spec(time.time() + 1.5) [sink.set_start_time(t_start) for sink in uhd_sinks] print "ready"
def __init__(self, center_frequency, sample_rate, decimation, filename, sample_format=None, threshold=7.0, signal_width=40e3, offline=False, max_queue_len=500, handle_multiple_frames_per_burst=False, raw_capture_filename=None, max_bursts=0, verbose=False): gr.top_block.__init__(self, "Top Block") self._center_frequency = center_frequency self._burst_width = 40e3 self._input_sample_rate = sample_rate self._verbose = verbose self._threshold = threshold self._filename = filename self._offline = offline self._max_queue_len = max_queue_len self._handle_multiple_frames_per_burst = handle_multiple_frames_per_burst self._fft_size = int( math.pow(2, 1 + int(math.log(self._input_sample_rate / 1000, 2)))) # fft is approx 1ms long self._burst_pre_len = 2 * self._fft_size self._burst_post_len = 8 * self._fft_size # Just to keep the code below a bit more portable tb = self if decimation > 1: self._use_pfb = True # We will set up a filter bank with an odd number of outputs and # and an over sampling ratio to still get the desired decimation. # The goal is to still catch signal which (due to doppler shift) end up # on the border of two channels. # For this to work the desired decimation must be even. if decimation % 2: raise RuntimeError( "The desired decimation must be 1 or an even number") self._channels = decimation + 1 self._pfb_over_sample_ratio = self._channels / (self._channels - 1.) pfb_output_sample_rate = int( round( float(self._input_sample_rate) / self._channels * self._pfb_over_sample_ratio)) assert pfb_output_sample_rate == self._input_sample_rate / decimation # The over sampled region of the FIR filter contains half of the signal width and # the transition region of the FIR filter. # The bandwidth is simply increased by the signal width. # A signal which has its center frequency directly on the border of # two channels will reconstruct correclty on both channels. self._fir_bw = (self._input_sample_rate / self._channels + self._burst_width) / 2 # The remaining bandwidth inside the over samples region is used to # contain the transistion region of the filter. # It can be multiplied by two as it is allowed to continue into the # transition region of the neighboring channel. # TODO: Draw a nice graphic how this works. self._fir_tw = (pfb_output_sample_rate / 2 - self._fir_bw) * 2 # If the over sampling ratio is not large enough, there is not # enough room to construct a transition region. if self._fir_tw < 0: raise RuntimeError( "PFB over sampling ratio not enough to create a working FIR filter" ) self._pfb_fir_filter = gnuradio.filter.firdes.low_pass_2( 1, self._input_sample_rate, self._fir_bw, self._fir_tw, 60) # If the transition width approaches 0, the filter size goes up significantly. if len(self._pfb_fir_filter) > 200: print( "Warning: The PFB FIR filter has an abnormal large number of taps:", len(self._pfb_fir_filter), file=sys.stderr) print( "Consider reducing the decimation factor or increase the over sampling ratio", file=sys.stderr) self._burst_sample_rate = pfb_output_sample_rate if self._verbose: print("self._channels", self._channels, file=sys.stderr) print("len(self._pfb_fir_filter)", len(self._pfb_fir_filter), file=sys.stderr) print("self._pfb_over_sample_ratio", self._pfb_over_sample_ratio, file=sys.stderr) print("self._fir_bw", self._fir_bw, file=sys.stderr) print("self._fir_tw", self._fir_tw, file=sys.stderr) print("self._burst_sample_rate", self._burst_sample_rate, file=sys.stderr) else: self._use_pfb = False self._burst_sample_rate = self._input_sample_rate # After 90 ms there needs to be a pause in the frame sturcture. # Let's make that the limit for a detected burst self._max_burst_len = int(self._burst_sample_rate * 0.09) if self._verbose: print("require %.1f dB" % self._threshold, file=sys.stderr) print("burst_width: %d Hz" % self._burst_width, file=sys.stderr) if self._filename.endswith(".conf"): import configparser config = configparser.ConfigParser() config.read(self._filename) items = config.items("osmosdr-source") d = {key: value for key, value in items} import osmosdr if 'device_args' in d: source = osmosdr.source(args=d['device_args']) else: source = osmosdr.source() source.set_sample_rate(self._input_sample_rate) source.set_center_freq(self._center_frequency, 0) if 'gain' in d: gain = int(d['gain']) source.set_gain(gain, 0) print("(RF) Gain:", source.get_gain(0), '(Requested %d)' % gain, file=sys.stderr) for key, value in d.items(): if key.endswith("_gain"): gain_option_name = key.split('_')[0] gain_value = int(value) def match_gain(gain, gain_names): for gain_name in gain_names: if gain.lower() == gain_name.lower(): return gain_name return None gain_name = match_gain(gain_option_name, source.get_gain_names()) if gain_name is not None: source.set_gain(gain_value, gain_name, 0) print(gain_name, "Gain:", source.get_gain(gain_name, 0), '(Requested %d)' % gain_value, file=sys.stderr) else: print("WARNING: Gain", gain_option_name, "not supported by source!", file=sys.stderr) print("Supported gains:", source.get_gain_names(), file=sys.stderr) if 'bandwidth' in d: bandwidth = int(d['bandwidth']) source.set_bandwidth(bandwidth, 0) print("Bandwidth:", source.get_bandwidth(0), '(Requested %d)' % bandwidth, file=sys.stderr) else: source.set_bandwidth(0, 0) print("Warning: Setting bandwidth to", source.get_bandwidth(0), file=sys.stderr) if 'antenna' in d: antenna = d['antenna'] source.set_antenna(antenna, 0) print("Antenna:", source.get_antenna(0), '(Requested %s)' % antenna, file=sys.stderr) else: print("Warning: Setting antenna to", source.get_antenna(0), file=sys.stderr) #source.set_freq_corr($corr0, 0) #source.set_dc_offset_mode($dc_offset_mode0, 0) #source.set_iq_balance_mode($iq_balance_mode0, 0) #source.set_gain_mode($gain_mode0, 0) #source.set_antenna($ant0, 0) else: if sample_format == "rtl": converter = iridium.iuchar_to_complex() itemsize = gr.sizeof_char elif sample_format == "hackrf": converter = blocks.interleaved_char_to_complex() itemsize = gr.sizeof_char elif sample_format == "sc16": converter = blocks.interleaved_short_to_complex() itemsize = gr.sizeof_short elif sample_format == "float": converter = None itemsize = gr.sizeof_gr_complex else: raise RuntimeError( "Unknown sample format for offline mode given") file_source = blocks.file_source(itemsize=itemsize, filename=self._filename, repeat=False) if converter: #multi = blocks.multiply_const_cc(1/128.) #tb.connect(file_source, converter, multi) #source = multi tb.connect(file_source, converter) source = converter else: source = file_source #fft_burst_tagger::make(float center_frequency, int fft_size, int sample_rate, # int burst_pre_len, int burst_post_len, int burst_width, # int max_bursts, float threshold, int history_size, bool debug) self._fft_burst_tagger = iridium.fft_burst_tagger( center_frequency=self._center_frequency, fft_size=self._fft_size, sample_rate=self._input_sample_rate, burst_pre_len=self._burst_pre_len, burst_post_len=self._burst_post_len, burst_width=int(self._burst_width), max_bursts=max_bursts, threshold=self._threshold, history_size=512, debug=self._verbose) # Initial filter to filter the detected bursts. Runs at burst_sample_rate. Used to decimate the signal. # TODO: Should probably be set to self._burst_width input_filter = gnuradio.filter.firdes.low_pass_2( 1, self._burst_sample_rate, 40e3 / 2, 40e3, 40) #input_filter = gnuradio.filter.firdes.low_pass_2(1, self._burst_sample_rate, 42e3/2, 24e3, 40) #print len(input_filter) # Filter to find the start of the signal. Should be fairly narrow. # TODO: 250000 appears as magic number here start_finder_filter = gnuradio.filter.firdes.low_pass_2( 1, 250000, 5e3 / 2, 10e3 / 2, 60) #print len(start_finder_filter) self._iridium_qpsk_demod = iridium.iridium_qpsk_demod_cpp() self._frame_sorter = iridium.frame_sorter() self._iridium_frame_printer = iridium.iridium_frame_printer() #self._iridium_qpsk_demod = iridium.iridium_qpsk_demod(250000) if raw_capture_filename: raw_sink = blocks.file_sink(itemsize=gr.sizeof_gr_complex, filename=raw_capture_filename) tb.connect(source, raw_sink) # Enable the following if not fast enough #self._burst_to_pdu_converters = [] #self._burst_downmixers = [] #return tb.connect(source, self._fft_burst_tagger) if self._use_pfb: self._burst_to_pdu_converters = [] self._burst_downmixers = [] sinks = [] for channel in range(self._channels): center = channel if channel <= self._channels / 2 else ( channel - self._channels) # Second and third parameters tell the block where after the PFB it sits. relative_center = center / float(self._channels) relative_span = 1. / self._channels relative_sample_rate = relative_span * self._pfb_over_sample_ratio burst_to_pdu_converter = iridium.tagged_burst_to_pdu( self._max_burst_len, relative_center, relative_span, relative_sample_rate, self._max_queue_len, not self._offline) burst_downmixer = iridium.burst_downmix( self._burst_sample_rate, int(0.007 * 250000), 0, (input_filter), (start_finder_filter), self._handle_multiple_frames_per_burst) self._burst_downmixers.append(burst_downmixer) self._burst_to_pdu_converters.append(burst_to_pdu_converter) #pfb_debug_sinks = [blocks.file_sink(itemsize=gr.sizeof_gr_complex, filename="/tmp/channel-%d.f32"%i) for i in range(self._channels)] pfb_debug_sinks = None pfb = gnuradio.filter.pfb.channelizer_ccf( numchans=self._channels, taps=self._pfb_fir_filter, oversample_rate=self._pfb_over_sample_ratio) tb.connect(self._fft_burst_tagger, pfb) for i in range(self._channels): tb.connect((pfb, i), self._burst_to_pdu_converters[i]) if pfb_debug_sinks: tb.connect((pfb, i), pfb_debug_sinks[i]) tb.msg_connect((self._burst_to_pdu_converters[i], 'cpdus'), (self._burst_downmixers[i], 'cpdus')) tb.msg_connect( (self._burst_downmixers[i], 'burst_handled'), (self._burst_to_pdu_converters[i], 'burst_handled')) tb.msg_connect((self._burst_downmixers[i], 'cpdus'), (self._iridium_qpsk_demod, 'cpdus')) else: burst_downmix = iridium.burst_downmix( self._burst_sample_rate, int(0.007 * 250000), 0, (input_filter), (start_finder_filter), self._handle_multiple_frames_per_burst) burst_to_pdu = iridium.tagged_burst_to_pdu(self._max_burst_len, 0.0, 1.0, 1.0, self._max_queue_len, not self._offline) tb.connect(self._fft_burst_tagger, burst_to_pdu) tb.msg_connect((burst_to_pdu, 'cpdus'), (burst_downmix, 'cpdus')) tb.msg_connect((burst_downmix, 'burst_handled'), (burst_to_pdu, 'burst_handled')) # Final connection to the demodulator. It prints the output to stdout tb.msg_connect((burst_downmix, 'cpdus'), (self._iridium_qpsk_demod, 'cpdus')) self._burst_downmixers = [burst_downmix] self._burst_to_pdu_converters = [burst_to_pdu] tb.msg_connect((self._iridium_qpsk_demod, 'pdus'), (self._frame_sorter, 'pdus')) tb.msg_connect((self._frame_sorter, 'pdus'), (self._iridium_frame_printer, 'pdus'))
def __init__(self, filenames, dev_addrs, dual, onebit, iq, noise, mix, gain, fs, fc, unint, sync_pps): gr.top_block.__init__(self) if mix: raise NotImplementedError("TODO: Hilbert remix mode not implemented.") if dual: channels = [0, 1] else: channels = [0] uhd_sinks = [ uhd.usrp_sink(",".join( [addr, "send_frame_size=32768,num_send_frames=128"]), uhd.stream_args( cpu_format="fc32", otwformat="sc8", channels=channels)) for addr in dev_addrs] for sink in uhd_sinks: a = sink.get_usrp_info() for each in a.keys(): print each + " : " + a.get(each) sink.set_clock_rate(fs, uhd.ALL_MBOARDS) sink.set_samp_rate(fs) sink.set_center_freq(fc, 0) sink.set_gain(gain, 0) if dual: sink.set_center_freq(fc, 1) sink.set_gain(gain, 1) sink.set_subdev_spec("A:B A:A", 0) # TODO Use offset tuning? if sync_pps: sink.set_clock_source("external") # 10 MHz sink.set_time_source("external") # PPS if unint: if noise or onebit or not iq: raise NotImplementedError("TODO: RX channel-interleaved mode only " "supported for noiseless 8-bit complex.") BLOCK_N = 16*1024*1024 demux = blocks.vector_to_streams(2, len(uhd_sinks)) self.connect(blocks.file_source(2*len(uhd_sinks)*BLOCK_N, filenames[0], False), blocks.vector_to_stream(2*len(uhd_sinks), BLOCK_N), demux) for ix, sink in enumerate(uhd_sinks): self.connect((demux, ix), blocks.vector_to_stream(1, 2), blocks.interleaved_char_to_complex(), # [-128.0, +127.0] blocks.multiply_const_cc(1.0/1024), # [-0.125, 0.125) # blocks.vector_to_stream(8, 16*1024), sink) else: for i, filename in enumerate(filenames): src = blocks.file_source(gr.sizeof_char*1, filename, False) if dual: channel = i % 2 sink = uhd_sinks[i/2] else: channel = 0 sink = uhd_sinks[i] if iq: node = blocks.multiply_const_cc(1.0/1024) if onebit: self.connect(src, blocks.unpack_k_bits_bb(8), blocks.char_to_short(), # [0, 1] -> [0, 256] blocks.add_const_ss(-128), # [-128, +128], blocks.interleaved_short_to_complex(), # [ -128.0, +128.0] node) # [-0.125, +0.125] else: self.connect(src, # [-128..127] blocks.interleaved_char_to_complex(), # [-128.0, +127.0] node) # [-0.125, +0.125) else: node = blocks.float_to_complex(1) if onebit: self.connect(src, blocks.unpack_k_bits_bb(8), # [0, 1] -> [-0.125, +0.125] blocks.char_to_float(vlen=1, scale=4), blocks.add_const_vff((-0.125, )), node) else: self.connect(src, # [-128..127] -> [-0.125, +0.125) blocks.char_to_float(vlen=1, scale=1024), node) if noise: combiner = blocks.add_vcc(1) self.connect((node, 0), (combiner, 0), (sink, channel)) self.connect(analog.fastnoise_source_c(analog.GR_GAUSSIAN, noise, -222, 8192), (combiner, 1)) else: self.connect((node, 0), (sink, channel)) print "Setting clocks..." if sync_pps: time.sleep(1.1) # Ensure there's been an edge. TODO: necessary? last_pps_time = uhd_sinks[0].get_time_last_pps() while last_pps_time == uhd_sinks[0].get_time_last_pps(): time.sleep(0.1) print "Got edge" [sink.set_time_next_pps(uhd.time_spec(round(time.time())+1)) for sink in uhd_sinks] time.sleep(1.0) # Wait for edge to set the clocks else: # No external PPS/10 MHz. Just set each clock and accept some skew. t = time.time() [sink.set_time_now(uhd.time_spec(time.time())) for sink in uhd_sinks] if len(uhd_sinks) > 1: print "Uncabled; loosely synced only. Initial skew ~ %.1f ms" % ( (time.time()-t) * 1000) t_start = uhd.time_spec(time.time() + 1.5) [sink.set_start_time(t_start) for sink in uhd_sinks] print "ready"
def __init__(self): gr.top_block.__init__(self, "Not titled yet") Qt.QWidget.__init__(self) self.setWindowTitle("Not titled yet") qtgui.util.check_set_qss() try: self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc')) except: pass self.top_scroll_layout = Qt.QVBoxLayout() self.setLayout(self.top_scroll_layout) self.top_scroll = Qt.QScrollArea() self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame) self.top_scroll_layout.addWidget(self.top_scroll) self.top_scroll.setWidgetResizable(True) self.top_widget = Qt.QWidget() self.top_scroll.setWidget(self.top_widget) self.top_layout = Qt.QVBoxLayout(self.top_widget) self.top_grid_layout = Qt.QGridLayout() self.top_layout.addLayout(self.top_grid_layout) self.settings = Qt.QSettings("GNU Radio", "fir_siggen") try: if StrictVersion(Qt.qVersion()) < StrictVersion("5.0.0"): self.restoreGeometry( self.settings.value("geometry").toByteArray()) else: self.restoreGeometry(self.settings.value("geometry")) except: pass ################################################## # Variables ################################################## self.tx_taps_hex = tx_taps_hex = [ 226, -36, -211, 246, 40, -527, 379, 850, -1179, -1172, 2637, 1447, -5739, -1633, 19484, 32767, 19484, -1633, -5739, 1447, 2637, -1172, -1179, 850, 379, -527, 40, 246, -211, -36, 226 ] self.tx_taps_exp = tx_taps_exp = [ -0.001129150390625, -0.009796142578125, -0.018341064453125, -0.025115966796875, -0.028533935546875, -0.027191162109375, -0.020172119140625, -0.00714111328125, 0.01141357421875, 0.0343017578125, 0.0596923828125, 0.08526611328125, 0.108551025390625, 0.127197265625, 0.139251708984375, 0.143402099609375, 0.143402099609375, 0.139251708984375, 0.127197265625, 0.108551025390625, 0.08526611328125, 0.0596923828125, 0.0343017578125, 0.01141357421875, -0.00714111328125, -0.020172119140625, -0.027191162109375, -0.028533935546875, -0.025115966796875, -0.018341064453125, -0.009796142578125, -0.001129150390625 ] self.tx_taps = tx_taps = firdes.root_raised_cosine(1, 2, 1, 0.2, 31) self.samp_rate = samp_rate = 32000 self.act_taps = act_taps = [x * 2**-15 for x in tx_taps_hex] ################################################## # Blocks ################################################## self.qtgui_const_sink_x_0 = qtgui.const_sink_c( 1024, #size "", #name 1 #number of inputs ) self.qtgui_const_sink_x_0.set_update_time(0.10) self.qtgui_const_sink_x_0.set_y_axis(-2, 2) self.qtgui_const_sink_x_0.set_x_axis(-2, 2) self.qtgui_const_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, "") self.qtgui_const_sink_x_0.enable_autoscale(False) self.qtgui_const_sink_x_0.enable_grid(False) self.qtgui_const_sink_x_0.enable_axis_labels(True) labels = ['', '', '', '', '', '', '', '', '', ''] widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] colors = [ "blue", "red", "red", "red", "red", "red", "red", "red", "red", "red" ] styles = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] markers = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] for i in range(1): if len(labels[i]) == 0: self.qtgui_const_sink_x_0.set_line_label( i, "Data {0}".format(i)) else: self.qtgui_const_sink_x_0.set_line_label(i, labels[i]) self.qtgui_const_sink_x_0.set_line_width(i, widths[i]) self.qtgui_const_sink_x_0.set_line_color(i, colors[i]) self.qtgui_const_sink_x_0.set_line_style(i, styles[i]) self.qtgui_const_sink_x_0.set_line_marker(i, markers[i]) self.qtgui_const_sink_x_0.set_line_alpha(i, alphas[i]) self._qtgui_const_sink_x_0_win = sip.wrapinstance( self.qtgui_const_sink_x_0.pyqwidget(), Qt.QWidget) self.top_grid_layout.addWidget(self._qtgui_const_sink_x_0_win) self.interp_fir_filter_xxx_0_0 = filter.interp_fir_filter_ccc( 1, tx_taps_hex) self.interp_fir_filter_xxx_0_0.declare_sample_delay(0) self.blocks_stream_mux_0 = blocks.stream_mux(gr.sizeof_gr_complex * 1, [1, 1]) self.blocks_multiply_const_vxx_2 = blocks.multiply_const_cc(32) self.blocks_multiply_const_vxx_1 = blocks.multiply_const_cc(2**-12) self.blocks_multiply_const_vxx_0 = blocks.multiply_const_cc(2**-8) self.blocks_interleaved_short_to_complex_0 = blocks.interleaved_short_to_complex( False, False) self.blocks_interleaved_char_to_complex_0 = blocks.interleaved_char_to_complex( False) self.blocks_file_source_0 = blocks.file_source( gr.sizeof_short * 1, '/Users/iracigt/Developer/DVB_hat/hdl/iq_bytes.bin', False, 0 * 21690 * 2, ) self.blocks_file_source_0.set_begin_tag(pmt.PMT_NIL) self.blocks_file_sink_0_0 = blocks.file_sink( gr.sizeof_short * 1, '/Users/iracigt/Developer/DVB_hat/hdl/fir_correct_u16.bin', False) self.blocks_file_sink_0_0.set_unbuffered(True) self.blocks_file_sink_0 = blocks.file_sink( gr.sizeof_char * 1, '/Users/iracigt/Developer/DVB_hat/hdl/fir_in_u8.bin', False) self.blocks_file_sink_0.set_unbuffered(True) self.blocks_complex_to_interleaved_short_0 = blocks.complex_to_interleaved_short( False) self.blocks_complex_to_interleaved_char_0 = blocks.complex_to_interleaved_char( False) self.blocks_add_const_vxx_0_0 = blocks.add_const_cc(-4 * (1 + 1j)) self.blocks_add_const_vxx_0 = blocks.add_const_cc(64 + 64j) self.analog_const_source_x_0 = analog.sig_source_c( 0, analog.GR_CONST_WAVE, 0, 0, 0) ################################################## # Connections ################################################## self.connect((self.analog_const_source_x_0, 0), (self.blocks_stream_mux_0, 1)) self.connect((self.blocks_add_const_vxx_0, 0), (self.blocks_complex_to_interleaved_char_0, 0)) self.connect((self.blocks_add_const_vxx_0_0, 0), (self.blocks_stream_mux_0, 0)) self.connect((self.blocks_complex_to_interleaved_char_0, 0), (self.blocks_file_sink_0, 0)) self.connect((self.blocks_complex_to_interleaved_char_0, 0), (self.blocks_interleaved_char_to_complex_0, 0)) self.connect((self.blocks_complex_to_interleaved_short_0, 0), (self.blocks_file_sink_0_0, 0)) self.connect((self.blocks_file_source_0, 0), (self.blocks_interleaved_short_to_complex_0, 0)) self.connect((self.blocks_interleaved_char_to_complex_0, 0), (self.interp_fir_filter_xxx_0_0, 0)) self.connect((self.blocks_interleaved_short_to_complex_0, 0), (self.blocks_multiply_const_vxx_1, 0)) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.blocks_complex_to_interleaved_short_0, 0)) self.connect((self.blocks_multiply_const_vxx_0, 0), (self.qtgui_const_sink_x_0, 0)) self.connect((self.blocks_multiply_const_vxx_1, 0), (self.blocks_add_const_vxx_0_0, 0)) self.connect((self.blocks_multiply_const_vxx_2, 0), (self.blocks_add_const_vxx_0, 0)) self.connect((self.blocks_stream_mux_0, 0), (self.blocks_multiply_const_vxx_2, 0)) self.connect((self.interp_fir_filter_xxx_0_0, 0), (self.blocks_multiply_const_vxx_0, 0))
def __init__(self, center_frequency, sample_rate, decimation, filename, sample_format=None, threshold=7.0, signal_width=40e3, offline=False, max_queue_len=500, verbose=False): gr.top_block.__init__(self, "Top Block") self._center_frequency = center_frequency self._signal_width = 40e3 self._input_sample_rate = sample_rate self._verbose = verbose self._threshold = threshold self._filename = filename self._offline = offline self._max_queue_len = max_queue_len self._fft_size = int(math.pow(2, 1 + int(math.log(self._input_sample_rate / 1000, 2)))) # fft is approx 1ms long self._burst_pre_len = 2 * self._fft_size self._burst_post_len = 8 * self._fft_size self._burst_width= int(self._signal_width / (self._input_sample_rate / self._fft_size)) # Area to ignore around an already found signal in FFT bins if decimation > 1: self._use_pfb = True # We will set up a filter bank with an odd number of outputs and # and an over sampling ratio to still get the desired decimation. # The goal is to still catch signal which (due to doppler shift) end up # on the border of two channels. # For this to work the desired decimation must be even. if decimation % 2: raise RuntimeError("The desired decimation must be 1 or an even number") self._channels = decimation + 1 self._pfb_over_sample_ratio = self._channels / (self._channels - 1.) pfb_output_sample_rate = int(round(float(self._input_sample_rate) / self._channels * self._pfb_over_sample_ratio)) assert pfb_output_sample_rate == self._input_sample_rate / decimation # The over sampled region of the FIR filter contains half of the signal width and # the transition region of the FIR filter. # The bandwidth is simply increased by the signal width. # A signal which has its center frequency directly on the border of # two channels will reconstruct correclty on both channels. self._fir_bw = (self._input_sample_rate / self._channels + self._signal_width) / 2 # The remaining bandwidth inside the over samples region is used to # contain the transistion region of the filter. # It can be multiplied by two as it is allowed to continue into the # transition region of the neighboring channel. # TODO: Draw a nice graphic how this works. self._fir_tw = (pfb_output_sample_rate / 2 - self._fir_bw) * 2 # If the over sampling ratio is not large enough, there is not # enough room to construct a transition region. if self._fir_tw < 0: raise RuntimeError("PFB over sampling ratio not enough to create a working FIR filter") self._pfb_fir_filter = gnuradio.filter.firdes.low_pass_2(1, self._input_sample_rate, self._fir_bw, self._fir_tw, 60) # If the transition width approaches 0, the filter size goes up significantly. if len(self._pfb_fir_filter) > 200: print >> sys.stderr, "Warning: The PFB FIR filter has an abnormal large number of taps:", len(self._pfb_fir_filter) print >> sys.stderr, "Consider reducing the decimation factor or increase the over sampling ratio" self._burst_sample_rate = pfb_output_sample_rate if self._verbose: print >> sys.stderr, "self._channels", self._channels print >> sys.stderr, "len(self._pfb_fir_filter)", len(self._pfb_fir_filter) print >> sys.stderr, "self._pfb_over_sample_ratio", self._pfb_over_sample_ratio print >> sys.stderr, "self._fir_bw", self._fir_bw print >> sys.stderr, "self._fir_tw", self._fir_tw print >> sys.stderr, "self._burst_sample_rate", self._burst_sample_rate else: self._use_pfb = False self._burst_sample_rate = self._input_sample_rate # After 90 ms there needs to be a pause in the frame sturcture. # Let's make that the limit for a detected burst self._max_burst_len = int(self._burst_sample_rate * 0.09) if self._verbose: print >> sys.stderr, "require %.1f dB" % self._threshold print >> sys.stderr, "burst_width: %d (= %.1f Hz)" % (self._burst_width, self._burst_width*self._input_sample_rate/self._fft_size) if self._filename.endswith(".conf"): import ConfigParser config = ConfigParser.ConfigParser() config.read(self._filename) items = config.items("osmosdr-source") d = {key: value for key, value in items} if 'device_args' in d: source = osmosdr.source(args=d['device_args']) else: source = osmosdr.source() source.set_sample_rate(self._input_sample_rate) source.set_center_freq(self._center_frequency, 0) if 'gain' in d: gain = int(d['gain']) source.set_gain(gain, 0) print >> sys.stderr, "(RF) Gain:", source.get_gain(0), '(Requested %d)' % gain if 'if_gain' in d: if_gain = int(d['if_gain']) source.set_if_gain(if_gain, 0) print >> sys.stderr, "IF Gain:", source.get_gain("IF", 0), '(Requested %d)' % if_gain if 'mix_gain' in d: mix_gain = int(d['mix_gain']) source.set_mix_gain(mix_gain, 0) print >> sys.stderr, "MIX Gain:", source.get_gain("MIX", 0), '(Requested %d)' % mix_gain if 'bb_gain' in d: bb_gain = int(d['bb_gain']) source.set_bb_gain(bb_gain, 0) print >> sys.stderr, "BB Gain:", source.get_gain("BB", 0), '(Requested %d)' % bb_gain if 'bandwidth' in d: bandwidth = int(d['bandwidth']) source.set_bandwidth(bandwidth, 0) print >> sys.stderr, "Bandwidth:", source.get_bandwidth(0), '(Requested %d)' % bandwidth else: source.set_bandwidth(0, 0) print >> sys.stderr, "Warning: Setting bandwidth to", source.get_bandwidth(0) #source.set_freq_corr($corr0, 0) #source.set_dc_offset_mode($dc_offset_mode0, 0) #source.set_iq_balance_mode($iq_balance_mode0, 0) #source.set_gain_mode($gain_mode0, 0) #source.set_antenna($ant0, 0) converter = None else: if sample_format == "rtl": converter = iridium.iuchar_to_complex() itemsize = gr.sizeof_char elif sample_format == "hackrf": converter = blocks.interleaved_char_to_complex() itemsize = gr.sizeof_char elif sample_format == "sc16": converter = blocks.interleaved_short_to_complex() itemsize = gr.sizeof_short elif sample_format == "float": converter = None itemsize = gr.sizeof_gr_complex else: raise RuntimeError("Unknown sample format for offline mode given") source = blocks.file_source(itemsize=itemsize, filename=self._filename, repeat=False) # Just to keep the code below a bit more portable tb = self #fft_burst_tagger::make(float center_frequency, int fft_size, int sample_rate, # int burst_pre_len, int burst_post_len, int burst_width, # int max_bursts, float threshold, int history_size, bool debug) self._fft_burst_tagger = iridium.fft_burst_tagger(center_frequency=self._center_frequency, fft_size=self._fft_size, sample_rate=self._input_sample_rate, burst_pre_len=self._burst_pre_len, burst_post_len=self._burst_post_len, burst_width=self._burst_width, max_bursts=100, threshold=self._threshold, history_size=512, debug=self._verbose) # Initial filter to filter the detected bursts. Runs at burst_sample_rate. Used to decimate the signal. # TODO: Should probably be set to self._signal_width input_filter = gnuradio.filter.firdes.low_pass_2(1, self._burst_sample_rate, 40e3/2, 40e3, 40) #input_filter = gnuradio.filter.firdes.low_pass_2(1, self._burst_sample_rate, 42e3/2, 24e3, 40) #print len(input_filter) # Filter to find the start of the signal. Should be fairly narrow. # TODO: 250000 appears as magic number here start_finder_filter = gnuradio.filter.firdes.low_pass_2(1, 250000, 5e3/2, 10e3/2, 60) #print len(start_finder_filter) self._iridium_qpsk_demod = iridium.iridium_qpsk_demod_cpp() #self._iridium_qpsk_demod = iridium.iridium_qpsk_demod(250000) if self._use_pfb: self._burst_to_pdu_converters = [] self._burst_downmixers = [] sinks = [] for channel in range(self._channels): center = channel if channel <= self._channels / 2 else (channel - self._channels) # Second and third parameters tell the block where after the PFB it sits. relative_center = center / float(self._channels) relative_span = 1. / self._channels relative_sample_rate = relative_span * self._pfb_over_sample_ratio burst_to_pdu_converter = iridium.tagged_burst_to_pdu(self._max_burst_len, relative_center, relative_span, relative_sample_rate, self._max_queue_len, not self._offline) burst_downmixer = iridium.burst_downmix(self._burst_sample_rate, int(0.007 * 250000), 0, (input_filter), (start_finder_filter)) self._burst_downmixers.append(burst_downmixer) self._burst_to_pdu_converters.append(burst_to_pdu_converter) #pfb_debug_sinks = [blocks.file_sink(itemsize=gr.sizeof_gr_complex, filename="/tmp/channel-%d.f32"%i) for i in range(self._channels)] pfb_debug_sinks = None pfb = gnuradio.filter.pfb.channelizer_ccf(numchans=self._channels, taps=self._pfb_fir_filter, oversample_rate=self._pfb_over_sample_ratio) if converter: tb.connect(source, converter, self._fft_burst_tagger, pfb) else: tb.connect(source, self._fft_burst_tagger, pfb) for i in range(self._channels): tb.connect((pfb, i), self._burst_to_pdu_converters[i]) if pfb_debug_sinks: tb.connect((pfb, i), pfb_debug_sinks[i]) tb.msg_connect((self._burst_to_pdu_converters[i], 'cpdus'), (self._burst_downmixers[i], 'cpdus')) tb.msg_connect((self._burst_downmixers[i], 'burst_handled'), (self._burst_to_pdu_converters[i], 'burst_handled')) tb.msg_connect((self._burst_downmixers[i], 'cpdus'), (self._iridium_qpsk_demod, 'cpdus')) else: burst_downmix = iridium.burst_downmix(self._burst_sample_rate, int(0.007 * 250000), 0, (input_filter), (start_finder_filter)) burst_to_pdu = iridium.tagged_burst_to_pdu(self._max_burst_len, 0.0, 1.0, 1.0, self._max_queue_len, not self._offline) if converter: #multi = blocks.multiply_const_cc(1/128.) #tb.connect(source, converter, multi, self._fft_burst_tagger, burst_to_pdu) tb.connect(source, converter, self._fft_burst_tagger, burst_to_pdu) else: tb.connect(source, self._fft_burst_tagger, burst_to_pdu) tb.msg_connect((burst_to_pdu, 'cpdus'), (burst_downmix, 'cpdus')) tb.msg_connect((burst_downmix, 'burst_handled'), (burst_to_pdu, 'burst_handled')) # Final connection to the demodulator. It prints the output to stdout tb.msg_connect((burst_downmix, 'cpdus'), (self._iridium_qpsk_demod, 'cpdus')) self._burst_downmixers = [burst_downmix] self._burst_to_pdu_converters = [burst_to_pdu]
def __init__(self, center_frequency, sample_rate, decimation, filename, sample_format=None, threshold=7.0, burst_width=40e3, offline=False, max_queue_len=500, handle_multiple_frames_per_burst=False, raw_capture_filename=None, debug_id=None, max_bursts=0, verbose=False, file_info=None, samples_per_symbol=10, config={}): gr.top_block.__init__(self, "Top Block") self.handle_sigint = False self._center_frequency = center_frequency self._burst_width = burst_width self._input_sample_rate = sample_rate self._verbose = verbose self._threshold = threshold self._filename = filename self._offline = offline self._max_queue_len = max_queue_len self._handle_multiple_frames_per_burst = handle_multiple_frames_per_burst # Sample rate of the bursts exiting the burst downmix block self._burst_sample_rate = 25000 * samples_per_symbol assert (self._input_sample_rate / decimation) % self._burst_sample_rate == 0 self._fft_size = 2**round(math.log(self._input_sample_rate / 1000, 2)) # FFT is approx. 1 ms long self._burst_pre_len = 2 * self._fft_size # Keep 16 ms of signal after the FFT loses track self._burst_post_len = int(self._input_sample_rate * 16e-3) # Just to keep the code below a bit more portable tb = self if decimation > 1: self._use_pfb = True # We will set up a filter bank with an odd number of outputs and # and an over sampling ratio to still get the desired decimation. # The goal is to reconstruct signals which (due to Doppler shift) end up # on the border of two channels. # For this to work the desired decimation must be even. if decimation % 2: raise RuntimeError( "The desired decimation must be 1 or an even number") self._channels = decimation + 1 self._pfb_over_sample_ratio = self._channels / (self._channels - 1.) pfb_output_sample_rate = int( round( float(self._input_sample_rate) / self._channels * self._pfb_over_sample_ratio)) assert pfb_output_sample_rate == self._input_sample_rate / decimation assert pfb_output_sample_rate % self._burst_sample_rate == 0 # The over sampled region of the FIR filter contains half of the signal width and # the transition region of the FIR filter. # The bandwidth is simply increased by the signal width. # A signal which has its center frequency directly on the border of # two channels will reconstruct correctly on both channels. self._fir_bw = (self._input_sample_rate / self._channels + self._burst_width) / 2 # The remaining bandwidth inside the over sampled region is used to # contain the transition region of the filter. # It can be multiplied by two as it is allowed to continue into the # transition region of the neighboring channel. # Some details can be found here: https://youtu.be/6ngYp8W-AX0?t=2289 self._fir_tw = (pfb_output_sample_rate / 2 - self._fir_bw) * 2 # Real world data shows only a minor degradation in performance when # doubling the transition width. self._fir_tw *= 2 # If the over sampling ratio is not large enough, there is not # enough room to construct a transition region. if self._fir_tw < 0: raise RuntimeError( "PFB over sampling ratio not enough to create a working FIR filter" ) self._pfb_fir_filter = gnuradio.filter.firdes.low_pass_2( 1, self._input_sample_rate, self._fir_bw, self._fir_tw, 60) # If the transition width approaches 0, the filter size goes up significantly. if len(self._pfb_fir_filter) > 300: print( "Warning: The PFB FIR filter has an abnormal large number of taps:", len(self._pfb_fir_filter), file=sys.stderr) print("Consider reducing the decimation factor", file=sys.stderr) pfb_input_delay = ( len(self._pfb_fir_filter) + 1) // 2 - self._channels / self._pfb_over_sample_ratio self._pfb_delay = pfb_input_delay / decimation self._channel_sample_rate = pfb_output_sample_rate if self._verbose: print("self._channels", self._channels, file=sys.stderr) print("len(self._pfb_fir_filter)", len(self._pfb_fir_filter), file=sys.stderr) print("self._pfb_over_sample_ratio", self._pfb_over_sample_ratio, file=sys.stderr) print("self._fir_bw", self._fir_bw, file=sys.stderr) print("self._fir_tw", self._fir_tw, file=sys.stderr) print("self._channel_sample_rate", self._channel_sample_rate, file=sys.stderr) else: self._use_pfb = False self._channel_sample_rate = self._input_sample_rate self._channels = 1 # After 90 ms there needs to be a pause in the frame sturcture. # Let's make that the limit for a detected burst self._max_burst_len = int(self._channel_sample_rate * 0.09) if self._verbose: print("require %.1f dB" % self._threshold, file=sys.stderr) print("burst_width: %d Hz" % self._burst_width, file=sys.stderr) if config['source'] == 'osmosdr': d = config["osmosdr-source"] # work around https://github.com/gnuradio/gnuradio/issues/5121 sys.path.append('/usr/local/lib/python3/dist-packages') import osmosdr if 'device_args' in d: source = osmosdr.source(args=d['device_args']) else: source = osmosdr.source() source.set_time_now(osmosdr.time_spec_t.get_system_time()) source.set_sample_rate(self._input_sample_rate) source.set_center_freq(self._center_frequency, 0) if 'gain' in d: gain = int(d['gain']) source.set_gain(gain, 0) print("(RF) Gain:", source.get_gain(0), '(Requested %d)' % gain, file=sys.stderr) for key, value in d.items(): if key.endswith("_gain"): gain_option_name = key.split('_')[0] gain_value = int(value) def match_gain(gain, gain_names): for gain_name in gain_names: if gain.lower() == gain_name.lower(): return gain_name return None gain_name = match_gain(gain_option_name, source.get_gain_names()) if gain_name is not None: source.set_gain(gain_value, gain_name, 0) print(gain_name, "Gain:", source.get_gain(gain_name, 0), '(Requested %d)' % gain_value, file=sys.stderr) else: print("WARNING: Gain", gain_option_name, "not supported by source!", file=sys.stderr) print("Supported gains:", source.get_gain_names(), file=sys.stderr) if 'bandwidth' in d: bandwidth = int(d['bandwidth']) source.set_bandwidth(bandwidth, 0) print("Bandwidth:", source.get_bandwidth(0), '(Requested %d)' % bandwidth, file=sys.stderr) else: source.set_bandwidth(0, 0) print("Warning: Setting bandwidth to", source.get_bandwidth(0), file=sys.stderr) if 'antenna' in d: antenna = d['antenna'] source.set_antenna(antenna, 0) print("Antenna:", source.get_antenna(0), '(Requested %s)' % antenna, file=sys.stderr) else: print("Warning: Setting antenna to", source.get_antenna(0), file=sys.stderr) #source.set_freq_corr($corr0, 0) #source.set_dc_offset_mode($dc_offset_mode0, 0) #source.set_iq_balance_mode($iq_balance_mode0, 0) #source.set_gain_mode($gain_mode0, 0) #source.set_antenna($ant0, 0) else: if sample_format == "cu8": converter = iridium.iuchar_to_complex() itemsize = gr.sizeof_char scale = 1 itemtype = np.uint8 elif sample_format == "ci8": converter = blocks.interleaved_char_to_complex() itemsize = gr.sizeof_char scale = 1 / 128. itemtype = np.int8 elif sample_format == "ci16_le": converter = blocks.interleaved_short_to_complex() itemsize = gr.sizeof_short scale = 1 / 32768. itemtype = np.int16 elif sample_format == "cf32_le": converter = None itemsize = gr.sizeof_gr_complex itemtype = np.complex64 else: raise RuntimeError( "Unknown sample format for offline mode given") if config['source'] == 'stdin': file_source = blocks.file_descriptor_source(itemsize=itemsize, fd=0, repeat=False) elif config['source'] == 'object': from iridium.file_object_source import file_object_source file_source = file_object_source(fileobject=config['object'], itemtype=itemtype) else: file_source = blocks.file_source(itemsize=itemsize, filename=config['file'], repeat=False) self.source = file_source # XXX: keep reference if converter: multi = blocks.multiply_const_cc(scale) tb.connect(file_source, converter, multi) source = multi else: source = file_source self._fft_burst_tagger = iridium.fft_burst_tagger( center_frequency=self._center_frequency, fft_size=self._fft_size, sample_rate=self._input_sample_rate, burst_pre_len=self._burst_pre_len, burst_post_len=self._burst_post_len, burst_width=int(self._burst_width), max_bursts=max_bursts, threshold=self._threshold, history_size=512, offline=self._offline, debug=self._verbose) # Initial filter to filter the detected bursts. Runs at burst_sample_rate. Used to decimate the signal. input_filter = gnuradio.filter.firdes.low_pass_2( 1, self._channel_sample_rate, self._burst_width / 2, self._burst_width, 40) #input_filter = gnuradio.filter.firdes.low_pass_2(1, self._channel_sample_rate, 42e3/2, 24e3, 40) #print len(input_filter) # Filter to find the start of the signal. Should be fairly narrow. start_finder_filter = gnuradio.filter.firdes.low_pass_2( 1, self._burst_sample_rate, 5e3 / 2, 10e3 / 2, 60) #print len(start_finder_filter) self._iridium_qpsk_demod = iridium.iridium_qpsk_demod_cpp( self._channels) self._frame_sorter = iridium.frame_sorter() self._iridium_frame_printer = iridium.iridium_frame_printer(file_info) if raw_capture_filename: multi = blocks.multiply_const_cc(32768) converter = blocks.complex_to_interleaved_short() raw_sink = blocks.file_sink(itemsize=gr.sizeof_short, filename=raw_capture_filename) tb.connect(source, multi, converter, raw_sink) # Enable the following if not fast enough #self._burst_to_pdu_converters = [] #self._burst_downmixers = [] #return tb.connect(source, self._fft_burst_tagger) if self._use_pfb: self._burst_to_pdu_converters = [] self._burst_downmixers = [] sinks = [] for channel in range(self._channels): center = channel if channel <= self._channels / 2 else ( channel - self._channels) # Second and third parameters tell the block where after the PFB it sits. relative_center = center / float(self._channels) relative_span = 1. / self._channels relative_sample_rate = relative_span * self._pfb_over_sample_ratio burst_to_pdu_converter = iridium.tagged_burst_to_pdu( self._max_burst_len, relative_center, relative_span, relative_sample_rate, -self._pfb_delay, self._max_queue_len, not self._offline) burst_downmixer = iridium.burst_downmix( self._burst_sample_rate, int(0.007 * self._burst_sample_rate), 0, (input_filter), (start_finder_filter), self._handle_multiple_frames_per_burst) if debug_id is not None: burst_downmixer.debug_id(debug_id) self._burst_downmixers.append(burst_downmixer) self._burst_to_pdu_converters.append(burst_to_pdu_converter) #pfb_debug_sinks = [blocks.file_sink(itemsize=gr.sizeof_gr_complex, filename="/tmp/channel-%d.f32"%i) for i in range(self._channels)] pfb_debug_sinks = None pfb = gnuradio.filter.pfb.channelizer_ccf( numchans=self._channels, taps=self._pfb_fir_filter, oversample_rate=self._pfb_over_sample_ratio) tb.connect(self._fft_burst_tagger, pfb) for i in range(self._channels): tb.connect((pfb, i), self._burst_to_pdu_converters[i]) if pfb_debug_sinks: tb.connect((pfb, i), pfb_debug_sinks[i]) tb.msg_connect((self._burst_to_pdu_converters[i], 'cpdus'), (self._burst_downmixers[i], 'cpdus')) tb.msg_connect( (self._burst_downmixers[i], 'burst_handled'), (self._burst_to_pdu_converters[i], 'burst_handled')) tb.msg_connect((self._burst_downmixers[i], 'cpdus'), (self._iridium_qpsk_demod, 'cpdus%d' % i)) else: burst_downmix = iridium.burst_downmix( self._burst_sample_rate, int(0.007 * self._burst_sample_rate), 0, (input_filter), (start_finder_filter), self._handle_multiple_frames_per_burst) if debug_id is not None: burst_downmix.debug_id(debug_id) burst_to_pdu = iridium.tagged_burst_to_pdu(self._max_burst_len, 0.0, 1.0, 1.0, 0, self._max_queue_len, not self._offline) tb.connect(self._fft_burst_tagger, burst_to_pdu) tb.msg_connect((burst_to_pdu, 'cpdus'), (burst_downmix, 'cpdus')) tb.msg_connect((burst_downmix, 'burst_handled'), (burst_to_pdu, 'burst_handled')) # Final connection to the demodulator. It prints the output to stdout tb.msg_connect((burst_downmix, 'cpdus'), (self._iridium_qpsk_demod, 'cpdus')) self._burst_downmixers = [burst_downmix] self._burst_to_pdu_converters = [burst_to_pdu] tb.msg_connect((self._iridium_qpsk_demod, 'pdus'), (self._frame_sorter, 'pdus')) tb.msg_connect((self._frame_sorter, 'pdus'), (self._iridium_frame_printer, 'pdus'))
def __init__(self, center_frequency, sample_rate, decimation, filename, sample_format=None, threshold=7.0, burst_width=40e3, offline=False, max_queue_len=500, handle_multiple_frames_per_burst=False, raw_capture_filename=None, debug_id=None, max_bursts=0, verbose=False, file_info="", samples_per_symbol=10, config={}): gr.top_block.__init__(self, "Top Block") self.handle_sigint = False self._center_frequency = center_frequency self._burst_width = burst_width self._input_sample_rate = sample_rate self._verbose = verbose self._threshold = threshold self._filename = filename self._offline = offline self._max_queue_len = max_queue_len self._handle_multiple_frames_per_burst = handle_multiple_frames_per_burst self._decimation = decimation # Sample rate of the bursts exiting the burst downmix block self._burst_sample_rate = 25000 * samples_per_symbol if (self._input_sample_rate / self._decimation) % self._burst_sample_rate != 0: raise RuntimeError("Selected sample rate and decimation can not be matched. Please try a different combination. Sample rate divided by decimation must be a multiple of %d." % self._burst_sample_rate) self._fft_size = 2**round(math.log(self._input_sample_rate / 1000, 2)) # FFT is approx. 1 ms long self._burst_pre_len = 2 * self._fft_size # Keep 16 ms of signal after the FFT loses track self._burst_post_len = int(self._input_sample_rate * 16e-3) # Just to keep the code below a bit more portable tb = self if self._decimation > 1: self._use_channelizer = True # We will set up a filter bank with an odd number of outputs and # and an over sampling ratio to still get the desired decimation. # The goal is to reconstruct signals which (due to Doppler shift) end up # on the border of two channels. # For this to work the desired decimation must be even. if self._decimation % 2: raise RuntimeError("The desired decimation must be 1 or an even number.") self._channels = self._decimation + 1 if self._decimation >= 8: self._use_fft_channelizer = True if 2**int(math.log(self._decimation, 2)) != self._decimation: raise RuntimeError("Decimations >= 8 must be a power of two.") self._channel_sample_rate = self._input_sample_rate // self._decimation # On low end ARM machines we only create a single burst downmixer to not # overload the CPU. Rather drop bursts than samples. if platform.machine() == 'aarch64' and multiprocessing.cpu_count() == 4: self._n_burst_downmixers = 1 else: self._n_burst_downmixers = 2 else: self._use_fft_channelizer = False self._n_burst_downmixers = self._channels self._channelizer_over_sample_ratio = self._channels / (self._channels - 1.) channelizer_output_sample_rate = int(round(float(self._input_sample_rate) / self._channels * self._channelizer_over_sample_ratio)) self._channel_sample_rate = channelizer_output_sample_rate assert channelizer_output_sample_rate == self._input_sample_rate / self._decimation assert channelizer_output_sample_rate % self._burst_sample_rate == 0 # The over sampled region of the FIR filter contains half of the signal width and # the transition region of the FIR filter. # The bandwidth is simply increased by the signal width. # A signal which has its center frequency directly on the border of # two channels will reconstruct correctly on both channels. self._fir_bw = (self._input_sample_rate / self._channels + self._burst_width) / 2 # The remaining bandwidth inside the over sampled region is used to # contain the transition region of the filter. # It can be multiplied by two as it is allowed to continue into the # transition region of the neighboring channel. # Some details can be found here: https://youtu.be/6ngYp8W-AX0?t=2289 self._fir_tw = (channelizer_output_sample_rate / 2 - self._fir_bw) * 2 # Real world data shows only a minor degradation in performance when # doubling the transition width. self._fir_tw *= 2 # If the over sampling ratio is not large enough, there is not # enough room to construct a transition region. if self._fir_tw < 0: raise RuntimeError("PFB over sampling ratio not enough to create a working FIR filter. Please try a different decimation.") self._pfb_fir_filter = gnuradio.filter.firdes.low_pass_2(1, self._input_sample_rate, self._fir_bw, self._fir_tw, 60) # If the transition width approaches 0, the filter size goes up significantly. if len(self._pfb_fir_filter) > 300: print("Warning: The PFB FIR filter has an abnormal large number of taps:", len(self._pfb_fir_filter), file=sys.stderr) print("Consider reducing the decimation factor or use a decimation >= 8.", file=sys.stderr) pfb_input_delay = (len(self._pfb_fir_filter) + 1) // 2 - self._channels / self._channelizer_over_sample_ratio self._channelizer_delay = pfb_input_delay / self._decimation if self._verbose: print("self._channels", self._channels, file=sys.stderr) print("len(self._pfb_fir_filter)", len(self._pfb_fir_filter), file=sys.stderr) print("self._channelizer_over_sample_ratio", self._channelizer_over_sample_ratio, file=sys.stderr) print("self._fir_bw", self._fir_bw, file=sys.stderr) print("self._fir_tw", self._fir_tw, file=sys.stderr) print("self._channel_sample_rate", self._channel_sample_rate, file=sys.stderr) else: self._use_channelizer = False self._channel_sample_rate = self._input_sample_rate self._channels = 1 # After 90 ms there needs to be a pause in the frame sturcture. # Let's make that the limit for a detected burst self._max_burst_len = int(self._channel_sample_rate * 0.09) if self._verbose: print("require %.1f dB" % self._threshold, file=sys.stderr) print("burst_width: %d Hz" % self._burst_width, file=sys.stderr) print("source:", config['source'], file=sys.stderr) if config['source'] == 'osmosdr': d = config["osmosdr-source"] # work around https://github.com/gnuradio/gnuradio/issues/5121 sys.path.append('/usr/local/lib/python3/dist-packages') import osmosdr if 'device_args' in d: source = osmosdr.source(args=d['device_args']) else: source = osmosdr.source() source.set_sample_rate(self._input_sample_rate) source.set_center_freq(self._center_frequency, 0) # Set a rough time estimate for potential rx_time tags from USRP devices # This prevents the output from having bogous time stamps if no GPSDO is available source.set_time_now(osmosdr.time_spec_t(time.time())) if 'gain' in d: gain = int(d['gain']) source.set_gain(gain, 0) print("(RF) Gain:", source.get_gain(0), '(Requested %d)' % gain, file=sys.stderr) for key, value in d.items(): if key.endswith("_gain"): gain_option_name = key.split('_')[0] gain_value = int(value) def match_gain(gain, gain_names): for gain_name in gain_names: if gain.lower() == gain_name.lower(): return gain_name return None gain_name = match_gain(gain_option_name, source.get_gain_names()) if gain_name is not None: source.set_gain(gain_value, gain_name, 0) print(gain_name, "Gain:", source.get_gain(gain_name, 0), '(Requested %d)' % gain_value, file=sys.stderr) else: print("WARNING: Gain", gain_option_name, "not supported by source!", file=sys.stderr) print("Supported gains:", source.get_gain_names(), file=sys.stderr) if 'bandwidth' in d: bandwidth = int(d['bandwidth']) source.set_bandwidth(bandwidth, 0) print("Bandwidth:", source.get_bandwidth(0), '(Requested %d)' % bandwidth, file=sys.stderr) else: source.set_bandwidth(0, 0) print("Warning: Setting bandwidth to", source.get_bandwidth(0), file=sys.stderr) if 'antenna' in d: antenna = d['antenna'] source.set_antenna(antenna, 0) print("Antenna:", source.get_antenna(0), '(Requested %s)' % antenna, file=sys.stderr) else: print("Warning: Setting antenna to", source.get_antenna(0), file=sys.stderr) if 'clock_source' in d: print("Setting clock source to:", d['clock_source'], file=sys.stderr) source.set_clock_source(d['clock_source'], 0) if 'time_source' in d: print("Setting time source to:", d['time_source'], file=sys.stderr) source.set_time_source(d['time_source'], 0) while (time.time() % 1) < 0.4 or (time.time() % 1) > 0.6: pass t = time.time() source.set_time_next_pps(osmosdr.time_spec_t(int(t) + 1)) time.sleep(1) #source.set_freq_corr($corr0, 0) #source.set_dc_offset_mode($dc_offset_mode0, 0) #source.set_iq_balance_mode($iq_balance_mode0, 0) #source.set_gain_mode($gain_mode0, 0) elif config['source'] == 'soapy': d = config["soapy-source"] try: from gnuradio import soapy except ImportError: raise ImportError("gr-soapy not found. Make sure you are running GNURadio >= 3.9.2.0") if 'driver' not in d: print("No driver specified for soapy", file=sys.stderr) print("Run 'SoapySDRUtil -i' to see available drivers(factories)", file=sys.stderr) exit(1) dev = 'driver=' + d['driver'] # Strip quotes def sanitize(s): if s.startswith('"') and s.endswith('"'): return s.strip('""') if s.startswith("'") and s.endswith("'"): return s.strip("''") return s # Remove all outer quotes from the args if they are present in the config if 'device_args' in d: dev_args = sanitize(d['device_args']) elif 'dev_args' in d: dev_args = sanitize(d['dev_args']) else: dev_args = '' stream_args = sanitize(d['stream_args']) if 'stream_args' in d else '' tune_args = sanitize(d['tune_args']) if 'tune_args' in d else '' other_settings = sanitize(d['other_settings']) if 'other_settings' in d else '' # We only support a single channel. Apply tune_args and other_settings to that channel. source = soapy.source(dev, "fc32", 1, dev_args, stream_args, [tune_args], [other_settings]) source.set_sample_rate(0, self._input_sample_rate) source.set_frequency(0, self._center_frequency) if 'gain' in d: gain = int(d['gain']) source.set_gain_mode(0, False) # AGC: OFF source.set_gain(0, gain) print("Gain:", source.get_gain(0), '(Requested %d)' % gain, file=sys.stderr) for key, value in d.items(): if key.endswith("_gain"): gain_option_name = key.split('_')[0] gain_value = int(value) def match_gain(gain, gain_names): for gain_name in gain_names: if gain.lower() == gain_name.lower(): return gain_name return None gain_name = match_gain(gain_option_name, source.list_gains(0)) if gain_name is not None: source.set_gain(0, gain_name, gain_value) print(gain_name, "Gain:", source.get_gain(0, gain_name), '(Requested %d)' % gain_value, source.get_gain_range(0, gain_name), file=sys.stderr) else: print("WARNING: Gain", gain_option_name, "not supported by source!", file=sys.stderr) print("Supported gains:", source.list_gains(0), file=sys.stderr) if 'bandwidth' in d: bandwidth = int(d['bandwidth']) source.set_bandwidth(0, bandwidth) print("Bandwidth:", source.get_bandwidth(0), '(Requested %d)' % bandwidth, file=sys.stderr) else: source.set_bandwidth(0, 0) print("Warning: Setting bandwidth to", source.get_bandwidth(0), file=sys.stderr) if 'antenna' in d: antenna = d['antenna'] source.set_antenna(0, antenna) print("Antenna:", source.get_antenna(0), '(Requested %s)' % antenna, file=sys.stderr) else: print("Warning: Setting antenna to", source.get_antenna(0), file=sys.stderr) #source.set_frequency_correction(0, f_corr) #source.set_dc_offset_mode(0, True) #source.set_dc_offset(0, dc_off) #source.set_iq_balance(0, iq_bal) elif config['source'] == 'zeromq-sub': d = config["zeromq-sub-source"] from gnuradio import zeromq if 'address' not in d: print("No address specified for zeromq sub", file=sys.stderr) exit(1) pass_tags = False if 'pass_tags' in d: pass_tags = bool(distutils.util.strtobool(d['pass_tags'])) timeout = 100 if 'timeout' in d: timeout = int(d['timeout']) high_water_mark = -1 if 'high_water_mark' in d: high_water_mark = int(d['high_water_mark']) source = zeromq.sub_source(gr.sizeof_gr_complex, 1, d['address'], timeout, pass_tags, high_water_mark, '') elif config['source'] == 'uhd': d = config["uhd-source"] from gnuradio import uhd dev_addr = "" if "device_addr" in d: dev_addr = d['device_addr'] dev_args = d['device_args'] cpu_format = 'fc32' wire_format = 'sc16' stream_args = "" stream_args = uhd.stream_args(cpu_format, wire_format, args=stream_args) source = uhd.usrp_source(dev_addr + "," + dev_args, stream_args) source.set_samp_rate(self._input_sample_rate) source.set_center_freq(self._center_frequency) if 'gain' in d: gain = int(d['gain']) source.set_gain(gain, 0) print("Gain:", source.get_gain(0), '(Requested %d)' % gain, file=sys.stderr) if 'bandwidth' in d: bandwidth = int(d['bandwidth']) source.set_bandwidth(bandwidth, 0) print("Bandwidth:", source.get_bandwidth(0), '(Requested %d)' % bandwidth, file=sys.stderr) else: source.set_bandwidth(0) print("Warning: Setting bandwidth to", source.get_bandwidth(0), file=sys.stderr) if 'antenna' in d: antenna = d['antenna'] source.set_antenna(antenna, 0) print("Antenna:", source.get_antenna(0), '(Requested %s)' % antenna, file=sys.stderr) else: print("Warning: Setting antenna to", source.get_antenna(0), file=sys.stderr) print("mboard sensors:", source.get_mboard_sensor_names(0), file=sys.stderr) #for sensor in source.get_mboard_sensor_names(0): # print(sensor, source.get_mboard_sensor(sensor, 0)) gpsdo_sources = ('gpsdo', 'jacksonlabs') time_source = None if 'time_source' in d: time_source = d['time_source'] if time_source in gpsdo_sources: source.set_time_source("gpsdo", 0) else: source.set_time_source(time_source, 0) clock_source = None if 'clock_source' in d: clock_source = d['time_source'] if clock_source in gpsdo_sources: source.set_clock_source("gpsdo", 0) else: source.set_clock_source(clock_source, 0) if time_source in gpsdo_sources or clock_source in gpsdo_sources: print("Waiting for gps_locked...", file=sys.stderr) while True: try: if d['time_source'] == "jacksonlabs": servo = source.get_mboard_sensor("gps_servo", 0) # See https://lists.ettus.com/empathy/thread/6ZOCFQSKLHSG2IH3ID7XPWVKHVHZXPBP gps_locked = str(servo).split()[8] == "6" else: gps_locked = source.get_mboard_sensor("gps_locked", 0).to_bool() if gps_locked: break except ValueError as e: print(e, file=sys.stderr) pass time.sleep(1) print("gps_locked!", file=sys.stderr) if clock_source: print("Waiting for ref_locked...", file=sys.stderr) while True: try: ref_locked = source.get_mboard_sensor("ref_locked", 0) if ref_locked.to_bool(): break except ValueError as e: print(e, file=sys.stderr) pass time.sleep(1) print("ref_locked!", file=sys.stderr) if time_source: if time_source in gpsdo_sources: while True: try: gps_time = uhd.time_spec_t(source.get_mboard_sensor("gps_time").to_int()) break except ValueError as e: print(e, file=sys.stderr) pass time.sleep(1) next_pps_time = gps_time + 1 else: system_time = uhd.time_spec_t(int(time.time())) next_pps_time = system_time + 1 source.set_time_next_pps(next_pps_time) print("Next PPS at", next_pps_time.get_real_secs(), file=sys.stderr) print("Sleeping 2 seconds...", file=sys.stderr) time.sleep(2) # TODO: Check result for plausibility print("USRP time:", source.get_time_last_pps(0).get_real_secs(), file=sys.stderr) else: # Set a rough time estimate for rx_time tags from the USRP. # This prevents the output from having bogous time stamps if no GPSDO is available. source.set_time_now(uhd.time_spec_t(time.time())) self.source = source else: if sample_format == "cu8": converter = iridium.iuchar_to_complex() itemsize = gr.sizeof_char scale = 1 itemtype = np.uint8 elif sample_format == "ci8": converter = blocks.interleaved_char_to_complex() itemsize = gr.sizeof_char scale = 1 / 128. itemtype = np.int8 elif sample_format == "ci16_le": converter = blocks.interleaved_short_to_complex() itemsize = gr.sizeof_short scale = 1 / 32768. itemtype = np.int16 elif sample_format == "cf32_le": converter = None itemsize = gr.sizeof_gr_complex itemtype = np.complex64 else: raise RuntimeError("Unknown sample format for offline mode given") if config['source'] == 'stdin': file_source = blocks.file_descriptor_source(itemsize=itemsize, fd=0, repeat=False) elif config['source'] == 'object': from iridium.file_object_source import file_object_source file_source = file_object_source(fileobject=config['object'], itemtype=itemtype) else: file_source = blocks.file_source(itemsize=itemsize, filename=config['file'], repeat=False) self.source = file_source # XXX: keep reference if converter: multi = blocks.multiply_const_cc(scale) tb.connect(file_source, converter, multi) source = multi else: source = file_source self._fft_burst_tagger = iridium.fft_burst_tagger(center_frequency=self._center_frequency, fft_size=self._fft_size, sample_rate=self._input_sample_rate, burst_pre_len=self._burst_pre_len, burst_post_len=self._burst_post_len, burst_width=int(self._burst_width), max_bursts=max_bursts, max_burst_len=int(self._input_sample_rate * 0.09), threshold=self._threshold, history_size=512, offline=self._offline, debug=self._verbose) self._fft_burst_tagger.set_min_output_buffer(1024 * 64) # Initial filter to filter the detected bursts. Runs at burst_sample_rate. Used to decimate the signal. input_filter = gnuradio.filter.firdes.low_pass_2(1, self._channel_sample_rate, self._burst_width / 2, self._burst_width, 40) #input_filter = gnuradio.filter.firdes.low_pass_2(1, self._channel_sample_rate, 42e3/2, 24e3, 40) #print len(input_filter) # Filter to find the start of the signal. Should be fairly narrow. start_finder_filter = gnuradio.filter.firdes.low_pass_2(1, self._burst_sample_rate, 5e3 / 2, 10e3 / 2, 60) #print len(start_finder_filter) self._iridium_qpsk_demod = iridium.iridium_qpsk_demod(self._channels) self._frame_sorter = iridium.frame_sorter() self._iridium_frame_printer = iridium.iridium_frame_printer(file_info) if raw_capture_filename: multi = blocks.multiply_const_cc(32768) converter = blocks.complex_to_interleaved_short() raw_sink = blocks.file_sink(itemsize=gr.sizeof_short, filename=raw_capture_filename + '.sigmf-data') tb.connect(source, multi, converter, raw_sink) # Enable the following if not fast enough #self._burst_to_pdu_converters = [] #self._burst_downmixers = [] #return tb.connect(source, self._fft_burst_tagger) if self._use_channelizer: self._burst_to_pdu_converters = [] self._burst_downmixers = [] sinks = [] for channel in range(self._channels): if not self._use_fft_channelizer: center = channel if channel <= self._channels / 2 else (channel - self._channels) relative_center = center / float(self._channels) relative_span = 1. / self._channels relative_sample_rate = relative_span * self._channelizer_over_sample_ratio # Second and third parameters tell the block where after the PFB it sits. burst_to_pdu_converter = iridium.tagged_burst_to_pdu(self._max_burst_len, relative_center, relative_span, relative_sample_rate, -self._channelizer_delay, self._max_queue_len, not self._offline) self._burst_to_pdu_converters.append(burst_to_pdu_converter) burst_downmixer = iridium.burst_downmix(self._burst_sample_rate, int(0.007 * self._burst_sample_rate), 0, (input_filter), (start_finder_filter), self._handle_multiple_frames_per_burst) if debug_id is not None: burst_downmixer.debug_id(debug_id) self._burst_downmixers.append(burst_downmixer) channelizer_debug_sinks = [] #channelizer_debug_sinks = [blocks.file_sink(itemsize=gr.sizeof_gr_complex, filename="/tmp/channel-%d.f32"%i) for i in range(self._channels)] if self._use_fft_channelizer: if not channelizer_debug_sinks and self._offline: # HACK: if there are no stream outputs active GNURadio has issues terminating the # flowgraph on completion. Connect some dummy sinks to them. channelizer_debug_sinks = [blocks.null_sink(gr.sizeof_gr_complex) for i in range(self._channels)] activate_streams = len(channelizer_debug_sinks) > 0 self._channelizer = iridium.fft_channelizer(1024, self._channels - 1, activate_streams, self._n_burst_downmixers, self._max_burst_len, self._max_queue_len * self._n_burst_downmixers, not self._offline) else: self._channelizer = gnuradio.filter.pfb.channelizer_ccf(numchans=self._channels, taps=self._pfb_fir_filter, oversample_rate=self._channelizer_over_sample_ratio) tb.connect(self._fft_burst_tagger, self._channelizer) for i in range(self._channels): if channelizer_debug_sinks: tb.connect((self._channelizer, i), channelizer_debug_sinks[i]) for i in range(self._n_burst_downmixers): if self._burst_to_pdu_converters: tb.connect((self._channelizer, i), self._burst_to_pdu_converters[i]) tb.msg_connect((self._burst_to_pdu_converters[i], 'cpdus'), (self._burst_downmixers[i], 'cpdus')) tb.msg_connect((self._burst_downmixers[i], 'burst_handled'), (self._burst_to_pdu_converters[i], 'burst_handled')) else: tb.msg_connect((self._channelizer, 'cpdus%d' % i), (self._burst_downmixers[i], 'cpdus')) tb.msg_connect((self._burst_downmixers[i], 'burst_handled'), (self._channelizer, 'burst_handled')) tb.msg_connect((self._burst_downmixers[i], 'cpdus'), (self._iridium_qpsk_demod, 'cpdus%d' % i)) else: burst_downmix = iridium.burst_downmix(self._burst_sample_rate, int(0.007 * self._burst_sample_rate), 0, (input_filter), (start_finder_filter), self._handle_multiple_frames_per_burst) if debug_id is not None: burst_downmix.debug_id(debug_id) burst_to_pdu = iridium.tagged_burst_to_pdu(self._max_burst_len, 0.0, 1.0, 1.0, 0, self._max_queue_len, not self._offline) tb.connect(self._fft_burst_tagger, burst_to_pdu) tb.msg_connect((burst_to_pdu, 'cpdus'), (burst_downmix, 'cpdus')) tb.msg_connect((burst_downmix, 'burst_handled'), (burst_to_pdu, 'burst_handled')) # Final connection to the demodulator. It prints the output to stdout tb.msg_connect((burst_downmix, 'cpdus'), (self._iridium_qpsk_demod, 'cpdus')) self._burst_downmixers = [burst_downmix] self._burst_to_pdu_converters = [burst_to_pdu] tb.msg_connect((self._iridium_qpsk_demod, 'pdus'), (self._frame_sorter, 'pdus')) tb.msg_connect((self._frame_sorter, 'pdus'), (self._iridium_frame_printer, 'pdus'))
def __init__(self): gr.top_block.__init__(self, "spooky") Qt.QWidget.__init__(self) self.setWindowTitle("spooky") qtgui.util.check_set_qss() try: self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc')) except: pass self.top_scroll_layout = Qt.QVBoxLayout() self.setLayout(self.top_scroll_layout) self.top_scroll = Qt.QScrollArea() self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame) self.top_scroll_layout.addWidget(self.top_scroll) self.top_scroll.setWidgetResizable(True) self.top_widget = Qt.QWidget() self.top_scroll.setWidget(self.top_widget) self.top_layout = Qt.QVBoxLayout(self.top_widget) self.top_grid_layout = Qt.QGridLayout() self.top_layout.addLayout(self.top_grid_layout) self.settings = Qt.QSettings("GNU Radio", "spooky") try: if StrictVersion(Qt.qVersion()) < StrictVersion("5.0.0"): self.restoreGeometry( self.settings.value("geometry").toByteArray()) else: self.restoreGeometry(self.settings.value("geometry")) except: pass ################################################## # Variables ################################################## self.samp_rate = samp_rate = 180000 ################################################## # Blocks ################################################## self.qtgui_time_sink_x_0_0 = qtgui.time_sink_f( 18000, #size samp_rate, #samp_rate 'Real uint8 Time Sink', #name 1 #number of inputs ) self.qtgui_time_sink_x_0_0.set_update_time(0.10) self.qtgui_time_sink_x_0_0.set_y_axis(-1, 1) self.qtgui_time_sink_x_0_0.set_y_label('Amplitude', "") self.qtgui_time_sink_x_0_0.enable_tags(True) self.qtgui_time_sink_x_0_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, 0, "") self.qtgui_time_sink_x_0_0.enable_autoscale(True) self.qtgui_time_sink_x_0_0.enable_grid(False) self.qtgui_time_sink_x_0_0.enable_axis_labels(True) self.qtgui_time_sink_x_0_0.enable_control_panel(False) self.qtgui_time_sink_x_0_0.enable_stem_plot(False) labels = [ 'Signal 1', 'Signal 2', 'Signal 3', 'Signal 4', 'Signal 5', 'Signal 6', 'Signal 7', 'Signal 8', 'Signal 9', 'Signal 10' ] widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] colors = [ 'blue', 'red', 'green', 'black', 'cyan', 'magenta', 'yellow', 'dark red', 'dark green', 'dark blue' ] alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] styles = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] markers = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1] for i in range(1): if len(labels[i]) == 0: self.qtgui_time_sink_x_0_0.set_line_label( i, "Data {0}".format(i)) else: self.qtgui_time_sink_x_0_0.set_line_label(i, labels[i]) self.qtgui_time_sink_x_0_0.set_line_width(i, widths[i]) self.qtgui_time_sink_x_0_0.set_line_color(i, colors[i]) self.qtgui_time_sink_x_0_0.set_line_style(i, styles[i]) self.qtgui_time_sink_x_0_0.set_line_marker(i, markers[i]) self.qtgui_time_sink_x_0_0.set_line_alpha(i, alphas[i]) self._qtgui_time_sink_x_0_0_win = sip.wrapinstance( self.qtgui_time_sink_x_0_0.pyqwidget(), Qt.QWidget) self.top_grid_layout.addWidget(self._qtgui_time_sink_x_0_0_win) self.qtgui_time_sink_x_0 = qtgui.time_sink_f( 18000, #size samp_rate, #samp_rate 'Complex uint8 Time Sink (after threshold)', #name 1 #number of inputs ) self.qtgui_time_sink_x_0.set_update_time(0.10) self.qtgui_time_sink_x_0.set_y_axis(-1, 1) self.qtgui_time_sink_x_0.set_y_label('Amplitude', "") self.qtgui_time_sink_x_0.enable_tags(True) self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, 0, "") self.qtgui_time_sink_x_0.enable_autoscale(True) self.qtgui_time_sink_x_0.enable_grid(False) self.qtgui_time_sink_x_0.enable_axis_labels(True) self.qtgui_time_sink_x_0.enable_control_panel(False) self.qtgui_time_sink_x_0.enable_stem_plot(False) labels = [ 'Signal 1', 'Signal 2', 'Signal 3', 'Signal 4', 'Signal 5', 'Signal 6', 'Signal 7', 'Signal 8', 'Signal 9', 'Signal 10' ] widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] colors = [ 'blue', 'red', 'green', 'black', 'cyan', 'magenta', 'yellow', 'dark red', 'dark green', 'dark blue' ] alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] styles = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] markers = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1] for i in range(1): if len(labels[i]) == 0: self.qtgui_time_sink_x_0.set_line_label( i, "Data {0}".format(i)) else: self.qtgui_time_sink_x_0.set_line_label(i, labels[i]) self.qtgui_time_sink_x_0.set_line_width(i, widths[i]) self.qtgui_time_sink_x_0.set_line_color(i, colors[i]) self.qtgui_time_sink_x_0.set_line_style(i, styles[i]) self.qtgui_time_sink_x_0.set_line_marker(i, markers[i]) self.qtgui_time_sink_x_0.set_line_alpha(i, alphas[i]) self._qtgui_time_sink_x_0_win = sip.wrapinstance( self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget) self.top_grid_layout.addWidget(self._qtgui_time_sink_x_0_win) self.qtgui_freq_sink_x_0 = qtgui.freq_sink_c( 1024, #size firdes.WIN_BLACKMAN_hARRIS, #wintype 0, #fc samp_rate, #bw 'Complex uint8 Frequency Sink', #name 1) self.qtgui_freq_sink_x_0.set_update_time(0.10) self.qtgui_freq_sink_x_0.set_y_axis(-140, 10) self.qtgui_freq_sink_x_0.set_y_label('Relative Gain', 'dB') self.qtgui_freq_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0, "") self.qtgui_freq_sink_x_0.enable_autoscale(False) self.qtgui_freq_sink_x_0.enable_grid(False) self.qtgui_freq_sink_x_0.set_fft_average(1.0) self.qtgui_freq_sink_x_0.enable_axis_labels(True) self.qtgui_freq_sink_x_0.enable_control_panel(True) labels = ['', '', '', '', '', '', '', '', '', ''] widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] colors = [ "blue", "red", "green", "black", "cyan", "magenta", "yellow", "dark red", "dark green", "dark blue" ] alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0] for i in range(1): if len(labels[i]) == 0: self.qtgui_freq_sink_x_0.set_line_label( i, "Data {0}".format(i)) else: self.qtgui_freq_sink_x_0.set_line_label(i, labels[i]) self.qtgui_freq_sink_x_0.set_line_width(i, widths[i]) self.qtgui_freq_sink_x_0.set_line_color(i, colors[i]) self.qtgui_freq_sink_x_0.set_line_alpha(i, alphas[i]) self._qtgui_freq_sink_x_0_win = sip.wrapinstance( self.qtgui_freq_sink_x_0.pyqwidget(), Qt.QWidget) self.top_grid_layout.addWidget(self._qtgui_freq_sink_x_0_win) self.blocks_throttle_0_0 = blocks.throttle(gr.sizeof_float * 1, samp_rate, True) self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex * 1, samp_rate, True) self.blocks_threshold_ff_0 = blocks.threshold_ff(150, 160, 0) self.blocks_interleaved_char_to_complex_0 = blocks.interleaved_char_to_complex( False) self.blocks_file_source_0_0 = blocks.file_source( gr.sizeof_char * 1, '/CHANGEME/cut.u8', False, 0, 0) self.blocks_file_source_0_0.set_begin_tag(pmt.PMT_NIL) self.blocks_file_source_0 = blocks.file_source(gr.sizeof_char * 1, '/CHANGME/cut.u8', False, 0, 0) self.blocks_file_source_0.set_begin_tag(pmt.PMT_NIL) self.blocks_complex_to_mag_0 = blocks.complex_to_mag(1) self.blocks_char_to_float_0 = blocks.char_to_float(1, 1) ################################################## # Connections ################################################## self.connect((self.blocks_char_to_float_0, 0), (self.blocks_throttle_0_0, 0)) self.connect((self.blocks_complex_to_mag_0, 0), (self.blocks_threshold_ff_0, 0)) self.connect((self.blocks_file_source_0, 0), (self.blocks_interleaved_char_to_complex_0, 0)) self.connect((self.blocks_file_source_0_0, 0), (self.blocks_char_to_float_0, 0)) self.connect((self.blocks_interleaved_char_to_complex_0, 0), (self.blocks_throttle_0, 0)) self.connect((self.blocks_threshold_ff_0, 0), (self.qtgui_time_sink_x_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.blocks_complex_to_mag_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.qtgui_freq_sink_x_0, 0)) self.connect((self.blocks_throttle_0_0, 0), (self.qtgui_time_sink_x_0_0, 0))