def setup_bpsk0(self): self.tb = gr.top_block() # Build the constellation object arity = 2 bps = 1 pts, code = digital.psk_2_0x0() constellation = digital.constellation_psk(pts, code, 2) # Create BPSK data to pass to the demodulator src = blocks.vector_source_b(self.src_data_bpsk) p2u = blocks.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST) mod = digital.generic_mod(constellation, True, self.sps, True, self.eb) snk = blocks.vector_sink_c() tb = gr.top_block() tb.connect(src, p2u, mod, snk) tb.run() self.src = blocks.vector_source_c(snk.data()) self.freq_recov = digital.fll_band_edge_cc(self.sps, self.eb, self.fll_ntaps, self.freq_bw) self.time_recov = digital.pfb_clock_sync_ccf(self.sps, self.timing_bw, self.taps, self.nfilts, self.nfilts//2, self.timing_max_dev) self.receiver = digital.constellation_receiver_cb( constellation.base(), self.phase_bw, self.fmin, self.fmax) self.diffdec = digital.diff_decoder_bb(arity) self.symbol_mapper = digital.map_bb( mod_codes.invert_code(constellation.pre_diff_code())) self.unpack = blocks.unpack_k_bits_bb(bps) self.snk = blocks.null_sink(gr.sizeof_char) self.tb.connect(self.src, self.freq_recov, self.time_recov, self.receiver) self.tb.connect(self.receiver, self.diffdec, self.symbol_mapper, self.unpack) self.tb.connect(self.unpack, self.snk)
def setup_test05(self): print "... benchmarking 8-PSK demapper" self.nobits = 4 self.data_subcarriers = 200 self.blks = self.N*(10 + 1) self.tb = gr.top_block() #self.bitmap = [self.nobits]*self.data_subcarriers self.demodulator = generic_demapper_vcb(self.data_subcarriers,10) const = self.demodulator.get_constellation( self.nobits ) assert( len( const ) == 2**self.nobits ) self.bitdata = [random()+1j*random() for i in range(self.blks*self.data_subcarriers)] self.src = blocks.vector_source_c(self.bitdata,False, self.data_subcarriers) #self.src = symbol_random_src( const, self.data_subcarriers ) self.bitmap = [0]*self.data_subcarriers + [self.nobits]*self.data_subcarriers self.bitmap_src = blocks.vector_source_b(self.bitmap,True, self.data_subcarriers) #self.bmaptrig_stream = [1, 2]+[0]*(11-2) #self.bitmap_trigger = blocks.vector_source_b(self.bmaptrig_stream, True) self.snk = blocks.null_sink(gr.sizeof_char) self.tb.connect(self.src,self.demodulator,self.snk) self.tb.connect(self.bitmap_src,(self.demodulator,1))
def xtest_005_interp_random_vals(self): MAX_TAPS = 9 MAX_INTERP = 7 INPUT_LEN = 9 random.seed(0) # we want reproducibility for ntaps in xrange(1, MAX_TAPS + 1): for interp in xrange(1, MAX_INTERP+1): for ilen in xrange(ntaps, ntaps + INPUT_LEN): src_data = random_floats(ilen) taps = random_floats(ntaps) expected_result = reference_interp_filter(src_data, interp, taps) tb = gr.top_block() src = gr.vector_source_f(src_data) op = gr.rational_resampler_base_fff(interp, 1, taps) dst = gr.vector_sink_f() tb.connect(src, op, dst) tb.run() tb = None result_data = dst.data() L1 = len(result_data) L2 = len(expected_result) L = min(L1, L2) #if True or abs(L1-L2) > 1: if False: sys.stderr.write('delta = %2d: ntaps = %d interp = %d ilen = %d\n' % (L2 - L1, ntaps, interp, ilen)) #sys.stderr.write(' len(result_data) = %d len(expected_result) = %d\n' % # (len(result_data), len(expected_result))) #self.assertEqual(expected_result[0:L], result_data[0:L]) # FIXME check first ntaps+1 answers self.assertEqual(expected_result[ntaps+1:L], result_data[ntaps+1:L])
def main(): sys.path.append(os.getcwd()) from PHY import PhysicalLayer samples_per_symbol = 4 samp_rate = 4e6 tb = gr.top_block() modulator = blks2.gmsk_mod(samples_per_symbol=samples_per_symbol) demodulator = blks2.gmsk_demod(samples_per_symbol=samples_per_symbol) sys.stderr.write('Using bitrate %sbits/s\n' % eng_notation.num_to_str(samp_rate / samples_per_symbol / modulator.bits_per_symbol())) sys.stderr.flush() phy = PhysicalLayer.PhysicalLayer(modulator, demodulator, hint = 'addr=192.168.10.2', access_code = 'master') tb.connect(phy) phy.tune(1.8e9) phy.set_gain(45) phy.set_samp_rate(samp_rate) args = shlex.split('cvlc --sout "#transcode{vcodec=theora, vb=128}:std{access=file, mux=ogg, dst=-}" v4l2:///dev/video0') child = subprocess.Popen(args, stdout = subprocess.PIPE, stdin = subprocess.PIPE, stderr=None) print 'Started vlc with pid', child.pid def read_data_from_child(): print "[DEBUG] reading from child's pipe" phy.send_pkt(child.stdout.read(512)) return True tb.start() gobject.threads_init() gobject.idle_add(read_data_from_child) loop = gobject.MainLoop() loop.run()
def test_006_interp_decim(self): taps = (0,1,0,0) src_data = range(10000) interp = 3 decimation = 2 expected_result = reference_interp_dec_filter(src_data, interp, decimation, taps) tb = gr.top_block() src = gr.vector_source_f(src_data) op = gr.rational_resampler_base_fff(interp, decimation, taps) dst = gr.vector_sink_f() tb.connect(src, op) tb.connect(op, dst) tb.run() result_data = dst.data() L1 = len(result_data) L2 = len(expected_result) L = min(L1, L2) if False: sys.stderr.write('delta = %2d: ntaps = %d decim = %d ilen = %d\n' % (L2 - L1, len(taps), decimation, len(src_data))) sys.stderr.write(' len(result_data) = %d len(expected_result) = %d\n' % (len(result_data), len(expected_result))) self.assertEqual(expected_result[1:L], result_data[1:L])
def test_002_interp(self): taps = random_floats(31) #src_data = random_floats(10000) # FIXME the 10k case fails! src_data = random_floats(1000) interpolation = 3 expected_result = reference_interp_filter(src_data, interpolation, taps) tb = gr.top_block() src = gr.vector_source_f(src_data) op = gr.rational_resampler_base_fff(interpolation, 1, taps) dst = gr.vector_sink_f() tb.connect(src, op) tb.connect(op, dst) tb.run() result_data = dst.data() L1 = len(result_data) L2 = len(expected_result) L = min(L1, L2) if False: sys.stderr.write('delta = %2d: ntaps = %d interp = %d ilen = %d\n' % (L2 - L1, len(taps), interpolation, len(src_data))) sys.stderr.write(' len(result_data) = %d len(expected_result) = %d\n' % (len(result_data), len(expected_result))) #self.assertEqual(expected_result[0:L], result_data[0:L]) # FIXME check first 3 answers self.assertEqual(expected_result[3:L], result_data[3:L])
def xtest_004_decim_random_vals(self): MAX_TAPS = 9 MAX_DECIM = 7 OUTPUT_LEN = 9 random.seed(0) # we want reproducibility for ntaps in xrange(1, MAX_TAPS + 1): for decim in xrange(1, MAX_DECIM+1): for ilen in xrange(ntaps + decim, ntaps + OUTPUT_LEN*decim): src_data = random_floats(ilen) taps = random_floats(ntaps) expected_result = reference_dec_filter(src_data, decim, taps) tb = gr.top_block() src = gr.vector_source_f(src_data) op = gr.rational_resampler_base_fff(1, decim, taps) dst = gr.vector_sink_f() tb.connect(src, op, dst) tb.run() tb = None result_data = dst.data() L1 = len(result_data) L2 = len(expected_result) L = min(L1, L2) if False: sys.stderr.write('delta = %2d: ntaps = %d decim = %d ilen = %d\n' % (L2 - L1, ntaps, decim, ilen)) sys.stderr.write(' len(result_data) = %d len(expected_result) = %d\n' % (len(result_data), len(expected_result))) self.assertEqual(expected_result[0:L], result_data[0:L])
def setUp (self): self.tb = gr.top_block() self.tmpfile = tempfile.NamedTemporaryFile() self.prevfd = os.dup(sys.stdout.fileno()) os.dup2(self.tmpfile.fileno(), sys.stdout.fileno()) self.prev = sys.stdout sys.stdout = os.fdopen(self.prevfd, "w")
def setUp(self): self.tb = gr.top_block() random.seed(0) # make repeatable N = 10000 self._noise = [get_n_cplx() for i in xrange(N)] self._bits = [get_cplx() for i in xrange(N)]
def build_graph(): sample_rate = 8000 scale_factor = 32000 tb = gr.top_block() src = audio.source(sample_rate, "plughw:0,0") src_scale = blocks.multiply_const_ff(scale_factor) interp = filter.rational_resampler_fff(8, 1) f2s = blocks.float_to_short() enc = vocoder.cvsd_encode_sb() dec = vocoder.cvsd_decode_bs() s2f = blocks.short_to_float() decim = filter.rational_resampler_fff(1, 8) sink_scale = blocks.multiply_const_ff(1.0/scale_factor) sink = audio.sink(sample_rate, "plughw:0,0") tb.connect(src, src_scale, interp, f2s, enc) tb.connect(enc, dec, s2f, decim, sink_scale, sink) if 0: # debug tb.conect(src, blocks.file_sink(gr.sizeof_float, "source.dat")) tb.conect(src_scale, blocks.file_sink(gr.sizeof_float, "src_scale.dat")) tb.conect(interp, blocks.file_sink(gr.sizeof_float, "interp.dat")) tb.conect(f2s, blocks.file_sink(gr.sizeof_short, "f2s.dat")) tb.conect(enc, blocks.file_sink(gr.sizeof_char, "enc.dat")) tb.conect(dec, blocks.file_sink(gr.sizeof_short, "dec.dat")) tb.conect(s2f, blocks.file_sink(gr.sizeof_float, "s2f.dat")) tb.conect(decim, blocks.file_sink(gr.sizeof_float, "decim.dat")) tb.conect(sink_scale, blocks.file_sink(gr.sizeof_float, "sink_scale.dat")) return tb
def derandomizer_pp_desync(self, offset): """ Tests the ability of the derandomiser to synchronise when the inverted SYNC is <offset> packets away Note: This method itself is not a unit test method. """ assert offset < 8 useful_data = make_transport_stream() src = gr.vector_source_b(useful_data) pad = dvb_swig.pad_mpeg_ts_packet_bp() randomizer = dvb_swig.randomizer_pp() depad = dvb_swig.depad_mpeg_ts_packet_pb() dst = gr.vector_sink_b() self.tb.connect(src, pad, randomizer, depad, dst) self.tb.run() randomized_data = dst.data() src_data = make_fake_transport_stream_packet(offset) src_data.extend(randomized_data) self.tb = gr.top_block() src = gr.vector_source_b(src_data) pad = dvb_swig.pad_mpeg_ts_packet_bp() derandomizer = dvb_swig.derandomizer_pp() depad = dvb_swig.depad_mpeg_ts_packet_pb() dst = gr.vector_sink_b() self.tb.connect(src, pad, derandomizer, depad, dst) self.tb.run() result_data = dst.data() self.assertEqual(tuple(useful_data), result_data[-len(useful_data):])
def vars_receive(self): if self.waterfall or self.FFTIN or self.FFTOUT: t = grc_wxgui.top_block_gui(title="OrcaTUN") _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png" t.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY)) else: t = gr.top_block() ################################################## # Variables ################################################## t.transistion = self.transistion t.sps = self.sps t.sideband_rx = self.sideband_rx #t.sideband = self.sideband t.samp_rate = self.samp_rate #t.payload = self.payload #t.interpolation = self.interpolation #t._crcpolynom_config = self._crcpolynom_config #t.crcpolynom = self.crcpolynom #t.crcpolynom = self.crcpolynom t.carrier_b = self.carrier_b #t.carrier_a = self.carrier_a #t._accesscode_config = self._accesscode_config #t.accesscode = self.accesscode return t
def setUp (self): print "setUp" self.tb = gr.top_block () self.src = gr.vector_source_c([0]*240,False,240) self.demapper = lte_swig.layer_demapper_vcvc(0, "tx_diversity") self.snk = gr.vector_sink_c(240) self.tb.connect(self.src, self.demapper, self.snk)
def test_024_disconnect_single(self): hblock = gr.top_block("test_block") blk = gr.hier_block2("block", gr.io_signature(0, 0, 0), gr.io_signature(0, 0, 0)) hblock.connect(blk) hblock.disconnect(blk)
def test_025_disconnect_single_not_connected(self): hblock = gr.top_block("test_block") blk = gr.hier_block2("block", gr.io_signature(0, 0, 0), gr.io_signature(0, 0, 0)) self.assertRaises(RuntimeError, lambda: hblock.disconnect(blk))
def setUp (self): #print os.getpid() #raw_input("press the any key") self.tb = gr.top_block () offset = 43223 #sample15 = 21839 #sample20 = 43223 fftl = 512 cpl = 144*fftl/2048 cpl0 = 160*fftl/2048 slotl = 7*fftl+6*cpl+cpl0 cell_id = 124 N_rb_dl = 6 mod=scipy.io.loadmat('/home/demel/exchange/matlab_test_first_freq.mat') mat_u1=tuple(mod['test'].flatten()) mat_d=range(len(mat_u1)) for idx, val in enumerate(mat_u1): mat_d[idx]=val intu=tuple(mat_d[0:slotl*60]) self.src = gr.vector_source_c(intu,False,1) self.tag = lte.tag_symbol_cc(offset,fftl) #self.head = gr.head(gr.sizeof_gr_complex,70000) self.sel = lte.sss_selector_cvc(fftl) self.vtos = gr.vector_to_stream(gr.sizeof_gr_complex,512) self.snk = gr.vector_sink_c(1) self.tb.connect(self.src,self.tag,self.sel,self.vtos,self.snk)#,self.head
def test_022_connect_single_with_ports(self): hblock = gr.top_block("test_block") blk = gr.hier_block2("block", gr.io_signature(1, 1, 1), gr.io_signature(1, 1, 1)) self.assertRaises(RuntimeError, lambda: hblock.connect(blk))
def setUp (self): print "qa_remove_cp2_cvc SetUp!" self.fftl = fftl = 2048 cpl = 144*fftl/2048 cpl0 = 160*fftl/2048 self.slotl = slotl = 7*fftl+6*cpl+cpl0 self.tb = gr.top_block () #provide test data self.src = gr.noise_source_c(gr.GR_GAUSSIAN,1) self.head = gr.head( gr.sizeof_gr_complex, 10*slotl ) self.tag = lte.pss_tagging_cc(fftl) # set up tagging block self.tag.set_half_frame_start(0) self.tag.set_N_id_2(1) self.tag.lock() # UUT self.rcp = lte.remove_cp2_cvc(fftl) # sinks self.snk = gr.vector_sink_c(fftl) self.tagsnc = gr.tag_debug(gr.sizeof_gr_complex*fftl, "remove_cp2_cvc") # connect blocks self.tb.connect(self.src, self.head, self.tag, self.rcp, self.snk )
def setUp (self): self.tb = gr.top_block () fftl = 512 waveform = gr.GR_SIN_WAVE freq = 0.0 ampl = 1.0 offset = 0.0 cpl = 144 * fftl / 2048 cpl0 = 160 * fftl / 2048 slotl = 7 * fftl + 6 * cpl + cpl0 samp_rate = slotl / 0.0005 self.sig = gr.sig_source_c(samp_rate,waveform,freq,ampl,offset) self.head = gr.head(gr.sizeof_gr_complex, 100000) print "amplitude\t" + str(self.sig.amplitude()) print "frequency\t" + str(self.sig.frequency()) print "name\t" + str(self.sig.name()) print "offset\t" + str(self.sig.offset()) print "samp_rate\t" + str(self.sig.sampling_freq()) print "waveform\t" + str(self.sig.waveform()) #print type(self.sig) self.est = lte_swig.freq_estimate_c(self.sig,fftl) self.tb.connect(self.sig,self.head,self.est)
def test_004_es_source_pdus(self): print "test_004_es_source_pdus" msg = pmt.cons( pmt.to_pmt( {"somekey":"val2", "somekey2":"someval2" } ), pmt.to_pmt( numpy.array( [0,1,2,3,4,5,6,7,8,9] , dtype=numpy.float32) ) ); src = es.source([gr.sizeof_float], 8, 2); stb = blocks.message_strobe( msg, 100.0 ); tb = gr.top_block(); tb.msg_connect(stb, "strobe", src, "schedule_event"); th = blocks.throttle(gr.sizeof_float, 1000*100); hd = blocks.head(gr.sizeof_float, 1000*100); snk = blocks.vector_sink_f(); tb.connect(src,th,hd,snk); # TODO: this can not use run because it is # subject to GNU Radio's shutdown msg block bug # for remaining upstream msg blocks ... #tb.run(); # workaround tb.start(); time.sleep(1); tb.stop(); tb.wait(); self.assertEqual( sum(snk.data())>0, True );
def setUp (self): self.tb = gr.top_block () self.c = phy(slow_rate=True) self.dqcsk_mapper = ieee802_15_4.dqcsk_mapper_fc(self.c.chirp_seq, self.c.time_gap_1, self.c.time_gap_2, c.n_sub, self.c.n_subchirps) self.dqcsk_demapper = ieee802_15_4.dqcsk_demapper_cf(self.c.chirp_seq, self.c.time_gap_1, self.c.time_gap_2, c.n_sub, self.c.n_subchirps) self.dqpsk_mapper = ieee802_15_4.dqpsk_mapper_ff(framelen=self.c.nsym_frame, forward=True) self.dqpsk_demapper = ieee802_15_4.dqpsk_mapper_ff(framelen=self.c.nsym_frame, forward=False) self.qpsk_mapper = ieee802_15_4.qpsk_mapper_if() self.qpsk_demapper = ieee802_15_4.qpsk_demapper_fi() self.preamble_sfd_prefixer_I = ieee802_15_4.preamble_sfd_prefixer_ii(self.c.preamble, self.c.SFD, self.c.nsym_frame) self.preamble_sfd_removal_I = blocks.keep_m_in_n(gr.sizeof_int, self.c.nsym_frame - len(self.c.preamble) - len(self.c.SFD), self.c.nsym_frame, len(self.c.preamble)+len(self.c.SFD)) self.preamble_sfd_prefixer_Q = ieee802_15_4.preamble_sfd_prefixer_ii(self.c.preamble, self.c.SFD, self.c.nsym_frame) self.preamble_sfd_removal_Q = blocks.keep_m_in_n(gr.sizeof_int, self.c.nsym_frame - len(self.c.preamble) - len(self.c.SFD), self.c.nsym_frame, len(self.c.preamble)+len(self.c.SFD)) self.interleaver_I = ieee802_15_4.interleaver_ii(self.c.intlv_seq, forward=True) self.interleaver_Q = ieee802_15_4.interleaver_ii(self.c.intlv_seq, forward=True) self.deinterleaver_I = ieee802_15_4.interleaver_ii(self.c.intlv_seq, forward=False) self.deinterleaver_Q = ieee802_15_4.interleaver_ii(self.c.intlv_seq, forward=False) self.codeword_mapper_I = ieee802_15_4.codeword_mapper_bi(self.c.bits_per_symbol, self.c.codewords) self.codeword_mapper_Q = ieee802_15_4.codeword_mapper_bi(self.c.bits_per_symbol, self.c.codewords) self.codeword_demapper_I = ieee802_15_4.codeword_demapper_ib(self.c.bits_per_symbol, self.c.codewords) self.codeword_demapper_Q = ieee802_15_4.codeword_demapper_ib(self.c.bits_per_symbol, self.c.codewords) self.demux = blocks.deinterleave(gr.sizeof_char*1,1) self.mux = blocks.interleave(gr.sizeof_char*1,1) self.zeropadding = ieee802_15_4.zeropadding_b(self.c.padded_zeros) self.zeropadding_removal = ieee802_15_4.zeropadding_removal_b(self.c.phy_packetsize_bytes*8+len(self.c.PHR), self.c.padded_zeros) self.phr_prefixer = ieee802_15_4.phr_prefixer(self.c.PHR) self.phr_removal = ieee802_15_4.phr_removal(self.c.PHR) self.fragmentation = ieee802_15_4.fragmentation(self.c.phy_packetsize_bytes)
def _update_sliced(self, filtered_symbols): self.slicer_view.data = filtered_symbols if filtered_symbols is None: self.sliced_view.data = None return omega = float(filtered_symbols.sampling_rate) / self.burst.symbol_rate mu = 0.5 data_source = filtered_symbols.samples numpy_source = NumpySource(data_source) clock_recovery = digital.clock_recovery_mm_ff(omega, self._gain_omega, mu, self._gain_mu, self._omega_relative_limit) numpy_sink = NumpySink(numpy.float32) top = gr.top_block() top.connect(numpy_source, clock_recovery) top.connect(clock_recovery, numpy_sink) top.run() symbol_data = numpy_sink.data numpy.max(symbol_data) # TODO: Adjust sampling rate bits = [] for i in xrange(len(symbol_data)): if symbol_data[i] >= 0: symbol_data[i] = 1 bits.append('1') else: symbol_data[i] = -1 bits.append('0') bits = ''.join(bits) #print(bits) self.sliced_view.data = TimeData(symbol_data, self.burst.symbol_rate)
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 setUp (self): self.tb = gr.top_block () self.tp = drm.transm_params(1, 3, False, 0, False, 1, 0, 1, 1, 0, False, 24000, "station label", "text message") vlen_msc = self.tp.msc().N_MUX() * self.tp.ofdm().M_TF() vlen_sdc = self.tp.sdc().N() vlen_fac = self.tp.fac().N() * self.tp.ofdm().M_TF() self.cell_mapping = drm.cell_mapping_vcvc(self.tp, (vlen_msc, vlen_sdc, vlen_fac))
def run_test (f,Kb,bitspersymbol,K,dimensionality,tot_constellation,N0,seed): tb = gr.top_block () # TX src = gr.lfsr_32k_source_s() src_head = gr.head (gr.sizeof_short,Kb/16) # packet size in shorts s2fsmi = gr.packed_to_unpacked_ss(bitspersymbol,gr.GR_MSB_FIRST) # unpack shorts to symbols compatible with the FSM input cardinality enc = trellis.encoder_ss(f,0) # initial state = 0 # essentially here we implement the combination of modulation and channel as a memoryless modulation (the memory induced by the channel is hidden in the FSM) mod = gr.chunks_to_symbols_sf(tot_constellation,dimensionality) # CHANNEL add = gr.add_ff() noise = gr.noise_source_f(gr.GR_GAUSSIAN,math.sqrt(N0/2),seed) # RX metrics = trellis.metrics_f(f.O(),dimensionality,tot_constellation,digital.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for Viterbi va = trellis.viterbi_s(f,K,0,-1) # Put -1 if the Initial/Final states are not set. fsmi2s = gr.unpacked_to_packed_ss(bitspersymbol,gr.GR_MSB_FIRST) # pack FSM input symbols to shorts dst = gr.check_lfsr_32k_s(); tb.connect (src,src_head,s2fsmi,enc,mod) tb.connect (mod,(add,0)) tb.connect (noise,(add,1)) tb.connect (add,metrics) tb.connect (metrics,va,fsmi2s,dst) tb.run() ntotal = dst.ntotal () nright = dst.nright () runlength = dst.runlength () #print ntotal,nright,runlength return (ntotal,ntotal-nright)
def xtest_fff_003(self): random.seed(0) for i in xrange(25): sys.stderr.write("\n>>> Loop = %d\n" % (i,)) src_len = 4096 src_data = make_random_float_tuple(src_len) ntaps = int(random.uniform(2, 1000)) taps = make_random_float_tuple(ntaps) expected_result = reference_filter_fff(1, taps, src_data) src = gr.vector_source_f(src_data) op = gr.fft_filter_fff(1, taps) dst = gr.vector_sink_f() tb = gr.top_block() tb.connect(src, op, dst) tb.run() result_data = dst.data() #print "src_len =", src_len, " ntaps =", ntaps try: self.assert_fft_float_ok2(expected_result, result_data, abs_eps=1.0) except: expected = open('expected', 'w') for x in expected_result: expected.write(`x` + '\n') actual = open('actual', 'w') for x in result_data: actual.write(`x` + '\n') raise
def setUp (self): self.tb = gr.top_block () self.tp = drm.transm_params(1, 3, False, 0, False, 1, 0, 1, 1, 0, False, 24000, "station label", "text message") self.src = drm.generate_sdc_b(self.tp) self.head = blocks.head(self.tp.sdc().L(), 1) self.snk = blocks.vector_sink_b(self.tp.sdc().L()) self.tb.connect(self.src, self.head, self.snk)
def _update_filtered(self, translated): if translated is not None and self._taps is not None: filtered = TimeData(numpy.complex64(scipy.signal.lfilter(self._taps, 1, translated.samples)), translated.sampling_rate) filtered_abs = filtered.abs data_source = filtered_abs.samples numpy_source = NumpySource(data_source) peak_detector = blocks.peak_detector_fb(1.0, 0.3, 10, 0.001) sample_and_hold = blocks.sample_and_hold_ff() multiply_const = blocks.multiply_const_vff((0.5, )) subtract = blocks.sub_ff(1) numpy_sink = NumpySink(numpy.float32) top = gr.top_block() top.connect((numpy_source, 0), (peak_detector, 0)) top.connect((numpy_source, 0), (sample_and_hold, 0)) top.connect((numpy_source, 0), (subtract, 0)) top.connect((peak_detector, 0), (sample_and_hold, 1)) top.connect((sample_and_hold, 0), (multiply_const, 0)) top.connect((multiply_const, 0), (subtract, 1)) top.connect((subtract, 0), (numpy_sink, 0)) top.run() filtered = TimeData(numpy_sink.data, translated.sampling_rate) self.filtered_view.data = filtered # abs_min = filtered.abs.min # abs_max = filtered.abs.max # abs_mid = (abs_min + abs_max) / 2.0 # self.burst.filtered = filtered.abs - abs_mid self.burst.filtered = filtered else: self.filtered_view.data = None self.burst.filtered = None
def test_disconnect(self): msgs = ("this", "test", "should", "pass") tb = gr.top_block() #put the source in a hier block hb_src = gr.hier_block2("hb src", gr.io_signature(0, 0, 0), gr.io_signature(1, 1, 1)) src = demo_msg_src(msgs) #put the sink in a hier block hb_sink = gr.hier_block2("hb sink", gr.io_signature(1, 1, 1), gr.io_signature(0, 0, 0)) sink = demo_msg_sink(len(msgs)) #connect hb_src.connect(src, hb_src) hb_sink.connect(hb_sink, sink) tb.connect(hb_src, hb_sink) #disconnect hb_src.disconnect(src, hb_src) hb_sink.disconnect(hb_sink, sink) tb.disconnect(hb_src, hb_sink) #reconnect hb_src.connect(src, hb_src) hb_sink.connect(hb_sink, sink) tb.connect(hb_src, hb_sink) tb.run() self.assertItemsEqual(sink.msgs(), msgs)
def test_003_es_sink (self): print "test_003_es_sink" iv = [0,1,2,3,4,5,6,7,8,9]; src = blocks.vector_source_f(iv, repeat=True); hd = blocks.head(gr.sizeof_float, 10000); snk = es.sink([gr.sizeof_float], 8); t = es.trigger_sample_timer(gr.sizeof_float, 10, 5, 10, 10); tb = gr.top_block(); pduh = es.es_make_handler_pdu(es.es_handler_print.TYPE_F32); msgdb = blocks.message_debug() tb.connect(src, hd, t, snk); tb.msg_connect( t, "which_stream", snk, "schedule_event" ) tb.msg_connect( t, "sample_timer_event", pduh, "handle_event" ) tb.msg_connect( pduh, "pdus_out", msgdb, "store" ) tb.run(); # expected output of each event in the periodic sequence sv = numpy.array( iv[5:] + iv[:5], dtype=numpy.float32 ); # verify each received message nm = msgdb.num_messages(); print "nm = %d"%(nm); for i in range(0, nm): m = msgdb.get_message(i); mp = pmt.to_python(pmt.cdr(m)); print mp; self.assertEqual( sv.all(), mp.all() );
def setUp(self): self.tb = gr.top_block() self.strobe = blocks.message_strobe(pmt.PMT_NIL, 25) self.ctr = pdu_utils.message_counter(pmt.intern("counter")) self.tb.msg_connect((self.strobe, 'strobe'), (self.ctr, 'msg'))
def setUp(self): self.tb = gr.top_block()
def setUp(self): self.tb = gr.top_block() self.dbg = blocks.message_debug()
from .. base.Param import Param as _Param from .. gui.Param import Param as _GUIParam import Constants import numpy from gnuradio import eng_notation import re from gnuradio import gr _check_id_matcher = re.compile('^[a-z|A-Z]\w*$') _show_id_matcher = re.compile('^(variable\w*|parameter|options|notebook)$') #blacklist certain ids, its not complete, but should help import __builtin__ ID_BLACKLIST = ['self', 'options', 'gr', 'blks2', 'wxgui', 'wx', 'math', 'forms', 'firdes'] + \ filter(lambda x: not x.startswith('_'), dir(gr.top_block())) + dir(__builtin__) #define types, native python + numpy VECTOR_TYPES = (tuple, list, set, numpy.ndarray) COMPLEX_TYPES = [complex, numpy.complex, numpy.complex64, numpy.complex128] REAL_TYPES = [float, numpy.float, numpy.float32, numpy.float64] INT_TYPES = [int, long, numpy.int, numpy.int8, numpy.int16, numpy.int32, numpy.uint64, numpy.uint, numpy.uint8, numpy.uint16, numpy.uint32, numpy.uint64] #cast to tuple for isinstance, concat subtypes COMPLEX_TYPES = tuple(COMPLEX_TYPES + REAL_TYPES + INT_TYPES) REAL_TYPES = tuple(REAL_TYPES + INT_TYPES) INT_TYPES = tuple(INT_TYPES) class Param(_Param, _GUIParam): def __init__(self, **kwargs): _Param.__init__(self, **kwargs)
def setUp(self): self.fg = gr.top_block("test_block")
def setUp(self): self.tb = gr.top_block() self.tsb_key = "tsb_key"
def run(self, starttime=None, endtime=None, duration=None, period=1): op = self.op # window in seconds that we allow for setup time so that we don't # issue a start command that's in the past when the flowgraph starts SETUP_TIME = 10 # print current time and NTP status if op.verbose and sys.platform.startswith('linux'): try: call(('timedatectl', 'status')) except OSError: # no timedatectl command, ignore pass # parse time arguments st = drf.util.parse_identifier_to_time(starttime) if st is not None: # find next suitable start time by cycle repeat period now = datetime.utcnow() now = now.replace(tzinfo=pytz.utc) soon = now + timedelta(seconds=SETUP_TIME) diff = max(soon - st, timedelta(0)).total_seconds() periods_until_next = (diff - 1) // period + 1 st = st + timedelta(seconds=periods_until_next * period) if op.verbose: ststr = st.strftime('%a %b %d %H:%M:%S %Y') stts = (st - drf.util.epoch).total_seconds() print('Start time: {0} ({1})'.format(ststr, stts)) et = drf.util.parse_identifier_to_time(endtime, ref_datetime=st) if et is not None: if op.verbose: etstr = et.strftime('%a %b %d %H:%M:%S %Y') etts = (et - drf.util.epoch).total_seconds() print('End time: {0} ({1})'.format(etstr, etts)) if ((et < (pytz.utc.localize(datetime.utcnow()) + timedelta(seconds=SETUP_TIME))) or (st is not None and et <= st)): raise ValueError('End time is before launch time!') if op.realtime: r = gr.enable_realtime_scheduling() if op.verbose: if r == gr.RT_OK: print('Realtime scheduling enabled') else: print('Note: failed to enable realtime scheduling') # wait for the start time if it is not past while (st is not None) and ((st - pytz.utc.localize(datetime.utcnow())) > timedelta(seconds=SETUP_TIME)): ttl = int( (st - pytz.utc.localize(datetime.utcnow())).total_seconds()) if (ttl % 10) == 0: print('Standby {0} s remaining...'.format(ttl)) sys.stdout.flush() time.sleep(1) # get UHD USRP source u = self._usrp_setup() # set device time tt = time.time() if op.sync: # wait until time 0.2 to 0.5 past full second, then latch # we have to trust NTP to be 0.2 s accurate while tt - math.floor(tt) < 0.2 or tt - math.floor(tt) > 0.3: time.sleep(0.01) tt = time.time() if op.verbose: print('Latching at ' + str(tt)) # waits for the next pps to happen # (at time math.ceil(tt)) # then sets the time for the subsequent pps # (at time math.ceil(tt) + 1.0) u.set_time_unknown_pps(uhd.time_spec(math.ceil(tt) + 1.0)) # wait for time registers to be in known state time.sleep(math.ceil(tt) - tt + 1.0) else: u.set_time_now(uhd.time_spec(tt), uhd.ALL_MBOARDS) # wait for time registers to be in known state time.sleep(1) # set launch time # (at least 1 second out so USRP start time can be set properly and # there is time to set up flowgraph) if st is not None: lt = st else: now = pytz.utc.localize(datetime.utcnow()) # launch on integer second by default for convenience (ceil + 1) lt = now.replace(microsecond=0) + timedelta(seconds=2) ltts = (lt - drf.util.epoch).total_seconds() # adjust launch time forward so it falls on an exact sample since epoch lt_samples = np.ceil(ltts * op.samplerate) ltts = lt_samples / op.samplerate lt = drf.util.sample_to_datetime(lt_samples, op.samplerate) if op.verbose: ltstr = lt.strftime('%a %b %d %H:%M:%S.%f %Y') print('Launch time: {0} ({1})'.format(ltstr, repr(ltts))) # command launch time ct_td = lt - drf.util.epoch ct_secs = ct_td.total_seconds() // 1.0 ct_frac = ct_td.microseconds / 1000000.0 u.set_start_time(uhd.time_spec(ct_secs) + uhd.time_spec(ct_frac)) # populate flowgraph one channel at a time fg = gr.top_block() for k in range(op.nchs): mult_k = op.amplitudes[k] * np.exp(1j * op.phases[k]) if op.waveform is not None: waveform_k = mult_k * op.waveform src_k = blocks.vector_source_c( waveform_k.tolist(), repeat=True, ) else: src_k = analog.sig_source_c( 0, analog.GR_CONST_WAVE, 0, 0, mult_k, ) fg.connect(src_k, (u, k)) # start the flowgraph once we are near the launch time # (start too soon and device buffers might not yet be flushed) # (start too late and device might not be able to start in time) while ((lt - pytz.utc.localize(datetime.utcnow())) > timedelta(seconds=1.2)): time.sleep(0.1) fg.start() # wait until end time or until flowgraph stops if et is None and duration is not None: et = lt + timedelta(seconds=duration) try: if et is None: fg.wait() else: # sleep until end time nears while (pytz.utc.localize(datetime.utcnow()) < et - timedelta(seconds=2)): time.sleep(1) else: # issue stream stop command at end time ct_td = et - drf.util.epoch ct_secs = ct_td.total_seconds() // 1.0 ct_frac = ct_td.microseconds / 1000000.0 u.set_command_time( (uhd.time_spec(ct_secs) + uhd.time_spec(ct_frac)), uhd.ALL_MBOARDS, ) stop_enum = uhd.stream_cmd.STREAM_MODE_STOP_CONTINUOUS u.issue_stream_cmd(uhd.stream_cmd(stop_enum)) u.clear_command_time(uhd.ALL_MBOARDS) # sleep until after end time time.sleep(2) except KeyboardInterrupt: # catch keyboard interrupt and simply exit pass fg.stop() # need to wait for the flowgraph to clean up, otherwise it won't exit fg.wait() print('done') sys.stdout.flush()
def setUp(self): self.tb = gr.top_block() self.src = blocks.vector_source_f([float(i) for i in xrange(10)]) self.head = blocks.head(gr.sizeof_float, int(1e6)) self.sink = debugme.buggy_cplusplus_sink() self.tb.connect(self.src, self.head, self.sink)
# # SPDX-License-Identifier: GPL-2.0-or-later # import re import builtins from .. import blocks from .. import Constants # Blacklist certain ids, its not complete, but should help ID_BLACKLIST = ['self', 'options', 'gr', 'math', 'firdes', 'default' ] + dir(builtins) try: from gnuradio import gr ID_BLACKLIST.extend(attr for attr in dir(gr.top_block()) if not attr.startswith('_')) except (ImportError, AttributeError): pass validators = {} def validates(*dtypes): def decorator(func): for dtype in dtypes: assert dtype in Constants.PARAM_TYPE_NAMES validators[dtype] = func return func return decorator
def processInput2tx(file_num, snr): freq = numpy.random.permutation([0, -2.5e6, 2.5e6]) snr_new = numpy.random.permutation([snr - 5, snr + 5]) source_A = blocks.vector_source_b( map(int, numpy.random.randint(0, 255, 1000000)), True) source_B = blocks.vector_source_b( map(int, numpy.random.randint(0, 255, 1000000)), True) #source_C = blocks.vector_source_b(map(int, numpy.random.randint(0, 255, 1000000)), True) #source_D = blocks.vector_source_b(map(int, numpy.random.randint(0, 255, 1000000)), True) #source_E = blocks.vector_source_b(map(int, numpy.random.randint(0, 255, 1000000)), True) throttle_A = blocks.throttle(gr.sizeof_char * 1, samp_rate_base, True) throttle_B = blocks.throttle(gr.sizeof_char * 1, samp_rate_base, True) constellation_modulator_A = digital.generic_mod( constellation=constellation_variable, differential=False, samples_per_symbol=sps, pre_diff_code=True, excess_bw=0.35, verbose=False, log=False, ) constellation_modulator_B = digital.generic_mod( constellation=constellation_variable, differential=False, samples_per_symbol=sps, pre_diff_code=True, excess_bw=0.35, verbose=False, log=False, ) sig_source_A = analog.sig_source_c( upsamp_rate, analog.GR_COS_WAVE, freq[1], (10**(float(snr_new[0]) / 20)) * noise_amplitude, 0) sig_source_B = analog.sig_source_c( upsamp_rate, analog.GR_COS_WAVE, freq[2], (10**(float(snr_new[1]) / 20)) * noise_amplitude, 0) const_A = analog.sig_source_f(0, analog.GR_CONST_WAVE, 0, 0, 0) resampler_A = filter.rational_resampler_ccc(10, 2, taps=None, fractional_bw=None) resampler_B = filter.rational_resampler_ccc(10, 2, taps=None, fractional_bw=None) multiply_A = blocks.multiply_vcc(1) multiply_A1 = blocks.multiply_vcc(1) multiply_B = blocks.multiply_vcc(1) float_to_complex_A = blocks.float_to_complex(1) delay_B = blocks.delay(gr.sizeof_gr_complex * 1, 500000) sqr_source_A = analog.sig_source_f(samp_rate_base, analog.GR_SQR_WAVE, -1, signal_amp, 0) channel_A = channels.fading_model(12, 0, False, 4.0, 0) channel_B = channels.fading_model(12, 0, False, 4.0, 0) add_block = blocks.add_vcc(1) channel = channels.channel_model(noise_voltage=noise_amplitude, frequency_offset=0.0, epsilon=1.0, taps=(1 + 1j, ), noise_seed=0, block_tags=False) skip_head = blocks.skiphead(gr.sizeof_gr_complex * 1, 1024) head_block = blocks.head(gr.sizeof_gr_complex * 1, 1000000) file_sink = blocks.file_sink( gr.sizeof_gr_complex * 1, 'data_2tx_' + str(snr) + 'dB_' + str(file_num) + '.dat', False) tb = gr.top_block() tb.connect(source_A, throttle_A, constellation_modulator_A, resampler_A, (multiply_A, 0)) tb.connect(sig_source_A, (multiply_A, 1)) tb.connect(multiply_A, (multiply_A1, 0)) tb.connect(sqr_source_A, (float_to_complex_A, 0)) tb.connect(const_A, (float_to_complex_A, 1)) tb.connect(float_to_complex_A, (multiply_A1, 1)) tb.connect(multiply_A1, channel_A, (add_block, 0)) tb.connect(source_B, throttle_B, constellation_modulator_B, resampler_B, (multiply_B, 0)) tb.connect(sig_source_B, (multiply_B, 1)) tb.connect(multiply_B, channel_B, delay_B, (add_block, 1)) tb.connect(add_block, channel, skip_head) tb.connect(skip_head, head_block) tb.connect(head_block, file_sink) tb.run()
def setUp (self): os.environ['GR_CONF_CONTROLPORT_ON'] = 'False' self.tb = gr.top_block ()
def setUp(self): self.tb = gr.top_block() self.src_data = [int(x) for x in range(65536)]
def main(): N = 10000 fs = 2000.0 Ts = 1.0 / fs t = numpy.arange(0, N*Ts, Ts) # When playing with the number of channels, be careful about the filter # specs and the channel map of the synthesizer set below. nchans = 10 # Build the filter(s) bw = 1000 tb = 400 proto_taps = filter.firdes.low_pass_2(1, nchans*fs, bw, tb, 80, filter.firdes.WIN_BLACKMAN_hARRIS) print("Filter length: ", len(proto_taps)) # Create a modulated signal npwr = 0.01 data = numpy.random.randint(0, 256, N) rrc_taps = filter.firdes.root_raised_cosine(1, 2, 1, 0.35, 41) src = blocks.vector_source_b(data.astype(numpy.uint8).tolist(), False) mod = digital.bpsk_mod(samples_per_symbol=2) chan = channels.channel_model(npwr) rrc = filter.fft_filter_ccc(1, rrc_taps) # Split it up into pieces channelizer = filter.pfb.channelizer_ccf(nchans, proto_taps, 2) # Put the pieces back together again syn_taps = [nchans*t for t in proto_taps] synthesizer = filter.pfb_synthesizer_ccf(nchans, syn_taps, True) src_snk = blocks.vector_sink_c() snk = blocks.vector_sink_c() # Remap the location of the channels # Can be done in synth or channelizer (watch out for rotattions in # the channelizer) synthesizer.set_channel_map([ 0, 1, 2, 3, 4, 15, 16, 17, 18, 19]) tb = gr.top_block() tb.connect(src, mod, chan, rrc, channelizer) tb.connect(rrc, src_snk) vsnk = [] for i in range(nchans): tb.connect((channelizer,i), (synthesizer, i)) vsnk.append(blocks.vector_sink_c()) tb.connect((channelizer,i), vsnk[i]) tb.connect(synthesizer, snk) tb.run() sin = numpy.array(src_snk.data()[1000:]) sout = numpy.array(snk.data()[1000:]) # Plot original signal fs_in = nchans*fs f1 = pyplot.figure(1, figsize=(16,12), facecolor='w') s11 = f1.add_subplot(2,2,1) s11.psd(sin, NFFT=fftlen, Fs=fs_in) s11.set_title("PSD of Original Signal") s11.set_ylim([-200, -20]) s12 = f1.add_subplot(2,2,2) s12.plot(sin.real[1000:1500], "o-b") s12.plot(sin.imag[1000:1500], "o-r") s12.set_title("Original Signal in Time") start = 1 skip = 2 s13 = f1.add_subplot(2,2,3) s13.plot(sin.real[start::skip], sin.imag[start::skip], "o") s13.set_title("Constellation") s13.set_xlim([-2, 2]) s13.set_ylim([-2, 2]) # Plot channels nrows = int(numpy.sqrt(nchans)) ncols = int(numpy.ceil(float(nchans) / float(nrows))) f2 = pyplot.figure(2, figsize=(16,12), facecolor='w') for n in range(nchans): s = f2.add_subplot(nrows, ncols, n+1) s.psd(vsnk[n].data(), NFFT=fftlen, Fs=fs_in) s.set_title("Channel {0}".format(n)) s.set_ylim([-200, -20]) # Plot reconstructed signal fs_out = 2*nchans*fs f3 = pyplot.figure(3, figsize=(16,12), facecolor='w') s31 = f3.add_subplot(2,2,1) s31.psd(sout, NFFT=fftlen, Fs=fs_out) s31.set_title("PSD of Reconstructed Signal") s31.set_ylim([-200, -20]) s32 = f3.add_subplot(2,2,2) s32.plot(sout.real[1000:1500], "o-b") s32.plot(sout.imag[1000:1500], "o-r") s32.set_title("Reconstructed Signal in Time") start = 0 skip = 4 s33 = f3.add_subplot(2,2,3) s33.plot(sout.real[start::skip], sout.imag[start::skip], "o") s33.set_title("Constellation") s33.set_xlim([-2, 2]) s33.set_ylim([-2, 2]) pyplot.show()
def __init__(self, spreadingFactor = 7, codingRate = "4/5", gains = [10, 20, 20]): ################################################## # Variables # ################################################## self.target_freq = 868.1e6 self.sf = spreadingFactor # 7 8 9 10 11 12 self.samp_rate = 1e6 self.capture_freq = 868.0e6 self.bw = 125e3 #self.symbols_per_sec = self.bw / (2**self.sf) self.offset = -(self.capture_freq - self.target_freq) #self.bitrate = self.sf * (1 / (2**self.sf / self.bw )) self.crc = True self.pwr = 1 self.codingRate = codingRate # 4/5 4/6 4/7 4/8 self.pre_delay = 0.150 self.post_delay = 0.350 self.trans_delay = 0.250 self.testResults = None # Socket connection for sink self.host = "127.0.0.1" self.port = 40868 self.server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.server.bind((self.host, self.port)) self.server.setblocking(0) ################################################## # LoRa transmitter # ################################################## try: self.lc = RN2483Controller("/dev/lora") self.lc.set_cr ( self.codingRate) self.lc.set_bw ( self.bw / 1e3) self.lc.set_sf ( self.sf ) self.lc.set_crc( "on" if self.crc else "off") self.lc.set_pwr( self.pwr ) except: raise Exception("Error initialising LoRa transmitter: RN2483Controller") ################################################## # Blocks # ################################################## self.tb = gr.top_block () self.osmosdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + '' ) self.osmosdr_source_0.set_sample_rate(self.samp_rate) self.osmosdr_source_0.set_center_freq(self.capture_freq, 0) self.osmosdr_source_0.set_freq_corr(0, 0) self.osmosdr_source_0.set_dc_offset_mode(0, 0) self.osmosdr_source_0.set_iq_balance_mode(0, 0) self.osmosdr_source_0.set_gain_mode(False, 0) self.osmosdr_source_0.set_gain(gains[0], 0) self.osmosdr_source_0.set_if_gain(gains[1], 0) self.osmosdr_source_0.set_bb_gain(gains[2], 0) self.osmosdr_source_0.set_antenna('', 0) self.osmosdr_source_0.set_bandwidth(0, 0) self.lora_lora_receiver_0 = lora.lora_receiver(self.samp_rate, self.capture_freq, self.offset, self.sf, self.samp_rate, 0.01) self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, self.samp_rate, True) self.blocks_message_socket_sink_0 = lora.message_socket_sink() self.tb.connect( (self.osmosdr_source_0, 0), (self.blocks_throttle_0, 0)) self.tb.connect( (self.blocks_throttle_0, 0), (self.lora_lora_receiver_0, 0)) self.tb.msg_connect( (self.lora_lora_receiver_0, 'frames'), (self.blocks_message_socket_sink_0, 'in'))
def run(self): op = self.op # window in seconds that we allow for setup time so that we don't # issue a start command that's in the past when the flowgraph starts SETUP_TIME = 10 # print current time and NTP status if op.verbose and sys.platform.startswith('linux'): try: call(('timedatectl', 'status')) except OSError: # no timedatectl command, ignore pass # get UHD USRP source usrp = self._usrp_setup() # set launch time # (at least 1 second out so USRP start time can be set properly and # there is time to set up flowgraph) ltts = usrp.get_time_last_pps().get_real_secs() + 2 usrp.set_start_time(uhd.time_spec(ltts)) # populate flowgraph one channel at a time fg = gr.top_block() for k in range(op.nchs): mult_k = op.amplitudes[k] * np.exp(1j * op.phases[k]) if op.waveform is not None: waveform_k = mult_k * op.waveform src_k = blocks.vector_source_c( waveform_k.tolist(), repeat=True, ) else: src_k = analog.sig_source_c( 0, analog.GR_CONST_WAVE, 0, 0, mult_k, ) fg.connect(src_k, (usrp, k)) # start the flowgraph once we are near the launch time # (start too soon and device buffers might not yet be flushed) # (start too late and device might not be able to start in time) while (ltts - usrp.get_mboard_sensor("gps_time").to_int()) > 1.2: time.sleep(0.1) fg.start() # Step the USRP through a list of frequencies basedir = '/'.join(op.freq_list_fname.split('/')[:-2]) flog_fname = os.path.join(basedir, 'logs/freqstep.log') lock_fname = os.path.join(basedir, 'logs/gps_lock.log') freq_stepper.step( usrp, op, freq_list_fname=op.freq_list_fname, flog_fname=flog_fname, lock_fname=lock_fname, ) # wait until flowgraph stops try: fg.wait() except KeyboardInterrupt: # catch keyboard interrupt and simply exit pass fg.stop() # need to wait for the flowgraph to clean up, otherwise it won't exit fg.wait() print('done') sys.stdout.flush()
def setUp(self): np.set_printoptions(2, linewidth=150) self.tb = gr.top_block()
def test_robustness_AWGN(): N = 10000#9000 zc_len = [29,201] n_repeats = [20,1] samples_per_frame = 2000 samples_of_awgn = 50 preamble_amp = np.random.uniform(0.5,100) SNRdBrange = range(-10,10) toffset = 200 Nruns = 100 sum_ratios = np.zeros(len(SNRdBrange)) sum_falarm = np.zeros(len(SNRdBrange)) cfo = 0#0.01 for ii, s in enumerate(SNRdBrange): for rr in range(Nruns): awgn_pwr = preamble_amp**2/(10**(s/10.0)) tb = gr.top_block() # derived preamble, pseq_list, pseq_norm_list = generate_preamble(zc_len,n_repeats) x = np.random.normal(0, np.sqrt(awgn_pwr)/np.sqrt(2), N)+np.random.normal(0, np.sqrt(awgn_pwr)/np.sqrt(2), N)*1j x = add_preambles(x,toffset,apply_cfo(preamble*preamble_amp, cfo),samples_per_frame) hist_len = 2*preamble.size + samples_of_awgn x_with_history = np.append(np.zeros(hist_len,dtype=np.complex128),x) toffset_with_hist = toffset+hist_len N_frames_tot = int(np.floor((N-toffset-preamble.size)/float(samples_per_frame))+1) vector_source = blocks.vector_source_c(x, True) head = blocks.head(gr.sizeof_gr_complex, len(x_with_history)) frame_sync = specmonitor.frame_sync_cc(pseq_list,n_repeats,0.15,samples_per_frame, samples_of_awgn, awgn_pwr) dst = blocks.vector_sink_c() tb.connect(vector_source,head) tb.connect(head,frame_sync) tb.connect(frame_sync,dst) print '\nTest: ' print '- toffset: ', toffset print '- preamble start:', toffset+hist_len print '- crosscorr peak0: ', toffset+hist_len+(n_repeats[0]-1)*zc_len[0] print '- preamble end: ', toffset+hist_len+n_repeats[0]*zc_len[0]+n_repeats[1]*zc_len[1] print '- number of preambles: ', N_frames_tot print '' tb.run () in_data = dst.data() h = frame_sync.history()-1 assert h == hist_len # raw_input ('Press Enter to continue: ') js_dict = json.loads(frame_sync.get_peaks_json()) print js_dict if len(js_dict)>=1: n_frames_detected = js_dict[0]['n_frames_detected'] print 'got:', js_dict[0]['peak_idx'], ', expected ', toffset+samples_per_frame*(N_frames_tot+1) if js_dict[0]['peak_idx']==(toffset+samples_per_frame*(N_frames_tot+1)): r = n_frames_detected / float(N_frames_tot+1) print 'r:', r sum_ratios[ii] = sum_ratios[ii] + r sum_falarm[ii] += len(js_dict)-1 rate_detection = sum_ratios / Nruns rate_falarm = sum_falarm / Nruns fig, (ax0, ax1) = plt.subplots(nrows=2) ax0.plot(SNRdBrange, rate_detection) ax1.plot(SNRdBrange, rate_falarm, ':') plt.show()
def main(args): nargs = len(args) if nargs == 1: infile = args[0] outfile = None elif nargs == 2: infile = args[0] outfile = args[1] else: sys.stderr.write("Usage: dvbt2-blade.py input_file [output_file]\n"); sys.exit(1) version = dvbt2.VERSION_111 fft_size = dvbt2.FFTSIZE_32K input_mode = dvbt2.INPUTMODE_NORMAL frame_size = dvbt2.FECFRAME_NORMAL code_rate = dvbt2.C3_4 data_symbols = 100 fec_blocks = 31 ti_blocks = 3 constellation = dvbt2.MOD_256QAM rotation = dvbt2.ROTATION_ON guard_interval = dvbt2.GI_19_128 mode = dvbt2.PREAMBLE_T2_SISO carrier_mode = dvbt2.CARRIERS_NORMAL pilot_pattern = dvbt2.PILOT_PP2 l1_constellation = dvbt2.L1_MOD_16QAM papr_mode = dvbt2.PAPR_OFF papr_vclip = 3.3 papr_iterations = 3 channel_mhz = 8 samp_rate = channel_mhz * 8000000.0 / 7 # center_freq = 429000000 center_freq = 666000000 # center_freq = 441000000 # txvga1_gain = -8 txvga1_gain = -8 txvga2_gain = 14 if channel_mhz == 10: bandwidth = 10000000 equalization_bandwidth = dvbt2.BANDWIDTH_10_0_MHZ elif channel_mhz == 8: bandwidth = 8750000 equalization_bandwidth = dvbt2.BANDWIDTH_8_0_MHZ elif channel_mhz == 7: bandwidth = 7000000 equalization_bandwidth = dvbt2.BANDWIDTH_7_0_MHZ elif channel_mhz == 6: bandwidth = 5500000 equalization_bandwidth = dvbt2.BANDWIDTH_6_0_MHZ elif channel_mhz == 5: bandwidth = 5000000 equalization_bandwidth = dvbt2.BANDWIDTH_5_0_MHZ else: bandwidth = 1750000 equalization_bandwidth = dvbt2.BANDWIDTH_1_7_MHZ if fft_size == dvbt2.FFTSIZE_1K: fftsize = 1024 elif fft_size == dvbt2.FFTSIZE_2K: fftsize = 2048 elif fft_size == dvbt2.FFTSIZE_4K: fftsize = 4096 elif fft_size == dvbt2.FFTSIZE_8K: fftsize = 8192 elif fft_size == dvbt2.FFTSIZE_8K_T2GI: fftsize = 8192 elif fft_size == dvbt2.FFTSIZE_16K: fftsize = 16384 elif fft_size == dvbt2.FFTSIZE_16K_T2GI: fftsize = 16384 elif fft_size == dvbt2.FFTSIZE_32K: fftsize = 32768 elif fft_size == dvbt2.FFTSIZE_32K_T2GI: fftsize = 32768 if guard_interval == dvbt2.GI_1_32: gi = fftsize / 32 elif guard_interval == dvbt2.GI_1_16: gi = fftsize / 16 elif guard_interval == dvbt2.GI_1_8: gi = fftsize / 8 elif guard_interval == dvbt2.GI_1_4: gi = fftsize / 4 elif guard_interval == dvbt2.GI_1_128: gi = fftsize / 128 elif guard_interval == dvbt2.GI_19_128: gi = (fftsize * 19) / 128 elif guard_interval == dvbt2.GI_19_256: gi = (fftsize * 19) / 256 tb = gr.top_block() src = blocks.file_source(gr.sizeof_char, infile, True) dvbt2_bbheader = dvbt2.bbheader_bb(frame_size, code_rate, input_mode, dvbt2.INBAND_OFF, fec_blocks, 4000000) dvbt2_bbscrambler = dvbt2.bbscrambler_bb(frame_size, code_rate) dvbt2_bch = dvbt2.bch_bb(frame_size, code_rate) dvbt2_ldpc = dvbt2.ldpc_bb(frame_size, code_rate) dvbt2_interleaver = dvbt2.interleaver_bb(frame_size, code_rate, constellation) dvbt2_modulator = dvbt2.modulator_bc(frame_size, constellation, rotation) dvbt2_cellinterleaver = dvbt2.cellinterleaver_cc(frame_size, constellation, fec_blocks, ti_blocks) dvbt2_framemapper = dvbt2.framemapper_cc(frame_size, code_rate, constellation, rotation, fec_blocks, ti_blocks, carrier_mode, fft_size, guard_interval, l1_constellation, pilot_pattern, 2, data_symbols, papr_mode, version, mode, input_mode, dvbt2.RESERVED_OFF, dvbt2.L1_SCRAMBLED_OFF, dvbt2.INBAND_OFF) dvbt2_freqinterleaver = dvbt2.freqinterleaver_cc(carrier_mode, fft_size, pilot_pattern, guard_interval, data_symbols, papr_mode, version, mode) dvbt2_pilotgenerator = dvbt2.pilotgenerator_cc(carrier_mode, fft_size, pilot_pattern, guard_interval, data_symbols, papr_mode, version, mode, dvbt2.MISO_TX1, dvbt2.EQUALIZATION_ON, equalization_bandwidth, fftsize) dvbt2_paprtr = dvbt2.paprtr_cc(carrier_mode, fft_size, pilot_pattern, guard_interval, data_symbols, papr_mode, version, papr_vclip, papr_iterations, fftsize) digital_ofdm_cyclic_prefixer = digital.ofdm_cyclic_prefixer(fftsize, fftsize+(gi), 0, "") dvbt2_p1insertion = dvbt2.p1insertion_cc(carrier_mode, fft_size, guard_interval, data_symbols, mode, dvbt2.SHOWLEVELS_OFF, 3.31) blocks_multiply_const = blocks.multiply_const_vcc((0.2, )) out = osmosdr.sink(args="bladerf=0,buffers=128,buflen=32768") out.set_sample_rate(samp_rate) out.set_center_freq(center_freq, 0) out.set_freq_corr(0, 0) out.set_gain(txvga2_gain, 0) out.set_bb_gain(txvga1_gain, 0) out.set_bandwidth(bandwidth, 0) tb.connect(src, dvbt2_bbheader) tb.connect(dvbt2_bbheader, dvbt2_bbscrambler) tb.connect(dvbt2_bbscrambler, dvbt2_bch) tb.connect(dvbt2_bch, dvbt2_ldpc) tb.connect(dvbt2_ldpc, dvbt2_interleaver) tb.connect(dvbt2_interleaver, dvbt2_modulator) tb.connect(dvbt2_modulator, dvbt2_cellinterleaver) tb.connect(dvbt2_cellinterleaver, dvbt2_framemapper) tb.connect(dvbt2_framemapper, dvbt2_freqinterleaver) tb.connect(dvbt2_freqinterleaver, dvbt2_pilotgenerator) tb.connect(dvbt2_pilotgenerator, dvbt2_paprtr) tb.connect(dvbt2_paprtr, digital_ofdm_cyclic_prefixer) tb.connect(digital_ofdm_cyclic_prefixer, dvbt2_p1insertion) tb.connect(dvbt2_p1insertion, blocks_multiply_const) tb.connect(blocks_multiply_const, out) if outfile: dst = blocks.file_sink(gr.sizeof_gr_complex, outfile) tb.connect(blocks_multiply_const, dst) tb.run()
def setUp(self): random.seed(0) self.tb = gr.top_block()
def test(): N = 9000#9000 zc_len = [5,13] toffset = 3500#8070 n_repeats = [40,1] samples_per_frame = 9000 samples_of_awgn = 50 preamble_amp = np.random.uniform(0.5,100) awgn_floor = 1e-3 for r in range(N-np.sum([n_repeats[i]*zc_len[i] for i in range(2)])): cfo = np.random.uniform(0,0.45)/zc_len[0] tb = gr.top_block() toffset = r # derived preamble, pseq_list, pseq_norm_list = generate_preamble(zc_len,n_repeats) x = np.ones(N,dtype=np.complex128)*awgn_floor x = add_preambles(x,toffset,apply_cfo(preamble*preamble_amp, cfo),samples_per_frame) hist_len = 2*preamble.size + samples_of_awgn x_with_history = np.append(np.zeros(hist_len,dtype=np.complex128),x) toffset_with_hist = toffset+hist_len N_frames_tot = int(np.ceil((N-toffset-preamble.size)/float(samples_per_frame))) vector_source = blocks.vector_source_c(x, True) head = blocks.head(gr.sizeof_gr_complex, len(x_with_history)) frame_sync = specmonitor.frame_sync_cc(pseq_list,n_repeats,0.5,samples_per_frame, samples_of_awgn, awgn_floor**2) dst = blocks.vector_sink_c() tb.connect(vector_source,head) tb.connect(head,frame_sync) tb.connect(frame_sync,dst) print '\nTest: ' print '- toffset: ', toffset print '- preamble start:', toffset+hist_len print '- crosscorr peak0: ', toffset+hist_len+(n_repeats[0]-1)*zc_len[0] print '- preamble end: ', toffset+hist_len+n_repeats[0]*zc_len[0]+n_repeats[1]*zc_len[1] print '- number of preambles: ', N_frames_tot print '' tb.run () in_data = dst.data() h = frame_sync.history()-1 if(h != hist_len): print 'The history length is not consistent. ', h, '!=', hist_len return error_num = [False]*6 js_dict0 = json.loads(frame_sync.get_crosscorr0_peaks()) js_dict = json.loads(frame_sync.get_peaks_json()) error_num[0] = False if len(js_dict0) == 1 else True error_num[1] = False if len(js_dict) == 1 else True if error_num[1] == False: error_num[2] = False if js_dict[0]['peak_idx']==(toffset+samples_per_frame*N_frames_tot) else True error_num[3] = False if js_dict[0]['n_frames_elapsed']==N_frames_tot else True error_num[4] = False if abs(js_dict[0]['awgn_estim']-awgn_floor**2)<0.001 else True error_num[5] = False if abs(js_dict[0]['cfo']-cfo)<0.001 else True if any(error_num): print 'There were errors', error_num xcorr = frame_sync.get_crosscorr0(1000) plt.plot(np.abs(xcorr)) plt.show() return
def setUp(self): self.tb = gr.top_block() self.emitter = pdu_utils.message_emitter() self.debug = blocks.message_debug()
def run(self, suites_to_run, pause=False, write_output=True): for test_suite in self.test_suites: # Skip test suites that we don't want to run if suites_to_run != [] and (not test_suite in suites_to_run): continue print("[+] Testing suite: '%s'" % test_suite) summary = TestSummary(suite=test_suite, pause=pause) # Get all metadata files associated with the suite get_mtime = lambda f: os.stat( os.path.join(self.test_suites_directory, test_suite, f) ).st_mtime metadata_files = [ os.path.join(self.test_suites_directory, test_suite, x) for x in sorted(os.listdir( os.path.join(self.test_suites_directory, test_suite)), key=get_mtime) if x.endswith('.sigmf-meta') ] # Parse metadata files for metadata_file in metadata_files: print("[+] %s" % metadata_file) data_file = os.path.splitext(metadata_file)[0] + '.sigmf-data' # Load sigmf data TODO abstract f = open(metadata_file, 'r') sigmf = SigMFFile(metadata=f.read()) if not sigmf.validate(): raise Exception("Invalid SigMF format") global_meta = sigmf.get_global_info() capture_meta = sigmf.get_capture_info(0) f.close() # Initialize test parameters sample_rate = global_meta["core:sample_rate"] # Get LoRa configuration capture_freq = capture_meta["core:frequency"] if "lora:frequency_offset" in capture_meta: frequency_offset = capture_meta["lora:frequency_offset"] else: frequency_offset = 0 transmit_freq = capture_meta["lora:frequency"] sf = capture_meta["lora:sf"] cr = capture_meta["lora:cr"] bw = int(capture_meta["lora:bw"]) prlen = capture_meta["lora:prlen"] crc = capture_meta["lora:crc"] implicit = capture_meta["lora:implicit"] lora_config = LoRaConfig(transmit_freq, sf, cr, bw, prlen, crc, implicit) # Get test case configuration payload = capture_meta["test:expected"] times = capture_meta["test:times"] test = Test(payload, times) # Build flowgraph tb = gr.top_block() file_source = blocks.file_source(gr.sizeof_gr_complex, data_file, False) lora_receiver = lora.lora_receiver(sample_rate, capture_freq, [868100000], bw, sf, False, 4, True, reduced_rate=False, decimation=1) throttle = blocks.throttle(gr.sizeof_gr_complex, sample_rate, True) message_socket_sink = lora.message_socket_sink( "127.0.0.1", 40868, 2) freq_xlating_fir_filter = filter.freq_xlating_fir_filter_ccc( 1, (firdes.low_pass(1, sample_rate, 200000, 100000, firdes.WIN_HAMMING, 6.67)), frequency_offset, sample_rate) # Make connections tb.connect((file_source, 0), (throttle, 0)) tb.connect((throttle, 0), (freq_xlating_fir_filter, 0)) tb.connect((freq_xlating_fir_filter, 0), (lora_receiver, 0)) tb.msg_connect((lora_receiver, 'frames'), (message_socket_sink, 'in')) tb.start() tb.wait() decoded_data = self.server.get_payloads( times) # Output from the flowgraph summary.add(TestResult(decoded_data=decoded_data, lora_config=lora_config, test=test), print_intermediate=True) # Finally, export the result for the suite summary.export_summary(path=self.reports_directory, write_output=write_output)
def setUp(self): self.send_tb = gr.top_block() self.recv_tb = gr.top_block()
def main(args): nargs = len(args) if nargs == 1: infile = args[0] outfile = None elif nargs == 2: port = int(args[0]) outfile = args[1] else: sys.stderr.write("Usage: dvbt-hackrf.py port [output_file]\n"); sys.exit(1) channel_mhz = 6 mode = dtv.T2k code_rate = dtv.C1_2 constellation = dtv.MOD_QPSK guard_interval = dtv.GI_1_32 symbol_rate = channel_mhz * 8000000.0 / 7 center_freq = 441000000 rf_gain = 14 if_gain = 40 if mode == dtv.T2k: factor = 1 carriers = 2048 elif mode == dtv.T8k: factor = 4 carriers = 8192 if guard_interval == dtv.GI_1_32: gi = carriers / 32 elif guard_interval == dtv.GI_1_16: gi = carriers / 16 elif guard_interval == dtv.GI_1_8: gi = carriers / 8 elif guard_interval == dtv.GI_1_4: gi = carriers / 4 if channel_mhz == 8: bandwidth = 8750000 elif channel_mhz == 7: bandwidth = 7000000 elif channel_mhz == 6: bandwidth = 6000000 elif channel_mhz == 5: bandwidth = 5000000 else: bandwidth = 8750000 tb = gr.top_block() src = blocks.file_source(gr.sizeof_char, infile, True) dvbt_energy_dispersal = dtv.dvbt_energy_dispersal(1 * factor) dvbt_reed_solomon_enc = dtv.dvbt_reed_solomon_enc(2, 8, 0x11d, 255, 239, 8, 51, (8 * factor)) dvbt_convolutional_interleaver = dtv.dvbt_convolutional_interleaver((136 * factor), 12, 17) dvbt_inner_coder = dtv.dvbt_inner_coder(1, (1512 * factor), constellation, dtv.NH, code_rate) dvbt_bit_inner_interleaver = dtv.dvbt_bit_inner_interleaver((1512 * factor), constellation, dtv.NH, mode) dvbt_symbol_inner_interleaver = dtv.dvbt_symbol_inner_interleaver((1512 * factor), mode, 1) dvbt_map = dtv.dvbt_map((1512 * factor), constellation, dtv.NH, mode, 1) dvbt_reference_signals = dtv.dvbt_reference_signals(gr.sizeof_gr_complex, (1512 * factor), carriers, constellation, dtv.NH, code_rate, code_rate, dtv.GI_1_32, mode, 0, 0) fft_vxx = fft.fft_vcc(carriers, False, (window.rectangular(carriers)), True, 10) digital_ofdm_cyclic_prefixer = digital.ofdm_cyclic_prefixer(carriers, carriers+(gi), 0, "") blocks_multiply_const_vxx = blocks.multiply_const_vcc((0.0022097087 * 2.5, )) out = osmosdr.sink() out.set_sample_rate(symbol_rate) out.set_center_freq(center_freq, 0) out.set_freq_corr(0, 0) out.set_gain(rf_gain, 0) out.set_if_gain(if_gain, 0) out.set_bandwidth(bandwidth, 0) tb.connect(src, dvbt_energy_dispersal) tb.connect(dvbt_energy_dispersal, dvbt_reed_solomon_enc) tb.connect(dvbt_reed_solomon_enc, dvbt_convolutional_interleaver) tb.connect(dvbt_convolutional_interleaver, dvbt_inner_coder) tb.connect(dvbt_inner_coder, dvbt_bit_inner_interleaver) tb.connect(dvbt_bit_inner_interleaver, dvbt_symbol_inner_interleaver) tb.connect(dvbt_symbol_inner_interleaver, dvbt_map) tb.connect(dvbt_map, dvbt_reference_signals) tb.connect(dvbt_reference_signals, fft_vxx) tb.connect(fft_vxx, digital_ofdm_cyclic_prefixer) tb.connect(digital_ofdm_cyclic_prefixer, blocks_multiply_const_vxx) tb.connect(blocks_multiply_const_vxx, out) if outfile: dst = blocks.file_sink(gr.sizeof_gr_complex, outfile) tb.connect(blocks_multiply_const_vxx, dst) tb.run()
def setUp(self): self.tb = gr.top_block() tp = drm.transm_params(1, 3, False, 0, False, 1, 0, 1, 1, 0, False, 24000, "station label", "text message") self.tables = tp.cfg().ptables()
def main(args): nargs = len(args) if nargs == 1: infile = args[0] outfile = None elif nargs == 2: infile = args[0] outfile = args[1] else: sys.stderr.write("Usage: atsc-blade.py input_file [output_file]\n") sys.exit(1) symbol_rate = 4500000.0 / 286 * 684 pilot_freq = 309441 center_freq = 441000000 txvga1_gain = -4 txvga2_gain = 25 tb = gr.top_block() src = blocks.file_source(gr.sizeof_char, infile, True) pad = atsc.pad() rand = atsc.randomizer() rs_enc = atsc.rs_encoder() inter = atsc.interleaver() trell = atsc.trellis_encoder() fsm = atsc.field_sync_mux() v2s = blocks.vector_to_stream(gr.sizeof_char, 1024) minn = blocks.keep_m_in_n(gr.sizeof_char, 832, 1024, 4) c2sym = digital.chunks_to_symbols_bc( ([symbol + 1.25 for symbol in [-7, -5, -3, -1, 1, 3, 5, 7]]), 1) offset = analog.sig_source_c(symbol_rate, analog.GR_COS_WAVE, -3000000 + pilot_freq, 0.9, 0) mix = blocks.multiply_vcc(1) rrc_taps = firdes.root_raised_cosine(0.1, symbol_rate * 2, symbol_rate / 2, 0.1152, 200) rrc = filter.rational_resampler_ccc( interpolation=2, decimation=3, taps=rrc_taps, fractional_bw=None, ) out = osmosdr.sink(args="bladerf=0,buffers=128,buflen=32768") out.set_sample_rate(symbol_rate * 2 / 3) out.set_center_freq(center_freq, 0) out.set_freq_corr(0, 0) out.set_gain(txvga2_gain, 0) out.set_bb_gain(txvga1_gain, 0) out.set_bandwidth(6000000, 0) tb.connect(src, pad, rand, rs_enc, inter, trell, fsm, v2s, minn, c2sym) tb.connect((c2sym, 0), (mix, 0)) tb.connect((offset, 0), (mix, 1)) tb.connect(mix, rrc, out) if outfile: dst = blocks.file_sink(gr.sizeof_gr_complex, outfile) tb.connect(rrc, dst) tb.run()
def setUp (self): self.fg = gr.top_block ()
while tt - math.floor(tt) < 0.2 or tt - math.floor(tt) > 0.3: tt = time.time() time.sleep(0.01) print("Latching at " + str(tt)) if not op.nosync: u.set_time_unknown_pps(uhd.time_spec(math.ceil(tt) + 1.0)) u.set_subdev_spec(op.subdev) u.set_samp_rate(op.samplerate) u.set_center_freq(op.centerfreqs[0], 0) u.set_center_freq(op.centerfreqs[1], 1) u.set_gain(op.gain, 0) u.set_gain(op.gain, 1) # create flowgraph fg = gr.top_block() dst_0 = None dst_1 = None if op.stop_on_dropped == True: op.stop_on_dropped = 1 else: op.stop_on_dropped = 0 if op.dec > 1: dst_0 = drf.digital_rf(op.dir0, int(op.filesize), int(3600), gr.sizeof_gr_complex, op.samplerate, 0, op.stop_on_dropped) dst_1 = drf.digital_rf(op.dir1, int(op.filesize), int(3600), gr.sizeof_gr_complex, op.samplerate, 0,
def setUp(self): self.tb = gr.top_block() self.tsb_key = "packet_len"
def setUp (self): self.tb = gr.top_block () self.pdf = Pdf_class(self.id().split(".")[1])