def __init__(self, rx_callback, SNR): """ @param options Optparse option field for command line arguments. @param rx_callback Callback function for the event when a packet is received. """ gr.flow_graph.__init__(self) self.samples_per_symbol = 2 self.data_rate = 2000000 payload_size = 128 # bytes self.packet_transmitter = ieee802_15_4_pkt.ieee802_15_4_mod_pkts( self, spb=self.samples_per_symbol, msgq_limit=2) # add some noise print " Setting SNR to ", SNR add = gr.add_cc() noise = gr.noise_source_c(gr.GR_GAUSSIAN, pow(10.0, -SNR / 20.0)) self.packet_receiver = ieee802_15_4_pkt.ieee802_15_4_demod_pkts( self, callback=rx_callback, sps=self.samples_per_symbol, symbol_rate=self.data_rate, threshold=-1) self.connect(self.packet_transmitter, (add, 0)) self.connect(noise, (add, 1)) self.connect(add, self.packet_receiver)
def test_002_freq (self): """ Add a fine frequency offset and see if that get's detected properly """ fft_len = 32 cp_len = 4 # This frequency offset is normalized to rads, i.e. \pi == f_s/2 max_freq_offset = 2*numpy.pi/fft_len # Otherwise, it's coarse freq_offset = ((2 * random.random()) - 1) * max_freq_offset sig_len = (fft_len + cp_len) * 10 sync_symbol = [(random.randint(0, 1)*2)-1 for x in range(fft_len/2)] * 2 tx_signal = sync_symbol[-cp_len:] + \ sync_symbol + \ [(random.randint(0, 1)*2)-1 for x in range(sig_len)] mult = gr.multiply_cc() add = gr.add_cc() sync = digital.ofdm_sync_sc_cfb(fft_len, cp_len, True) channel = gr.channel_model(0.005, freq_offset / 2.0 / numpy.pi) sink_freq = gr.vector_sink_f() sink_detect = gr.vector_sink_b() self.tb.connect(gr.vector_source_c(tx_signal), channel, sync) self.tb.connect((sync, 0), sink_freq) self.tb.connect((sync, 1), sink_detect) self.tb.run() phi_hat = sink_freq.data()[sink_detect.data().index(1)] est_freq_offset = 2 * phi_hat / fft_len self.assertAlmostEqual(est_freq_offset, freq_offset, places=2)
def __init__(self): gr.top_block.__init__(self) Rs = 8000 f1 = 100 f2 = 200 npts = 2048 self.qapp = QtGui.QApplication(sys.argv) src1 = gr.sig_source_c(Rs, gr.GR_SIN_WAVE, f1, 0.5, 0) src2 = gr.sig_source_c(Rs, gr.GR_SIN_WAVE, f2, 0.5, 0) src = gr.add_cc() channel = filter.channel_model(0.001) thr = gr.throttle(gr.sizeof_gr_complex, 100*npts) self.snk1 = qtgui.const_sink_c(npts, "Constellation Example", 1) self.connect(src1, (src,0)) self.connect(src2, (src,1)) self.connect(src, channel, thr, (self.snk1, 0)) self.ctrl_win = control_box() self.ctrl_win.attach_signal1(src1) self.ctrl_win.attach_signal2(src2) # Get the reference pointer to the SpectrumDisplayForm QWidget pyQt = self.snk1.pyqwidget() # Wrap the pointer as a PyQt SIP object # This can now be manipulated as a PyQt4.QtGui.QWidget pyWin = sip.wrapinstance(pyQt, QtGui.QWidget) self.main_box = dialog_box(pyWin, self.ctrl_win) self.main_box.show()
def __init__(self, fg, noise_voltage=0.0, frequency_offset=0.0, epsilon=1.0, taps=[1.0,0.0]): ''' Creates a channel model that includes: - AWGN noise power in terms of noise voltage - A frequency offest in the channel in ratio - A timing offset ratio to model clock difference (epsilon) - Multipath taps ''' print epsilon self.timing_offset = gr.fractional_interpolator_cc(0, epsilon) self.multipath = gr.fir_filter_ccc(1, taps) self.noise_adder = gr.add_cc() self.noise = gr.noise_source_c(gr.GR_GAUSSIAN,noise_voltage) self.freq_offset = gr.sig_source_c(1, gr.GR_SIN_WAVE, frequency_offset, 1.0, 0.0) self.mixer_offset = gr.multiply_cc() fg.connect(self.timing_offset, self.multipath) fg.connect(self.multipath, (self.mixer_offset,0)) fg.connect(self.freq_offset,(self.mixer_offset,1)) fg.connect(self.mixer_offset, (self.noise_adder,1)) fg.connect(self.noise, (self.noise_adder,0)) gr.hier_block.__init__(self, fg, self.timing_offset, self.noise_adder)
def set_waveform(self, type): self.lock() self.disconnect_all() if type == gr.GR_SIN_WAVE or type == gr.GR_CONST_WAVE: self._src = gr.sig_source_c( self[SAMP_RATE_KEY], # Sample rate type, # Waveform type self[WAVEFORM_FREQ_KEY], # Waveform frequency self[AMPLITUDE_KEY], # Waveform amplitude self[WAVEFORM_OFFSET_KEY]) # Waveform offset elif type == gr.GR_GAUSSIAN or type == gr.GR_UNIFORM: self._src = gr.noise_source_c(type, self[AMPLITUDE_KEY]) elif type == "2tone": self._src1 = gr.sig_source_c(self[SAMP_RATE_KEY], gr.GR_SIN_WAVE, self[WAVEFORM_FREQ_KEY], self[AMPLITUDE_KEY] / 2.0, 0) if (self[WAVEFORM2_FREQ_KEY] is None): self[WAVEFORM2_FREQ_KEY] = -self[WAVEFORM_FREQ_KEY] self._src2 = gr.sig_source_c(self[SAMP_RATE_KEY], gr.GR_SIN_WAVE, self[WAVEFORM2_FREQ_KEY], self[AMPLITUDE_KEY] / 2.0, 0) self._src = gr.add_cc() self.connect(self._src1, (self._src, 0)) self.connect(self._src2, (self._src, 1)) elif type == "sweep": # rf freq is center frequency # waveform_freq is total swept width # waveform2_freq is sweep rate # will sweep from (rf_freq-waveform_freq/2) to (rf_freq+waveform_freq/2) if self[WAVEFORM2_FREQ_KEY] is None: self[WAVEFORM2_FREQ_KEY] = 0.1 self._src1 = gr.sig_source_f(self[SAMP_RATE_KEY], gr.GR_TRI_WAVE, self[WAVEFORM2_FREQ_KEY], 1.0, -0.5) self._src2 = gr.frequency_modulator_fc( self[WAVEFORM_FREQ_KEY] * 2 * math.pi / self[SAMP_RATE_KEY]) self._src = gr.multiply_const_cc(self[AMPLITUDE_KEY]) self.connect(self._src1, self._src2, self._src) else: raise RuntimeError("Unknown waveform type") self.connect(self._src, self._u) self.unlock() if self._verbose: print "Set baseband modulation to:", waveforms[type] if type == gr.GR_SIN_WAVE: print "Modulation frequency: %sHz" % (n2s( self[WAVEFORM_FREQ_KEY]), ) print "Initial phase:", self[WAVEFORM_OFFSET_KEY] elif type == "2tone": print "Tone 1: %sHz" % (n2s(self[WAVEFORM_FREQ_KEY]), ) print "Tone 2: %sHz" % (n2s(self[WAVEFORM2_FREQ_KEY]), ) elif type == "sweep": print "Sweeping across %sHz to %sHz" % (n2s( -self[WAVEFORM_FREQ_KEY] / 2.0), n2s(self[WAVEFORM_FREQ_KEY] / 2.0)) print "Sweep rate: %sHz" % (n2s(self[WAVEFORM2_FREQ_KEY]), ) print "TX amplitude:", self[AMPLITUDE_KEY]
def test_002_freq (self): """ Add a fine frequency offset and see if that get's detected properly """ fft_len = 32 cp_len = 4 freq_offset = 0.1 # Must stay < 2*pi/fft_len = 0.196 (otherwise, it's coarse) sig_len = (fft_len + cp_len) * 10 sync_symbol = [(random.randint(0, 1)*2)-1 for x in range(fft_len/2)] * 2 tx_signal = sync_symbol[-cp_len:] + \ sync_symbol + \ [(random.randint(0, 1)*2)-1 for x in range(sig_len)] mult = gr.multiply_cc() add = gr.add_cc() sync = digital.ofdm_sync_sc_cfb(fft_len, cp_len) sink_freq = gr.vector_sink_f() sink_detect = gr.vector_sink_b() self.tb.connect(gr.vector_source_c(tx_signal), (mult, 0), (add, 0)) self.tb.connect(gr.sig_source_c(2 * numpy.pi, gr.GR_SIN_WAVE, freq_offset, 1.0), (mult, 1)) self.tb.connect(gr.noise_source_c(gr.GR_GAUSSIAN, .01), (add, 1)) self.tb.connect(add, sync) self.tb.connect((sync, 0), sink_freq) self.tb.connect((sync, 1), sink_detect) self.tb.run() phi_hat = sink_freq.data()[sink_detect.data().index(1)] est_freq_offset = 2 * phi_hat / fft_len self.assertAlmostEqual(est_freq_offset, freq_offset, places=2)
def test_001_detect (self): """ Send two bursts, with zeros in between, and check they are both detected at the correct position and no false alarms occur """ n_zeros = 15 fft_len = 32 cp_len = 4 sig_len = (fft_len + cp_len) * 10 sync_symbol = [(random.randint(0, 1)*2)-1 for x in range(fft_len/2)] * 2 tx_signal = [0,] * n_zeros + \ sync_symbol[-cp_len:] + \ sync_symbol + \ [(random.randint(0, 1)*2)-1 for x in range(sig_len)] tx_signal = tx_signal * 2 add = gr.add_cc() sync = digital.ofdm_sync_sc_cfb(fft_len, cp_len) sink_freq = gr.vector_sink_f() sink_detect = gr.vector_sink_b() self.tb.connect(gr.vector_source_c(tx_signal), (add, 0)) self.tb.connect(gr.noise_source_c(gr.GR_GAUSSIAN, .01), (add, 1)) self.tb.connect(add, sync) self.tb.connect((sync, 0), sink_freq) self.tb.connect((sync, 1), sink_detect) self.tb.run() sig1_detect = sink_detect.data()[0:len(tx_signal)/2] sig2_detect = sink_detect.data()[len(tx_signal)/2:] self.assertTrue(abs(sig1_detect.index(1) - (n_zeros + fft_len + cp_len)) < cp_len) self.assertTrue(abs(sig2_detect.index(1) - (n_zeros + fft_len + cp_len)) < cp_len) self.assertEqual(numpy.sum(sig1_detect), 1) self.assertEqual(numpy.sum(sig2_detect), 1)
def __init__(self, rx_callback, spb, alpha, SNR): # m is constellation size # if diff==True we are doing DxPSK gr.flow_graph.__init__(self) fg = self # transmitter self.packet_transmitter = bbn_80211b_mod_pkts(fg, spb=spb, alpha=alpha, gain=1) # add some noise add = gr.add_cc() noise = gr.noise_source_c(gr.GR_GAUSSIAN, pow(10.0,-SNR/20.0)) # channel filter rx_filt_taps = gr.firdes.low_pass(1,spb,0.8,0.1,gr.firdes.WIN_HANN) rx_filt = gr.fir_filter_ccf(1,rx_filt_taps) # receiver self.bit_receiver = bbn_80211b_demod_pkts(self, spb=spb, alpha=alpha, callback=rx_callback) fg.connect(self.packet_transmitter, (add,0)) fg.connect(noise, (add,1)) #xfile=gr.file_sink(gr.sizeof_gr_complex,"txdata"); #fg.connect(add, xfile) fg.connect(add, rx_filt) fg.connect(rx_filt, self.bit_receiver)
def test_003_multiburst (self): """ Send several bursts, see if the number of detects is correct. Burst lengths and content are random. """ n_bursts = 42 fft_len = 32 cp_len = 4 tx_signal = [] for i in xrange(n_bursts): sync_symbol = [(random.randint(0, 1)*2)-1 for x in range(fft_len/2)] * 2 tx_signal += [0,] * random.randint(0, 2*fft_len) + \ sync_symbol[-cp_len:] + \ sync_symbol + \ [(random.randint(0, 1)*2)-1 for x in range(fft_len * random.randint(5,23))] add = gr.add_cc() sync = digital.ofdm_sync_sc_cfb(fft_len, cp_len) sink_freq = gr.vector_sink_f() sink_detect = gr.vector_sink_b() self.tb.connect(gr.vector_source_c(tx_signal), (add, 0)) self.tb.connect(gr.noise_source_c(gr.GR_GAUSSIAN, .005), (add, 1)) self.tb.connect(add, sync) self.tb.connect((sync, 0), sink_freq) self.tb.connect((sync, 1), sink_detect) self.tb.run() self.assertEqual(numpy.sum(sink_detect.data()), n_bursts, msg="""Because of statistics, it is possible (though unlikely) that the number of detected bursts differs slightly. If the number of detects is off by one or two, run the test again and see what happen. Detection error was: %d """ % (numpy.sum(sink_detect.data()) - n_bursts) )
def test_002_freq(self): """ Add a fine frequency offset and see if that get's detected properly """ fft_len = 32 cp_len = 4 # This frequency offset is normalized to rads, i.e. \pi == f_s/2 max_freq_offset = 2 * numpy.pi / fft_len # Otherwise, it's coarse freq_offset = ((2 * random.random()) - 1) * max_freq_offset sig_len = (fft_len + cp_len) * 10 sync_symbol = [(random.randint(0, 1) * 2) - 1 for x in range(fft_len / 2)] * 2 tx_signal = sync_symbol[-cp_len:] + \ sync_symbol + \ [(random.randint(0, 1)*2)-1 for x in range(sig_len)] mult = gr.multiply_cc() add = gr.add_cc() sync = digital.ofdm_sync_sc_cfb(fft_len, cp_len, True) channel = gr.channel_model(0.005, freq_offset / 2.0 / numpy.pi) sink_freq = gr.vector_sink_f() sink_detect = gr.vector_sink_b() self.tb.connect(gr.vector_source_c(tx_signal), channel, sync) self.tb.connect((sync, 0), sink_freq) self.tb.connect((sync, 1), sink_detect) self.tb.run() phi_hat = sink_freq.data()[sink_detect.data().index(1)] est_freq_offset = 2 * phi_hat / fft_len self.assertAlmostEqual(est_freq_offset, freq_offset, places=2)
def __init__(self, noise_voltage=0.0, frequency_offset=0.0, epsilon=1.0, taps=[1.0,0.0], noise_seed=3021): ''' Creates a channel model that includes: - AWGN noise power in terms of noise voltage - A frequency offest in the channel in ratio - A timing offset ratio to model clock difference (epsilon) - Multipath taps ''' gr.hier_block2.__init__(self, "channel_model", gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature #print epsilon self.timing_offset = gr.fractional_interpolator_cc(0, epsilon) self.multipath = gr.fir_filter_ccc(1, taps) self.noise_adder = gr.add_cc() self.noise = gr.noise_source_c(gr.GR_GAUSSIAN, noise_voltage, noise_seed) self.freq_offset = gr.sig_source_c(1, gr.GR_SIN_WAVE, frequency_offset, 1.0, 0.0) self.mixer_offset = gr.multiply_cc() self.connect(self, self.timing_offset, self.multipath) self.connect(self.multipath, (self.mixer_offset,0)) self.connect(self.freq_offset,(self.mixer_offset,1)) self.connect(self.mixer_offset, (self.noise_adder,1)) self.connect(self.noise, (self.noise_adder,0)) self.connect(self.noise_adder, self)
def __init__(self): gr.top_block.__init__(self, "FFT Sink Test") fft_size = 256 # build our flow graph input_rate = 2048.0e3 #Generate some noise noise = gr.noise_source_c(gr.GR_UNIFORM, 1.0/10) # Generate a complex sinusoid src1 = gr.sig_source_c (input_rate, gr.GR_SIN_WAVE, 2e3, 1) #src1 = gr.sig_source_c(input_rate, gr.GR_CONST_WAVE, 57.50e3, 1) # We add these throttle blocks so that this demo doesn't # suck down all the CPU available. Normally you wouldn't use these. thr1 = gr.throttle(gr.sizeof_gr_complex, input_rate) test_fft = zmq_fft_sink_c(title="Complex Data", fft_size=fft_size, sample_rate=input_rate, baseband_freq=100e3, ref_level=0, y_per_div=20, y_divs=10) combine1 = gr.add_cc() #self.connect(src1, (combine1, 0)) #self.connect(noise,(combine1, 1)) self.connect(src1, thr1, test_fft)
def __init__(self, sample_rate, noise_voltage, frequency_offset, seed=False): gr.hier_block2.__init__(self, "awgn_channel", gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature # Create the Gaussian noise source if not seed: self.noise = gr.noise_source_c(gr.GR_GAUSSIAN, noise_voltage) else: rseed = int(time.time()) self.noise = gr.noise_source_c(gr.GR_GAUSSIAN, noise_voltage, rseed) self.adder = gr.add_cc() # Create the frequency offset self.offset = gr.sig_source_c(1, gr.GR_SIN_WAVE, frequency_offset, 1.0, 0.0) self.mixer = gr.multiply_cc() # Connect the components self.connect(self, (self.mixer, 0)) self.connect(self.offset, (self.mixer, 1)) self.connect(self.mixer, (self.adder, 0)) self.connect(self.noise, (self.adder, 1)) self.connect(self.adder, self)
def __init__(self, frame, panel, vbox, argv): stdgui2.std_top_block.__init__ (self, frame, panel, vbox, argv) pspectrum_len = 1024 # build our flow graph input_rate = 2e6 #Generate some noise noise = gr.noise_source_c(gr.GR_GAUSSIAN, 1.0/10) # Generate a complex sinusoid #source = gr.file_source(gr.sizeof_gr_complex, 'foobar2.dat', repeat=True) src1 = gr.sig_source_c (input_rate, gr.GR_SIN_WAVE, -500e3, 1) src2 = gr.sig_source_c (input_rate, gr.GR_SIN_WAVE, 500e3, 1) src3 = gr.sig_source_c (input_rate, gr.GR_SIN_WAVE, -250e3, 2) # We add these throttle blocks so that this demo doesn't # suck down all the CPU available. Normally you wouldn't use these. thr1 = gr.throttle(gr.sizeof_gr_complex, input_rate) sink1 = spectrum_sink_c (panel, title="Spectrum Sink", pspectrum_len=pspectrum_len, sample_rate=input_rate, baseband_freq=0, ref_level=0, y_per_div=20, y_divs=10, m = 70, n = 3, nsamples = 1024) vbox.Add (sink1.win, 1, wx.EXPAND) combine1=gr.add_cc() self.connect(src1,(combine1,0)) self.connect(src2,(combine1,1)) self.connect(src3,(combine1,2)) self.connect(noise, (combine1,3)) self.connect(combine1,thr1, sink1)
def test_003_multiburst(self): """ Send several bursts, see if the number of detects is correct. Burst lengths and content are random. """ n_bursts = 42 fft_len = 32 cp_len = 4 tx_signal = [] for i in xrange(n_bursts): sync_symbol = [(random.randint(0, 1) * 2) - 1 for x in range(fft_len / 2)] * 2 tx_signal += [0,] * random.randint(0, 2*fft_len) + \ sync_symbol[-cp_len:] + \ sync_symbol + \ [(random.randint(0, 1)*2)-1 for x in range(fft_len * random.randint(5,23))] add = gr.add_cc() sync = digital.ofdm_sync_sc_cfb(fft_len, cp_len) sink_freq = gr.vector_sink_f() sink_detect = gr.vector_sink_b() channel = gr.channel_model(0.005) self.tb.connect(gr.vector_source_c(tx_signal), channel, sync) self.tb.connect((sync, 0), sink_freq) self.tb.connect((sync, 1), sink_detect) self.tb.run() n_bursts_detected = numpy.sum(sink_detect.data()) # We allow for one false alarm or missed burst self.assertTrue( abs(n_bursts_detected - n_bursts) <= 1, msg="""Because of statistics, it is possible (though unlikely) that the number of detected bursts differs slightly. If the number of detects is off by one or two, run the test again and see what happen. Detection error was: %d """ % (numpy.sum(sink_detect.data()) - n_bursts))
def __init__(self, n_sinusoids = 1, SNR = 10, samp_rate = 32e3, nsamples = 2048): gr.hier_block2.__init__(self, "ESPRIT/MUSIC signal generator", gr.io_signature(0, 0, gr.sizeof_float), gr.io_signature(1, 1, gr.sizeof_gr_complex)) sigampl = 10.0**(SNR/10.0) # noise power is 1 self.srcs = list() self.n_sinusoids = n_sinusoids self.samp_rate = samp_rate # create our signals ... for s in range(n_sinusoids): self.srcs.append(gr.sig_source_c(samp_rate, gr.GR_SIN_WAVE,1000 * s + 2000, numpy.sqrt(sigampl/n_sinusoids))) seed = ord(os.urandom(1)) self.noise = gr.noise_source_c(gr.GR_GAUSSIAN, 1, seed) self.add = gr.add_cc() self.head = gr.head(gr.sizeof_gr_complex, nsamples) self.sink = gr.vector_sink_f(vlen=n_sinusoids) # wire it up ... for s in range(n_sinusoids): self.connect(self.srcs[s], (self.add, s)) # Additive noise self.connect(self.noise, (self.add, n_sinusoids)) self.connect(self.add, self.head, self)
def test_001_detect(self): """ Send two bursts, with zeros in between, and check they are both detected at the correct position and no false alarms occur """ n_zeros = 15 fft_len = 32 cp_len = 4 sig_len = (fft_len + cp_len) * 10 sync_symbol = [(random.randint(0, 1) * 2) - 1 for x in range(fft_len / 2)] * 2 tx_signal = [0,] * n_zeros + \ sync_symbol[-cp_len:] + \ sync_symbol + \ [(random.randint(0, 1)*2)-1 for x in range(sig_len)] tx_signal = tx_signal * 2 add = gr.add_cc() sync = digital.ofdm_sync_sc_cfb(fft_len, cp_len) sink_freq = gr.vector_sink_f() sink_detect = gr.vector_sink_b() self.tb.connect(gr.vector_source_c(tx_signal), (add, 0)) self.tb.connect(gr.noise_source_c(gr.GR_GAUSSIAN, .005), (add, 1)) self.tb.connect(add, sync) self.tb.connect((sync, 0), sink_freq) self.tb.connect((sync, 1), sink_detect) self.tb.run() sig1_detect = sink_detect.data()[0:len(tx_signal) / 2] sig2_detect = sink_detect.data()[len(tx_signal) / 2:] self.assertTrue( abs(sig1_detect.index(1) - (n_zeros + fft_len + cp_len)) < cp_len) self.assertTrue( abs(sig2_detect.index(1) - (n_zeros + fft_len + cp_len)) < cp_len) self.assertEqual(numpy.sum(sig1_detect), 1) self.assertEqual(numpy.sum(sig2_detect), 1)
def __init__(self, rx_callback, SNR): """ @param options Optparse option field for command line arguments. @param rx_callback Callback function for the event when a packet is received. """ gr.flow_graph.__init__(self) self.samples_per_symbol = 2 self.data_rate = 2000000 payload_size = 128 # bytes self.packet_transmitter = ieee802_15_4_pkt.ieee802_15_4_mod_pkts(self, spb=self.samples_per_symbol, msgq_limit=2) # add some noise print " Setting SNR to ", SNR add = gr.add_cc() noise = gr.noise_source_c(gr.GR_GAUSSIAN, pow(10.0,-SNR/20.0)) self.packet_receiver = ieee802_15_4_pkt.ieee802_15_4_demod_pkts(self, callback=rx_callback, sps=self.samples_per_symbol, symbol_rate=self.data_rate, threshold=-1) self.connect (self.packet_transmitter, (add,0)) self.connect (noise, (add,1)) self.connect(add, self.packet_receiver)
def run_flow_graph(sync_sym1, sync_sym2, data_sym): top_block = gr.top_block() carr_offset = random.randint(-max_offset/2, max_offset/2) * 2 tx_data = shift_tuple(sync_sym1, carr_offset) + \ shift_tuple(sync_sym2, carr_offset) + \ shift_tuple(data_sym, carr_offset) channel = [rand_range(min_chan_ampl, max_chan_ampl) * numpy.exp(1j * rand_range(0, 2 * numpy.pi)) for x in range(fft_len)] src = gr.vector_source_c(tx_data, False, fft_len) chan= gr.multiply_const_vcc(channel) noise = gr.noise_source_c(gr.GR_GAUSSIAN, wgn_amplitude) add = gr.add_cc(fft_len) chanest = digital.ofdm_chanest_vcvc(sync_sym1, sync_sym2, 1) sink = gr.vector_sink_c(fft_len) top_block.connect(src, chan, (add, 0), chanest, sink) top_block.connect(noise, gr.stream_to_vector(gr.sizeof_gr_complex, fft_len), (add, 1)) top_block.run() channel_est = None carr_offset_hat = 0 rx_sym_est = [0,] * fft_len tags = sink.tags() for tag in tags: if pmt.pmt_symbol_to_string(tag.key) == 'ofdm_sync_carr_offset': carr_offset_hat = pmt.pmt_to_long(tag.value) self.assertEqual(carr_offset, carr_offset_hat) if pmt.pmt_symbol_to_string(tag.key) == 'ofdm_sync_chan_taps': channel_est = shift_tuple(pmt.pmt_c32vector_elements(tag.value), carr_offset) shifted_carrier_mask = shift_tuple(carrier_mask, carr_offset) for i in range(fft_len): if shifted_carrier_mask[i] and channel_est[i]: self.assertAlmostEqual(channel[i], channel_est[i], places=0) rx_sym_est[i] = (sink.data()[i] / channel_est[i]).real return (carr_offset, list(shift_tuple(rx_sym_est, -carr_offset_hat)))
def build_graph (input, raw, snr, freq_offset, coeffs, mag): # Initialize empty flow graph fg = gr.top_block () # Set up file source src = gr.file_source (1, input) # Set up GMSK modulator, 2 samples per symbol mod = gmsk_mod(2) # Amplify the signal tx_amp = 1 amp = gr.multiply_const_cc(1) amp.set_k(tx_amp) # Compute proper noise voltage based on SNR SNR = 10.0**(snr/10.0) power_in_signal = abs(tx_amp)**2 noise_power = power_in_signal/SNR noise_voltage = math.sqrt(noise_power) # Generate noise rseed = int(time.time()) noise = gr.noise_source_c(gr.GR_GAUSSIAN, noise_voltage, rseed) adder = gr.add_cc() fg.connect(noise, (adder, 1)) # Create the frequency offset, 0 for now offset = gr.sig_source_c(1, gr.GR_SIN_WAVE, freq_offset, 1.0, 0.0) mixer = gr.multiply_cc() fg.connect(offset, (mixer, 1)) # Pass the noisy data to the matched filter dfile = open(coeffs, 'r') data = [] for line in dfile: data.append(complex(*map(float,line.strip().strip("()").split(" "))).conjugate()) dfile.close() data.reverse() mfilter = gr.fir_filter_ccc(1, data) # Connect the flow graph fg.connect(src, mod) fg.connect(mod, (mixer, 0)) fg.connect(mixer, (adder, 0)) if mag: raw_dst = gr.file_sink (gr.sizeof_float, raw) magnitude = gr.complex_to_mag(1) fg.connect(adder, mfilter, magnitude, raw_dst) else: raw_dst = gr.file_sink (gr.sizeof_gr_complex, raw) fg.connect(adder, mfilter, raw_dst) print "SNR(db): " + str(snr) print "Frequency Offset: " + str(freq_offset) return fg
def __init__(self): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option) parser.add_option( "-f", "--freq1", type="eng_float", default=1e6, help="set waveform frequency to FREQ [default=%default]") parser.add_option( "-g", "--freq2", type="eng_float", default=1e6, help="set waveform frequency to FREQ [default=%default]") parser.add_option( "-a", "--amplitude1", type="eng_float", default=16e3, help="set waveform amplitude to AMPLITUDE [default=%default]", metavar="AMPL") parser.add_option( "-b", "--amplitude2", type="eng_float", default=16e3, help="set waveform amplitude to AMPLITUDE [default=%default]", metavar="AMPL") parser.add_option( "-i", "--interp", type="int", default=32, help="assume fgpa interpolation rate is INTERP [default=%default]") (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() raise SystemExit, 1 src0 = gr.sig_source_c(master_clock / options.interp, gr.GR_SIN_WAVE, options.freq1, options.amplitude1) src1 = gr.sig_source_c(master_clock / options.interp, gr.GR_SIN_WAVE, options.freq2, options.amplitude2) adder = gr.add_cc() c2s = gr.complex_to_interleaved_short() stdout_sink = gr.file_descriptor_sink(gr.sizeof_short, 1) self.connect(src0, (adder, 0)) self.connect(src1, (adder, 1)) self.connect(adder, c2s, stdout_sink)
def __init__(self, frame, panel, vbox, argv): stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv) fft_size = 256 # build our flow graph input_rate = 2048.0e3 # Generate some noise noise = gr.noise_source_c(gr.GR_UNIFORM, 1.0 / 10) # Generate a complex sinusoid # src1 = gr.sig_source_c (input_rate, gr.GR_SIN_WAVE, 2e3, 1) src1 = gr.sig_source_c(input_rate, gr.GR_CONST_WAVE, 57.50e3, 1) # We add these throttle blocks so that this demo doesn't # suck down all the CPU available. Normally you wouldn't use these. thr1 = gr.throttle(gr.sizeof_gr_complex, input_rate) sink1 = fft_sink_c( panel, title="Complex Data", fft_size=fft_size, sample_rate=input_rate, baseband_freq=100e3, ref_level=0, y_per_div=20, y_divs=10, ) vbox.Add(sink1.win, 1, wx.EXPAND) combine1 = gr.add_cc() self.connect(src1, (combine1, 0)) self.connect(noise, (combine1, 1)) self.connect(combine1, thr1, sink1) # src2 = gr.sig_source_f (input_rate, gr.GR_SIN_WAVE, 2e3, 1) src2 = gr.sig_source_f(input_rate, gr.GR_CONST_WAVE, 57.50e3, 1) thr2 = gr.throttle(gr.sizeof_float, input_rate) sink2 = fft_sink_f( panel, title="Real Data", fft_size=fft_size * 2, sample_rate=input_rate, baseband_freq=100e3, ref_level=0, y_per_div=20, y_divs=10, ) vbox.Add(sink2.win, 1, wx.EXPAND) combine2 = gr.add_ff() c2f2 = gr.complex_to_float() self.connect(src2, (combine2, 0)) self.connect(noise, c2f2, (combine2, 1)) self.connect(combine2, thr2, sink2)
def __init__(self): gr.top_block.__init__(self) self._nsamples = 1000000 self._audio_rate = 8000 # Set up N channels with their own baseband and IF frequencies self._N = 5 chspacing = 16000 freq = [10, 20, 30, 40, 50] f_lo = [0, 1*chspacing, -1*chspacing, 2*chspacing, -2*chspacing] self._if_rate = 4*self._N*self._audio_rate # Create a signal source and frequency modulate it self.sum = gr.add_cc () for n in xrange(self._N): sig = gr.sig_source_f(self._audio_rate, gr.GR_SIN_WAVE, freq[n], 0.5) fm = fmtx(f_lo[n], self._audio_rate, self._if_rate) self.connect(sig, fm) self.connect(fm, (self.sum, n)) self.head = gr.head(gr.sizeof_gr_complex, self._nsamples) self.snk_tx = gr.vector_sink_c() self.channel = blks2.channel_model(0.1) self.connect(self.sum, self.head, self.channel, self.snk_tx) # Design the channlizer self._M = 10 bw = chspacing/2.0 t_bw = chspacing/10.0 self._chan_rate = self._if_rate / self._M self._taps = gr.firdes.low_pass_2(1, self._if_rate, bw, t_bw, attenuation_dB=100, window=gr.firdes.WIN_BLACKMAN_hARRIS) tpc = math.ceil(float(len(self._taps)) / float(self._M)) print "Number of taps: ", len(self._taps) print "Number of channels: ", self._M print "Taps per channel: ", tpc self.pfb = blks2.pfb_channelizer_ccf(self._M, self._taps) self.connect(self.channel, self.pfb) # Create a file sink for each of M output channels of the filter and connect it self.fmdet = list() self.squelch = list() self.snks = list() for i in xrange(self._M): self.fmdet.append(blks2.nbfm_rx(self._audio_rate, self._chan_rate)) self.squelch.append(blks2.standard_squelch(self._audio_rate*10)) self.snks.append(gr.vector_sink_f()) self.connect((self.pfb, i), self.fmdet[i], self.squelch[i], self.snks[i])
def __init__(self): gr.hier_block2.__init__(self, "symbol_0_slicer", gr.io_signature(2, 2, gr.sizeof_gr_complex), gr.io_signature(1, 1, gr.sizeof_float)) adder = gr.add_cc() to_mag = gr.complex_to_mag_squared() self.connect((self, 0), (adder, 0)) self.connect((self, 1), (adder, 1)) self.connect(adder, to_mag, self)
def __init__(self, tx_id, rx_id, sample_rate, filename): """ Parameters: sample_rate: int or float sample_rate of the flowgraph filename: string file containing the channel model Notes: The modelfile was created with the pickle module and contains a list of sum of cisoids, each sum of cisoids models the Doppler spectrum with a specific delay. If one list element is empty this means that there exist no scatterers with the specified delay. Each sum of cisoids, i.e. list element, contains again a list of amplitudes and frequencies. """ gr.hier_block2.__init__(self, "Channel Sounder Measurement", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(1, 1, gr.sizeof_gr_complex)) self.sample_rate = sample_rate fp = open(filename, 'r') model = pickle.load(fp) self.taps_delays = [] # check for non-empty list elements to find multipath components with a # certain delay for idx, mpc in enumerate(model): if mpc: self.taps_delays.append(idx) # print 'taps_delays', self.taps_delays # create a tapped delay line structure, since the amplitudes of the sum # of cisoids already contain all the information about the power of a # Doppler spectrum, the power delay profile is set to 1 for all delays. self.mpc_channel = mpc_channel_cc(self.taps_delays, [1] * len(self.taps_delays)) # loop through all delays for idx, delay in enumerate(self.taps_delays): adder = gr.add_cc() # loop through all cisoids of a delay for iidx, (freq, ampl) in enumerate(model[delay]): src = gr.sig_source_c(sample_rate, gr.GR_COS_WAVE, freq, ampl) self.connect(src, (adder, iidx)) # print iidx self.connect(adder, (self.mpc_channel, idx + 1)) self.connect(self, (self.mpc_channel, 0)) self.connect(self.mpc_channel, self)
def __init__(self): gr.top_block.__init__(self) self._N = 2000000 # number of samples to use self._fs = 1000 # initial sampling rate self._M = M = 9 # Number of channels to channelize self._ifs = M * self._fs # initial sampling rate # Create a set of taps for the PFB channelizer self._taps = filter.firdes.low_pass_2( 1, self._ifs, 475.50, 50, attenuation_dB=100, window=filter.firdes.WIN_BLACKMAN_hARRIS) # Calculate the number of taps per channel for our own information tpc = scipy.ceil(float(len(self._taps)) / float(self._M)) print "Number of taps: ", len(self._taps) print "Number of channels: ", self._M print "Taps per channel: ", tpc # Create a set of signals at different frequencies # freqs lists the frequencies of the signals that get stored # in the list "signals", which then get summed together self.signals = list() self.add = gr.add_cc() freqs = [-70, -50, -30, -10, 10, 20, 40, 60, 80] for i in xrange(len(freqs)): f = freqs[i] + (M / 2 - M + i + 1) * self._fs self.signals.append( gr.sig_source_c(self._ifs, gr.GR_SIN_WAVE, f, 1)) self.connect(self.signals[i], (self.add, i)) self.head = gr.head(gr.sizeof_gr_complex, self._N) # Construct the channelizer filter self.pfb = filter.pfb.channelizer_ccf(self._M, self._taps, 1) # Construct a vector sink for the input signal to the channelizer self.snk_i = gr.vector_sink_c() # Connect the blocks self.connect(self.add, self.head, self.pfb) self.connect(self.add, self.snk_i) # Use this to play with the channel mapping #self.pfb.set_channel_map([5,6,7,8,0,1,2,3,4]) # Create a vector sink for each of M output channels of the filter and connect it self.snks = list() for i in xrange(self._M): self.snks.append(gr.vector_sink_c()) self.connect((self.pfb, i), self.snks[i])
def __init__(self): gr.top_block.__init__(self) Rs = 8000 f1 = 100 f2 = 200 npts = 2048 self.qapp = QtGui.QApplication(sys.argv) src1 = gr.sig_source_c(Rs, gr.GR_SIN_WAVE, f1, 0.1, 0) src2 = gr.sig_source_c(Rs, gr.GR_SIN_WAVE, f2, 0.1, 0) src = gr.add_cc() channel = filter.channel_model(0.01) thr = gr.throttle(gr.sizeof_gr_complex, 100*npts) self.snk1 = qtgui.time_sink_c(npts, Rs, "Complex Time Example", 1) self.connect(src1, (src,0)) self.connect(src2, (src,1)) self.connect(src, channel, thr, (self.snk1, 0)) #self.connect(src1, (self.snk1, 1)) #self.connect(src2, (self.snk1, 2)) self.ctrl_win = control_box() self.ctrl_win.attach_signal1(src1) self.ctrl_win.attach_signal2(src2) # Get the reference pointer to the SpectrumDisplayForm QWidget pyQt = self.snk1.pyqwidget() # Wrap the pointer as a PyQt SIP object # This can now be manipulated as a PyQt4.QtGui.QWidget pyWin = sip.wrapinstance(pyQt, QtGui.QWidget) # Example of using signal/slot to set the title of a curve pyWin.connect(pyWin, QtCore.SIGNAL("setTitle(int, QString)"), pyWin, QtCore.SLOT("setTitle(int, QString)")) pyWin.emit(QtCore.SIGNAL("setTitle(int, QString)"), 0, "Re{sum}") self.snk1.set_title(1, "Im{Sum}") #self.snk1.set_title(2, "Re{src1}") #self.snk1.set_title(3, "Im{src1}") #self.snk1.set_title(4, "Re{src2}") #self.snk1.set_title(5, "Im{src2}") # Can also set the color of a curve #self.snk1.set_color(5, "blue") self.snk1.set_update_time(0.5) #pyWin.show() self.main_box = dialog_box(pyWin, self.ctrl_win) self.main_box.show()
def _get_gauss_rand_proc_c(self): """ Returns the Gaussian random process. """ spec_getter = getattr(self.model, 'get_' + self.spec_type) if self.spec_type in self.model.specs_odd: from winelo.channel import spec2soc soc = spec2soc(spec_getter(), method=self.method, N=self.N) sources = [] adder = gr.add_cc() for idx, (freq, ampl) in enumerate(soc.get_soc()): sources.append(gr.sig_source_c(self.sample_rate, gr.GR_COS_WAVE, freq, ampl)) self.connect(sources[idx], gr.skiphead(gr.sizeof_gr_complex, randint(low=0, high=self.sample_rate)), (adder, idx)) return adder elif self.spec_type in self.model.specs_even: from winelo.channel import spec2sos # real part of the gaussian random process sos_real = spec2sos(spec_getter(), method=self.method, N=self.N) sources_real = [] adder_real = gr.add_ff() for idx, (freq, ampl) in enumerate(sos_real.get_sos()): sources_real.append(gr.sig_source_f(self.sample_rate, gr.GR_COS_WAVE, freq, ampl)) self.connect(sources_real[idx], gr.skiphead(gr.sizeof_float, randint(low=0, high=self.sample_rate)), (adder_real, idx)) # imaginary part of the gaussian random process sos_imaginary = spec2sos(spec_getter(), method=self.method, N=self.N + 1) sources_imag = [] adder_imag = gr.add_ff() for idx, (freq, ampl) in enumerate(sos_imaginary.get_sos()): sources_imag.append(gr.sig_source_f(self.sample_rate, gr.GR_COS_WAVE, freq, ampl)) self.connect(sources_imag[idx], gr.skiphead(gr.sizeof_float, randint(low=0, high=self.sample_rate)), (adder_imag, idx)) float2complex = gr.float_to_complex() self.connect(adder_real, (float2complex, 0)) self.connect(adder_imag, (float2complex, 1)) return float2complex else: print 'You picked a non-existant Doppler spectrum' print 'Pick one of the following: ', \ self.model.specs_even + self.model.specs_odd return None
def __init__(self, frame, panel, vbox, argv): stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv) fft_size = 256 # build our flow graph input_rate = 2048.0e3 #Generate some noise noise = gr.noise_source_c(gr.GR_UNIFORM, 1.0 / 10) # Generate a complex sinusoid #src1 = gr.sig_source_c (input_rate, gr.GR_SIN_WAVE, 2e3, 1) src1 = gr.sig_source_c(input_rate, gr.GR_CONST_WAVE, 57.50e3, 1) # We add these throttle blocks so that this demo doesn't # suck down all the CPU available. Normally you wouldn't use these. thr1 = gr.throttle(gr.sizeof_gr_complex, input_rate) sink1 = fft_sink_c(panel, title="Complex Data", fft_size=fft_size, sample_rate=input_rate, baseband_freq=100e3, ref_level=0, y_per_div=20, y_divs=10) vbox.Add(sink1.win, 1, wx.EXPAND) combine1 = gr.add_cc() self.connect(src1, (combine1, 0)) self.connect(noise, (combine1, 1)) self.connect(combine1, thr1, sink1) #src2 = gr.sig_source_f (input_rate, gr.GR_SIN_WAVE, 2e3, 1) src2 = gr.sig_source_f(input_rate, gr.GR_CONST_WAVE, 57.50e3, 1) thr2 = gr.throttle(gr.sizeof_float, input_rate) sink2 = fft_sink_f(panel, title="Real Data", fft_size=fft_size * 2, sample_rate=input_rate, baseband_freq=100e3, ref_level=0, y_per_div=20, y_divs=10) vbox.Add(sink2.win, 1, wx.EXPAND) combine2 = gr.add_ff() c2f2 = gr.complex_to_float() self.connect(src2, (combine2, 0)) self.connect(noise, c2f2, (combine2, 1)) self.connect(combine2, thr2, sink2)
def __init__(self): gr.top_block.__init__(self) Rs = 8000 f1 = 100 f2 = 200 npts = 2048 self.qapp = QtGui.QApplication(sys.argv) src1 = gr.sig_source_c(Rs, gr.GR_SIN_WAVE, f1, 0.1, 0) src2 = gr.sig_source_c(Rs, gr.GR_SIN_WAVE, f2, 0.1, 0) src = gr.add_cc() channel = gr.channel_model(0.01) thr = gr.throttle(gr.sizeof_gr_complex, 100*npts) self.snk1 = qtgui.time_sink_c(npts, Rs, "Complex Time Example", 3) self.connect(src1, (src,0)) self.connect(src2, (src,1)) self.connect(src, channel, thr, (self.snk1, 0)) self.connect(src1, (self.snk1, 1)) self.connect(src2, (self.snk1, 2)) self.ctrl_win = control_box() self.ctrl_win.attach_signal1(src1) self.ctrl_win.attach_signal2(src2) # Get the reference pointer to the SpectrumDisplayForm QWidget pyQt = self.snk1.pyqwidget() # Wrap the pointer as a PyQt SIP object # This can now be manipulated as a PyQt4.QtGui.QWidget pyWin = sip.wrapinstance(pyQt, QtGui.QWidget) # Example of using signal/slot to set the title of a curve pyWin.connect(pyWin, QtCore.SIGNAL("setTitle(int, QString)"), pyWin, QtCore.SLOT("setTitle(int, QString)")) pyWin.emit(QtCore.SIGNAL("setTitle(int, QString)"), 0, "Re{sum}") self.snk1.set_title(1, "Im{Sum}") self.snk1.set_title(2, "Re{src1}") self.snk1.set_title(3, "Im{src1}") self.snk1.set_title(4, "Re{src2}") self.snk1.set_title(5, "Im{src2}") # Can also set the color of a curve #self.snk1.set_color(5, "blue") #pyWin.show() self.main_box = dialog_box(pyWin, self.ctrl_win) self.main_box.show()
def __init__(self, avg_len): gr.hier_block2.__init__(self, "dc_block", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(1, 1, gr.sizeof_gr_complex)) self.mvg_avg = gr.moving_average_cc(avg_len, complex(-1.0, 0.0) / avg_len, 4 * avg_len) self.adder = gr.add_cc() self.connect(self, self.mvg_avg, (self.adder, 0)) self.connect(self, (self.adder, 1)) self.connect(self.adder, self)
def __init__(self): gr.top_block.__init__(self) self._N = 2000000 # number of samples to use self._fs = 1000 # initial sampling rate self._M = M = 9 # Number of channels to channelize self._ifs = M*self._fs # initial sampling rate # Create a set of taps for the PFB channelizer self._taps = filter.firdes.low_pass_2(1, self._ifs, 475.50, 50, attenuation_dB=100, window=filter.firdes.WIN_BLACKMAN_hARRIS) # Calculate the number of taps per channel for our own information tpc = scipy.ceil(float(len(self._taps)) / float(self._M)) print "Number of taps: ", len(self._taps) print "Number of channels: ", self._M print "Taps per channel: ", tpc # Create a set of signals at different frequencies # freqs lists the frequencies of the signals that get stored # in the list "signals", which then get summed together self.signals = list() self.add = gr.add_cc() freqs = [-70, -50, -30, -10, 10, 20, 40, 60, 80] for i in xrange(len(freqs)): f = freqs[i] + (M/2-M+i+1)*self._fs self.signals.append(gr.sig_source_c(self._ifs, gr.GR_SIN_WAVE, f, 1)) self.connect(self.signals[i], (self.add,i)) self.head = gr.head(gr.sizeof_gr_complex, self._N) # Construct the channelizer filter self.pfb = filter.pfb.channelizer_ccf(self._M, self._taps, 1) # Construct a vector sink for the input signal to the channelizer self.snk_i = gr.vector_sink_c() # Connect the blocks self.connect(self.add, self.head, self.pfb) self.connect(self.add, self.snk_i) # Use this to play with the channel mapping #self.pfb.set_channel_map([5,6,7,8,0,1,2,3,4]) # Create a vector sink for each of M output channels of the filter and connect it self.snks = list() for i in xrange(self._M): self.snks.append(gr.vector_sink_c()) self.connect((self.pfb, i), self.snks[i])
def __init__(self): gr.top_block.__init__(self) self._N = 10000000 # number of samples to use self._fs = 10000 # initial sampling rate self._decim = 20 # Decimation rate # Generate the prototype filter taps for the decimators with a 200 Hz bandwidth self._taps = gr.firdes.low_pass_2(1, self._fs, 200, 150, attenuation_dB=120, window=gr.firdes.WIN_BLACKMAN_hARRIS) # Calculate the number of taps per channel for our own information tpc = scipy.ceil(float(len(self._taps)) / float(self._decim)) print "Number of taps: ", len(self._taps) print "Number of filters: ", self._decim print "Taps per channel: ", tpc # Build the input signal source # We create a list of freqs, and a sine wave is generated and added to the source # for each one of these frequencies. self.signals = list() self.add = gr.add_cc() freqs = [10, 20, 2040] for i in xrange(len(freqs)): self.signals.append( gr.sig_source_c(self._fs, gr.GR_SIN_WAVE, freqs[i], 1)) self.connect(self.signals[i], (self.add, i)) self.head = gr.head(gr.sizeof_gr_complex, self._N) # Construct a PFB decimator filter self.pfb = blks2.pfb_decimator_ccf(self._decim, self._taps, 0) # Construct a standard FIR decimating filter self.dec = gr.fir_filter_ccf(self._decim, self._taps) self.snk_i = gr.vector_sink_c() # Connect the blocks self.connect(self.add, self.head, self.pfb) self.connect(self.add, self.snk_i) # Create the sink for the decimated siganl self.snk = gr.vector_sink_c() self.connect(self.pfb, self.snk)
def __init__ ( self, noise_power, coherence_time, taps ): gr.hier_block2.__init__(self, "fading_channel", gr.io_signature( 1, 1, gr.sizeof_gr_complex ), gr.io_signature( 1, 1, gr.sizeof_gr_complex ) ) inp = gr.kludge_copy( gr.sizeof_gr_complex ) self.connect( self, inp ) tap1_delay = gr.delay( gr.sizeof_gr_complex, 1 ) tap2_delay = gr.delay( gr.sizeof_gr_complex, 2 ) self.connect( inp, tap1_delay ) self.connect( inp, tap2_delay ) fd = 100 z = numpy.arange(-fd+0.1,fd,0.1) t = numpy.sqrt(1. / ( pi * fd * numpy.sqrt( 1. - (z/fd)**2 ) ) ) tap1_noise = ofdm.complex_white_noise( 0.0, taps[0] ) tap1_filter = gr.fft_filter_ccc(1, t) self.connect( tap1_noise, tap1_filter ) tap1_mult = gr.multiply_cc() self.connect( tap1_filter, (tap1_mult,0) ) self.connect( tap1_delay, (tap1_mult,1) ) tap2_noise = ofdm.complex_white_noise( 0.0, taps[1] ) tap2_filter = gr.fft_filter_ccc(1, t) self.connect( tap2_noise, tap2_filter ) tap2_mult = gr.multiply_cc() self.connect( tap2_filter, (tap2_mult,0) ) self.connect( tap2_delay, (tap2_mult,1) ) noise_src = ofdm.complex_white_noise( 0.0, sqrt( noise_power ) ) chan = gr.add_cc() self.connect( inp, (chan,0) ) self.connect( tap1_mult, (chan,1) ) self.connect( tap2_mult, (chan,2) ) self.connect( noise_src, (chan,3) ) self.connect( chan, self ) log_to_file( self, tap1_filter, "data/tap1_filter.compl") log_to_file( self, tap1_filter, "data/tap1_filter.float", mag=True) log_to_file( self, tap2_filter, "data/tap2_filter.compl") log_to_file( self, tap2_filter, "data/tap2_filter.float", mag=True)
def __init__(self, frame, panel, vbox, argv): stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv) default_input_rate = 1e6 if len(argv) > 1: input_rate = int(argv[1]) else: input_rate = default_input_rate if len(argv) > 2: v_scale = float(argv[2]) # start up at this v_scale value else: v_scale = None # start up in autorange mode, default if len(argv) > 3: t_scale = float(argv[3]) # start up at this t_scale value else: t_scale = .00003 * default_input_rate / input_rate # old behavior print "input rate %s v_scale %s t_scale %s" % (input_rate, v_scale, t_scale) # Generate a complex sinusoid ampl = 1.0e3 self.src0 = gr.sig_source_c(input_rate, gr.GR_SIN_WAVE, 25.1e3 * input_rate / default_input_rate, ampl) self.noise = gr.sig_source_c( input_rate, gr.GR_SIN_WAVE, 11.1 * 25.1e3 * input_rate / default_input_rate, ampl / 10) #self.noise =gr.noise_source_c(gr.GR_GAUSSIAN, ampl/10) self.combine = gr.add_cc() # We add this throttle block so that this demo doesn't suck down # all the CPU available. You normally wouldn't use it... self.thr = gr.throttle(gr.sizeof_gr_complex, input_rate) scope = scope_sink_c(panel, "Secret Data", sample_rate=input_rate, v_scale=v_scale, t_scale=t_scale) vbox.Add(scope.win, 1, wx.EXPAND) # Ultimately this will be # self.connect("src0 throttle scope") self.connect(self.src0, (self.combine, 0)) self.connect(self.noise, (self.combine, 1)) self.connect(self.combine, self.thr, scope)
def test_000(self): N = 1000 # number of samples to use M = 5 # Number of channels fs = 1000 # baseband sampling rate ifs = M * fs # input samp rate to decimator channel = 0 # Extract channel 0 taps = filter.firdes.low_pass_2( 1, ifs, fs / 2, fs / 10, attenuation_dB=80, window=filter.firdes.WIN_BLACKMAN_hARRIS) signals = list() add = gr.add_cc() freqs = [-200, -100, 0, 100, 200] for i in xrange(len(freqs)): f = freqs[i] + (M / 2 - M + i + 1) * fs signals.append(gr.sig_source_c(ifs, gr.GR_SIN_WAVE, f, 1)) self.tb.connect(signals[i], (add, i)) head = gr.head(gr.sizeof_gr_complex, N) s2ss = gr.stream_to_streams(gr.sizeof_gr_complex, M) pfb = filter.pfb_decimator_ccf(M, taps, channel) snk = gr.vector_sink_c() self.tb.connect(add, head, s2ss) for i in xrange(M): self.tb.connect((s2ss, i), (pfb, i)) self.tb.connect(pfb, snk) self.tb.run() Ntest = 50 L = len(snk.data()) t = map(lambda x: float(x) / fs, xrange(L)) # Create known data as complex sinusoids for the baseband freq # of the extracted channel is due to decimator output order. phase = 0 expected_data = map(lambda x: math.cos(2.*math.pi*freqs[2]*x+phase) + \ 1j*math.sin(2.*math.pi*freqs[2]*x+phase), t) dst_data = snk.data() self.assertComplexTuplesAlmostEqual(expected_data[-Ntest:], dst_data[-Ntest:], 4)
def __init__(self, noise_dB=-20., fir_taps=[1]): gr.hier_block2.__init__(self, 'my_channel', gr.io_signature(1,1,gr.sizeof_gr_complex), gr.io_signature(1,1,gr.sizeof_gr_complex)) noise_adder = gr.add_cc() noise = gr.noise_source_c(gr.GR_GAUSSIAN, 10**(noise_dB/20.), random.randint(0,2**30)) # normalize taps firtabsum = float(sum(map(abs,fir_taps))) fir_taps = [ i / firtabsum for i in fir_taps] multipath = gr.fir_filter_ccc(1,fir_taps) self.connect(noise, (noise_adder,1)) self.connect(self, noise_adder, multipath, self) self.__dict__.update(locals()) # didn't feel like using self all over the place
def __init__(self, noise_power, coherence_time, taps): gr.hier_block2.__init__(self, "fading_channel", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(1, 1, gr.sizeof_gr_complex)) inp = gr.kludge_copy(gr.sizeof_gr_complex) self.connect(self, inp) tap1_delay = gr.delay(gr.sizeof_gr_complex, 1) tap2_delay = gr.delay(gr.sizeof_gr_complex, 2) self.connect(inp, tap1_delay) self.connect(inp, tap2_delay) fd = 100 z = numpy.arange(-fd + 0.1, fd, 0.1) t = numpy.sqrt(1. / (pi * fd * numpy.sqrt(1. - (z / fd)**2))) tap1_noise = ofdm.complex_white_noise(0.0, taps[0]) tap1_filter = gr.fft_filter_ccc(1, t) self.connect(tap1_noise, tap1_filter) tap1_mult = gr.multiply_cc() self.connect(tap1_filter, (tap1_mult, 0)) self.connect(tap1_delay, (tap1_mult, 1)) tap2_noise = ofdm.complex_white_noise(0.0, taps[1]) tap2_filter = gr.fft_filter_ccc(1, t) self.connect(tap2_noise, tap2_filter) tap2_mult = gr.multiply_cc() self.connect(tap2_filter, (tap2_mult, 0)) self.connect(tap2_delay, (tap2_mult, 1)) noise_src = ofdm.complex_white_noise(0.0, sqrt(noise_power)) chan = gr.add_cc() self.connect(inp, (chan, 0)) self.connect(tap1_mult, (chan, 1)) self.connect(tap2_mult, (chan, 2)) self.connect(noise_src, (chan, 3)) self.connect(chan, self) log_to_file(self, tap1_filter, "data/tap1_filter.compl") log_to_file(self, tap1_filter, "data/tap1_filter.float", mag=True) log_to_file(self, tap2_filter, "data/tap2_filter.compl") log_to_file(self, tap2_filter, "data/tap2_filter.float", mag=True)
def __init__(self): gr.top_block.__init__(self) parser = OptionParser(option_class=eng_option) parser.add_option( "-f", "--freq1", type="eng_float", default=1e6, help="set waveform frequency to FREQ [default=%default]" ) parser.add_option( "-g", "--freq2", type="eng_float", default=1e6, help="set waveform frequency to FREQ [default=%default]" ) parser.add_option( "-a", "--amplitude1", type="eng_float", default=16e3, help="set waveform amplitude to AMPLITUDE [default=%default]", metavar="AMPL", ) parser.add_option( "-b", "--amplitude2", type="eng_float", default=16e3, help="set waveform amplitude to AMPLITUDE [default=%default]", metavar="AMPL", ) parser.add_option( "-i", "--interp", type="int", default=32, help="assume fgpa interpolation rate is INTERP [default=%default]" ) (options, args) = parser.parse_args() if len(args) != 0: parser.print_help() raise SystemExit, 1 src0 = gr.sig_source_c(master_clock / options.interp, gr.GR_SIN_WAVE, options.freq1, options.amplitude1) src1 = gr.sig_source_c(master_clock / options.interp, gr.GR_SIN_WAVE, options.freq2, options.amplitude2) adder = gr.add_cc() c2s = gr.complex_to_interleaved_short() stdout_sink = gr.file_descriptor_sink(gr.sizeof_short, 1) self.connect(src0, (adder, 0)) self.connect(src1, (adder, 1)) self.connect(adder, c2s, stdout_sink)
def test_000(self): N = 1000 # number of samples to use M = 5 # Number of channels fs = 1000 # baseband sampling rate ifs = M * fs # input samp rate to decimator channel = 0 # Extract channel 0 taps = filter.firdes.low_pass_2( 1, ifs, fs / 2, fs / 10, attenuation_dB=80, window=filter.firdes.WIN_BLACKMAN_hARRIS ) signals = list() add = gr.add_cc() freqs = [-200, -100, 0, 100, 200] for i in xrange(len(freqs)): f = freqs[i] + (M / 2 - M + i + 1) * fs signals.append(gr.sig_source_c(ifs, gr.GR_SIN_WAVE, f, 1)) self.tb.connect(signals[i], (add, i)) head = gr.head(gr.sizeof_gr_complex, N) s2ss = gr.stream_to_streams(gr.sizeof_gr_complex, M) pfb = filter.pfb_decimator_ccf(M, taps, channel) snk = gr.vector_sink_c() self.tb.connect(add, head, s2ss) for i in xrange(M): self.tb.connect((s2ss, i), (pfb, i)) self.tb.connect(pfb, snk) self.tb.run() Ntest = 50 L = len(snk.data()) t = map(lambda x: float(x) / fs, xrange(L)) # Create known data as complex sinusoids for the baseband freq # of the extracted channel is due to decimator output order. phase = 0 expected_data = map( lambda x: math.cos(2.0 * math.pi * freqs[2] * x + phase) + 1j * math.sin(2.0 * math.pi * freqs[2] * x + phase), t, ) dst_data = snk.data() self.assertComplexTuplesAlmostEqual(expected_data[-Ntest:], dst_data[-Ntest:], 4)
def __init__(self, noise_dB=-20., fir_taps=[1]): gr.hier_block2.__init__(self, 'my_channel', gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(1, 1, gr.sizeof_gr_complex)) noise_adder = gr.add_cc() noise = gr.noise_source_c(gr.GR_GAUSSIAN, 10**(noise_dB / 20.), random.randint(0, 2**30)) # normalize taps firtabsum = float(sum(map(abs, fir_taps))) fir_taps = [i / firtabsum for i in fir_taps] multipath = gr.fir_filter_ccc(1, fir_taps) self.connect(noise, (noise_adder, 1)) self.connect(self, noise_adder, multipath, self) self.__dict__.update( locals()) # didn't feel like using self all over the place
def __init__(self): gr.top_block.__init__(self) Rs = 8000 f1 = 1000 f2 = 2000 fftsize = 2048 self.qapp = QtGui.QApplication(sys.argv) src1 = gr.sig_source_c(Rs, gr.GR_SIN_WAVE, f1, 0.1, 0) src2 = gr.sig_source_c(Rs, gr.GR_SIN_WAVE, f2, 0.1, 0) src = gr.add_cc() channel = gr.channel_model(0.001) thr = gr.throttle(gr.sizeof_gr_complex, 100*fftsize) self.snk1 = qtgui2.sink_c(fftsize, gr.firdes.WIN_BLACKMAN_hARRIS, 0, Rs, "Complex Signal Example", True, True, False, True, True, True, True) #True, False, False, False, False, True, False) #fft , wfall, 3dwf , time , const, oGL , formui # Get the reference pointer to the SpectrumDisplayForm QWidget pyQt = self.snk1.pyqwidget() # Wrap the pointer as a PyQt SIP object # This can now be manipulated as a PyQt4.QtGui.QWidget self.pyWin = sip.wrapinstance(pyQt, QtGui.QWidget) self.connect(src1, (src,0)) self.connect(src2, (src,1)) self.connect(src, channel, thr, self.snk1) self.ctrl_win = control_box(self.snk1) self.ctrl_win.attach_signal1(src1) self.ctrl_win.attach_signal2(src2) self.main_box = dialog_box(self.pyWin, self.ctrl_win) self.main_box.show()
def __init__(self): gr.top_block.__init__(self) self._N = 10000000 # number of samples to use self._fs = 10000 # initial sampling rate self._decim = 20 # Decimation rate # Generate the prototype filter taps for the decimators with a 200 Hz bandwidth self._taps = filter.firdes.low_pass_2( 1, self._fs, 200, 150, attenuation_dB=120, window=filter.firdes.WIN_BLACKMAN_hARRIS ) # Calculate the number of taps per channel for our own information tpc = scipy.ceil(float(len(self._taps)) / float(self._decim)) print "Number of taps: ", len(self._taps) print "Number of filters: ", self._decim print "Taps per channel: ", tpc # Build the input signal source # We create a list of freqs, and a sine wave is generated and added to the source # for each one of these frequencies. self.signals = list() self.add = gr.add_cc() freqs = [10, 20, 2040] for i in xrange(len(freqs)): self.signals.append(gr.sig_source_c(self._fs, gr.GR_SIN_WAVE, freqs[i], 1)) self.connect(self.signals[i], (self.add, i)) self.head = gr.head(gr.sizeof_gr_complex, self._N) # Construct a PFB decimator filter self.pfb = filter.pfb.decimator_ccf(self._decim, self._taps, 0) # Construct a standard FIR decimating filter self.dec = filter.fir_filter_ccf(self._decim, self._taps) self.snk_i = gr.vector_sink_c() # Connect the blocks self.connect(self.add, self.head, self.pfb) self.connect(self.add, self.snk_i) # Create the sink for the decimated siganl self.snk = gr.vector_sink_c() self.connect(self.pfb, self.snk)
def __init__(self, constellation, f, N0=0.25, seed=-666L): """ constellation - a constellation object used for modulation. f - a finite state machine specification used for coding. N0 - noise level seed - random seed """ super(trellis_tb, self).__init__() # packet size in bits (make it multiple of 16 so it can be packed in a short) packet_size = 1024 * 16 # bits per FSM input symbol bitspersymbol = int(round(math.log(f.I()) / math.log(2))) # bits per FSM input symbol # packet size in trellis steps K = packet_size / bitspersymbol # TX src = gr.lfsr_32k_source_s() # packet size in shorts src_head = gr.head(gr.sizeof_short, packet_size / 16) # unpack shorts to symbols compatible with the FSM input cardinality s2fsmi = gr.packed_to_unpacked_ss(bitspersymbol, gr.GR_MSB_FIRST) # initial FSM state = 0 enc = trellis.encoder_ss(f, 0) mod = gr.chunks_to_symbols_sc(constellation.points(), 1) # CHANNEL add = gr.add_cc() noise = gr.noise_source_c(gr.GR_GAUSSIAN, math.sqrt(N0 / 2), seed) # RX # data preprocessing to generate metrics for Viterbi metrics = trellis.constellation_metrics_cf( constellation.base(), digital_swig.TRELLIS_EUCLIDEAN) # Put -1 if the Initial/Final states are not set. va = trellis.viterbi_s(f, K, 0, -1) # pack FSM input symbols to shorts fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol, gr.GR_MSB_FIRST) # check the output self.dst = gr.check_lfsr_32k_s() self.connect(src, src_head, s2fsmi, enc, mod) self.connect(mod, (add, 0)) self.connect(noise, (add, 1)) self.connect(add, metrics, va, fsmi2s, self.dst)
def run_flow_graph(sync_sym1, sync_sym2, data_sym): top_block = gr.top_block() carr_offset = random.randint(-max_offset / 2, max_offset / 2) * 2 tx_data = shift_tuple(sync_sym1, carr_offset) + \ shift_tuple(sync_sym2, carr_offset) + \ shift_tuple(data_sym, carr_offset) channel = [ rand_range(min_chan_ampl, max_chan_ampl) * numpy.exp(1j * rand_range(0, 2 * numpy.pi)) for x in range(fft_len) ] src = gr.vector_source_c(tx_data, False, fft_len) chan = gr.multiply_const_vcc(channel) noise = gr.noise_source_c(gr.GR_GAUSSIAN, wgn_amplitude) add = gr.add_cc(fft_len) chanest = digital.ofdm_chanest_vcvc(sync_sym1, sync_sym2, 1) sink = gr.vector_sink_c(fft_len) top_block.connect(src, chan, (add, 0), chanest, sink) top_block.connect( noise, gr.stream_to_vector(gr.sizeof_gr_complex, fft_len), (add, 1)) top_block.run() channel_est = None carr_offset_hat = 0 rx_sym_est = [ 0, ] * fft_len tags = sink.tags() for tag in tags: if pmt.pmt_symbol_to_string( tag.key) == 'ofdm_sync_carr_offset': carr_offset_hat = pmt.pmt_to_long(tag.value) self.assertEqual(carr_offset, carr_offset_hat) if pmt.pmt_symbol_to_string(tag.key) == 'ofdm_sync_chan_taps': channel_est = shift_tuple( pmt.pmt_c32vector_elements(tag.value), carr_offset) shifted_carrier_mask = shift_tuple(carrier_mask, carr_offset) for i in range(fft_len): if shifted_carrier_mask[i] and channel_est[i]: self.assertAlmostEqual(channel[i], channel_est[i], places=0) rx_sym_est[i] = (sink.data()[i] / channel_est[i]).real return (carr_offset, list(shift_tuple(rx_sym_est, -carr_offset_hat)))
def __init__(self,ampl_i,band,symbol_rate,sps): gr.hier_block2.__init__(self,"Channel", gr.io_signature(1,1,gr.sizeof_gr_complex), gr.io_signature(1,1,gr.sizeof_gr_complex)) self.symbol_rate = symbol_rate self.sample_rate=symbol_rate*sps self.fading = False self.adder = gr.add_cc() self.noise = gr.noise_source_c(gr.GR_GAUSSIAN, 1, -42) self.ampl = gr.multiply_const_cc(ampl_i) self.taps = gr.firdes.low_pass_2 (1,280,band/2,5,80,gr.firdes.WIN_KAISER) self.filter=gr.fir_filter_ccf(1,self.taps) #Connects self.connect(self,self.filter,(self.adder,0)) self.connect(self.noise, self.ampl, (self.adder,1)) self.connect(self.adder, self)
def test_100(self): vlen = 256 N = int( 5e5 ) soff=40 taps = [1.0,0.0,2e-1+0.1j,1e-4-0.04j] freqoff = 0.0 snr_db = 10 rms_amplitude = 8000 data = [1 + 1j] * vlen #data2 = [2] * vlen src = gr.vector_source_c( data, True, vlen ) v2s = gr.vector_to_stream(gr.sizeof_gr_complex,vlen) #interp = gr.fractional_interpolator_cc(0.0,soff) interp = moms(1000000,1000000+soff) fad_chan = gr.fir_filter_ccc(1,taps) freq_shift = gr.multiply_cc() norm_freq = freqoff / vlen freq_off_src = gr.sig_source_c(1.0, gr.GR_SIN_WAVE, norm_freq, 1.0, 0.0 ) snr = 10.0**(snr_db/10.0) noise_sigma = sqrt( rms_amplitude**2 / snr) awgn_chan = gr.add_cc() awgn_noise_src = ofdm.complex_white_noise( 0.0, noise_sigma ) dst = gr.null_sink( gr.sizeof_gr_complex ) limit = gr.head( gr.sizeof_gr_complex * vlen, N ) self.tb.connect( src, limit, v2s, interp, fad_chan,freq_shift, awgn_chan, dst ) self.tb.connect( freq_off_src,(freq_shift,1)) self.tb.connect( awgn_noise_src,(awgn_chan,1)) r = time_it( self.tb ) print "Rate: %s Samples/second" \ % eng_notation.num_to_str( float(N) * vlen / r )
def __init__(self, ampl_i, band, symbol_rate, sps): gr.hier_block2.__init__(self, "Channel", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(1, 1, gr.sizeof_gr_complex)) self.symbol_rate = symbol_rate self.sample_rate = symbol_rate * sps self.fading = False self.adder = gr.add_cc() self.noise = gr.noise_source_c(gr.GR_GAUSSIAN, 1, -42) self.ampl = gr.multiply_const_cc(ampl_i) self.taps = gr.firdes.low_pass_2(1, 280, band / 2, 5, 80, gr.firdes.WIN_KAISER) self.filter = gr.fir_filter_ccf(1, self.taps) #Connects self.connect(self, self.filter, (self.adder, 0)) self.connect(self.noise, self.ampl, (self.adder, 1)) self.connect(self.adder, self)
def test_100(self): vlen = 256 N = int(5e5) soff = 40 taps = [1.0, 0.0, 2e-1 + 0.1j, 1e-4 - 0.04j] freqoff = 0.0 snr_db = 10 rms_amplitude = 8000 data = [1 + 1j] * vlen #data2 = [2] * vlen src = gr.vector_source_c(data, True, vlen) v2s = gr.vector_to_stream(gr.sizeof_gr_complex, vlen) #interp = gr.fractional_interpolator_cc(0.0,soff) interp = moms(1000000, 1000000 + soff) fad_chan = gr.fir_filter_ccc(1, taps) freq_shift = gr.multiply_cc() norm_freq = freqoff / vlen freq_off_src = gr.sig_source_c(1.0, gr.GR_SIN_WAVE, norm_freq, 1.0, 0.0) snr = 10.0**(snr_db / 10.0) noise_sigma = sqrt(rms_amplitude**2 / snr) awgn_chan = gr.add_cc() awgn_noise_src = ofdm.complex_white_noise(0.0, noise_sigma) dst = gr.null_sink(gr.sizeof_gr_complex) limit = gr.head(gr.sizeof_gr_complex * vlen, N) self.tb.connect(src, limit, v2s, interp, fad_chan, freq_shift, awgn_chan, dst) self.tb.connect(freq_off_src, (freq_shift, 1)) self.tb.connect(awgn_noise_src, (awgn_chan, 1)) r = time_it(self.tb) print "Rate: %s Samples/second" \ % eng_notation.num_to_str( float(N) * vlen / r )
def __init__(self, frame, panel, vbox, argv): stdgui2.std_top_block.__init__(self, frame, panel, vbox, argv) self.frame = frame self.panel = panel parser = OptionParser(usage="%prog: [options]") parser.add_option("-N", "--dpsslength", type="int", help="Length of the DPSS", default="512") parser.add_option("-B", "--timebandwidthproduct", type="float", help="Time Bandwidthproduct used to calculate the DPSS", default="3") parser.add_option("-K", "--tapers", type="int", help="Number of Tapers used to calculate the Spectrum", default="5") parser.add_option("-W", "--weighting", type="choice", choices=("unity", "eigenvalues" ,"adaptive" ), help="weighting-type to be used (unity, eigenvalues, adaptive) ", default="adaptive") (options, args) = parser.parse_args () self.options = options #setting up our signal self.samplingrate = 48000 self.source = gr.sig_source_c(self.samplingrate, gr.GR_SIN_WAVE, 3000, 1) self.noise = gr.noise_source_c(gr.GR_GAUSSIAN,0.5) self.add = gr.add_cc() self.throttle = gr.throttle(gr.sizeof_gr_complex, self.samplingrate) #the actual spectrum estimator self.v2s = gr.vector_to_stream(gr.sizeof_float, self.options.dpsslength) self.mtm = specest.mtm(N = self.options.dpsslength, NW = self.options.timebandwidthproduct, K = self.options.tapers, weighting = self.options.weighting) self.scope = specest.spec_sink_f(panel, title='Spectrum with %s weighting, Length %i and %i Tapers' % ( self.options.weighting, self.options.dpsslength, self.options.tapers ), spec_size=self.options.dpsslength, sample_rate=self.samplingrate, ref_level=80, avg_alpha=0.8, y_per_div=20) self.connect(self.source, (self.add, 0) ) self.connect(self.noise, (self.add, 1) ) self.connect(self.add, self.throttle, self.mtm) self.connect(self.mtm, self.v2s, self.scope) self._build_gui(vbox)
def __init__(self, sample_rate): gr.hier_block2.__init__(self, "example_signal_1", gr.io_signature(0, 0, 0), # Input signature gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature src0 = gr.sig_source_c (sample_rate, # sample rate gr.GR_SIN_WAVE, # waveform type 350, # frequency 1.0, # amplitude 0) # DC Offset src1 = gr.sig_source_c (sample_rate, # sample rate gr.GR_SIN_WAVE, # waveform type 440, # frequency 1.0, # amplitude 0) # DC Offset sum = gr.add_cc() self.connect(src0, (sum, 0)) self.connect(src1, (sum, 1)) self.connect(sum, self)
def __init__(self): gr.top_block.__init__(self) # Make a local QtApp so we can start it from our side self.qapp = QtGui.QApplication(sys.argv) fftsize = 2048 self.src = gr.sig_source_c(1, gr.GR_SIN_WAVE, 0.1, 1) self.nse = gr.noise_source_c(gr.GR_GAUSSIAN, 0.0) self.add = gr.add_cc() self.thr = gr.throttle(gr.sizeof_gr_complex, 100 * fftsize) self.snk = qtgui.sink_c(fftsize, gr.firdes.WIN_BLACKMAN_hARRIS) self.connect(self.src, (self.add, 0)) self.connect(self.nse, (self.add, 1)) self.connect(self.add, self.thr, self.snk) # Tell the sink we want it displayed self.pyobj = sip.wrapinstance(self.snk.pyqwidget(), QtGui.QWidget) self.pyobj.show()
def __init__(self, noise_voltage, frequency_offset): gr.hier_block2.__init__(self, "awgn_channel", gr.io_signature(1, 1, gr.sizeof_gr_complex), gr.io_signature(1, 1, gr.sizeof_gr_complex)) self.noise_adder = gr.add_cc() self.noise = gr.noise_source_c(gr.GR_GAUSSIAN, noise_voltage) self.offset = gr.sig_source_c(1, gr.GR_SIN_WAVE, frequency_offset, 1.0, 0.0) self.mixer_offset = gr.multiply_cc() self.connect(self, (self.mixer_offset, 0)) self.connect(self.offset, (self.mixer_offset, 1)) self.connect(self.mixer_offset, (self.noise_adder, 1)) self.connect(self.noise, (self.noise_adder, 0)) self.connect(self.noise_adder, self) try: gr.hier_block.update_var_names(self, "awgn_channel", vars()) gr.hier_block.update_var_names(self, "awgn_channel", vars(self)) except: pass
def __init__(self): gr.top_block.__init__(self) Rs = 8000 f1 = 1000 f2 = 2000 fftsize = 2048 self.qapp = QtGui.QApplication(sys.argv) src1 = gr.sig_source_c(Rs, gr.GR_SIN_WAVE, f1, 0.1, 0) src2 = gr.sig_source_c(Rs, gr.GR_SIN_WAVE, f2, 0.1, 0) src = gr.add_cc() channel = gr.channel_model(0.001) thr = gr.throttle(gr.sizeof_gr_complex, 100 * fftsize) self.snk1 = qtgui.sink_c(fftsize, gr.firdes.WIN_BLACKMAN_hARRIS, 0, Rs, "Complex Signal Example", True, True, False, True, False) self.connect(src1, (src, 0)) self.connect(src2, (src, 1)) self.connect(src, channel, thr, self.snk1) self.ctrl_win = control_box() self.ctrl_win.attach_signal1(src1) self.ctrl_win.attach_signal2(src2) # Get the reference pointer to the SpectrumDisplayForm QWidget pyQt = self.snk1.pyqwidget() # Wrap the pointer as a PyQt SIP object # This can now be manipulated as a PyQt4.QtGui.QWidget self.pyWin = sip.wrapinstance(pyQt, QtGui.QWidget) self.main_box = dialog_box(self.pyWin, self.ctrl_win) self.main_box.show()
def __init__(self, N, fs, fd, ca_shift, snr=0): gr.hier_block2.__init__(self, "simulated_source", gr.io_signature(0, 0, 0), gr.io_signature(1, 1, gr.sizeof_gr_complex)) code = ca_code(svn=1, fs=fs, ca_shift=ca_shift) code = ravel(array([code for _ in range(N)])) n = arange(len(code)) f = e**(2j * pi * fd * n / fs) x = (code * f) # Add noise. signal_power = sum(sqrt(abs(x))) / len(x) noise_voltage = sqrt(signal_power / 10**(snr / 10.0)) src = gr.vector_source_c(x) noise = gr.noise_source_c(gr.GR_UNIFORM, noise_voltage) add = gr.add_cc() self.connect(src, (add, 0)) self.connect(noise, (add, 1)) self.connect(add, self)