def test_002 (self): l = 100000 stream = [ [0]*l, [1]*l, [2]*l, [3]*l ] mux = concatenate(stream) seed() for i in range(l): a = randint(0,len(mux)-1) b = randint(0,len(mux)-1) mux[a],mux[b] = mux[b],mux[a] imux = [] for x in mux: imux.append(int(x)) data = [gr.vector_source_s(stream[0]), gr.vector_source_s(stream[1]), gr.vector_source_s(stream[2]), gr.vector_source_s(stream[3])] dst = gr.vector_sink_s() uut = ofdm.static_mux_v(gr.sizeof_short, imux) self.fg.connect(data[0], (uut,0)) self.fg.connect(data[1], (uut,1)) self.fg.connect(data[2], (uut,2)) self.fg.connect(data[3], (uut,3)) self.fg.connect(uut,dst) self.fg.run() self.assertEqual(list(mux),list(dst.data()))
def __init__(self): gr.top_block.__init__(self) length = 101 data_r = range(length) data_i = range(length,2*length) src_r = gr.vector_source_s(data_r, False) src_i = gr.vector_source_s(data_i, False) s2f_r = gr.short_to_float() s2f_i = gr.short_to_float() f2c = gr.float_to_complex() s2v = gr.stream_to_vector(gr.sizeof_gr_complex, length) shift = True ifft = gr.fft_vcc(length, False, [], shift) fft = gr.fft_vcc(length, True, [], shift) v2s = gr.vector_to_stream(gr.sizeof_gr_complex, length) snk_in = gr.file_sink(gr.sizeof_gr_complex, "fftshift.in") snk_out = gr.file_sink(gr.sizeof_gr_complex, "fftshift.out") self.connect(src_r, s2f_r, (f2c,0)) self.connect(src_i, s2f_i, (f2c,1)) self.connect(f2c, snk_in) self.connect(f2c, s2v, ifft, fft, v2s, snk_out)
def test_006(self): l = 100000 stream = [[0] * l, [1] * l, [2] * l] mux = [0, 2, 1] ref = concatenate([mux] * l) imux = [] for x in mux: imux.append(int(x)) data = [ gr.vector_source_s(stream[0]), gr.vector_source_s(stream[1]), gr.vector_source_s(stream[2]) ] dst = gr.vector_sink_s() uut = ofdm.static_mux_v(gr.sizeof_short, imux) self.fg.connect(data[0], (uut, 0)) self.fg.connect(data[1], (uut, 1)) self.fg.connect(data[2], (uut, 2)) self.fg.connect(uut, dst) self.fg.run() self.assertEqual(list(ref), list(dst.data()))
def test_001(self): stream = [[0] * 10, [1] * 10, [2] * 10] mux = [ 0, 2, 2, 1, 1, 2, 0, 2, 0, 0, 1, 0, 1, 0, 1, 2, 1, 2, 1, 1, 2, 0, 0, 2, 1, 2, 0, 1, 2, 0 ] imux = [] for x in mux: imux.append(int(x)) data = [ gr.vector_source_s(stream[0]), gr.vector_source_s(stream[1]), gr.vector_source_s(stream[2]) ] dst = gr.vector_sink_s() uut = ofdm.static_mux_v(gr.sizeof_short, imux) self.fg.connect(data[0], (uut, 0)) self.fg.connect(data[1], (uut, 1)) self.fg.connect(data[2], (uut, 2)) self.fg.connect(uut, dst) self.fg.run() self.assertEqual(mux, list(dst.data()))
def test_002(self): l = 100000 stream = [[0] * l, [1] * l, [2] * l, [3] * l] mux = concatenate(stream) seed() for i in range(l): a = randint(0, len(mux) - 1) b = randint(0, len(mux) - 1) mux[a], mux[b] = mux[b], mux[a] imux = [] for x in mux: imux.append(int(x)) data = [ gr.vector_source_s(stream[0]), gr.vector_source_s(stream[1]), gr.vector_source_s(stream[2]), gr.vector_source_s(stream[3]) ] dst = gr.vector_sink_s() uut = ofdm.static_mux_v(gr.sizeof_short, imux) self.fg.connect(data[0], (uut, 0)) self.fg.connect(data[1], (uut, 1)) self.fg.connect(data[2], (uut, 2)) self.fg.connect(data[3], (uut, 3)) self.fg.connect(uut, dst) self.fg.run() self.assertEqual(list(mux), list(dst.data()))
def test_005 (self): stream = [ [0]*10, [1]*10, [2]*10 ] mux = [ 0,1,2 ] ref = [ 0,1,2,0,1,2,0,1,2,0,1,2,0,1,2,0,1,2,0,1,2, 0,1,2,0,1,2,0,1,2 ] imux = [] for x in mux: imux.append(int(x)) data = [gr.vector_source_s(stream[0]), gr.vector_source_s(stream[1]), gr.vector_source_s(stream[2])] dst = gr.vector_sink_s() uut = ofdm.static_mux_v(gr.sizeof_short, imux) self.fg.connect(data[0], (uut,0)) self.fg.connect(data[1], (uut,1)) self.fg.connect(data[2], (uut,2)) self.fg.connect(uut,dst) self.fg.run() self.assertEqual(ref,list(dst.data()))
def test_006 (self): l = 100000 stream = [ [0]*l, [1]*l, [2]*l ] mux = [ 0,2,1 ] ref = concatenate([mux]*l) imux = [] for x in mux: imux.append(int(x)) data = [gr.vector_source_s(stream[0]), gr.vector_source_s(stream[1]), gr.vector_source_s(stream[2])] dst = gr.vector_sink_s() uut = ofdm.static_mux_v(gr.sizeof_short, imux) self.fg.connect(data[0], (uut,0)) self.fg.connect(data[1], (uut,1)) self.fg.connect(data[2], (uut,2)) self.fg.connect(uut,dst) self.fg.run() self.assertEqual(list(ref),list(dst.data()))
def test_001(self): src_data = ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10) trg_data = (-1, -1, 1, 1, -1, -1, 1, 1, -1, -1) src = gr.vector_source_i(src_data) trg = gr.vector_source_s(trg_data) op = blocks.burst_tagger(gr.sizeof_int) snk = blocks.tagged_file_sink(gr.sizeof_int, 1) self.tb.connect(src, (op,0)) self.tb.connect(trg, (op,1)) self.tb.connect(op, snk) self.tb.run() # Tagged file sink gets 2 burst tags at index 2 and index 5. # Creates two new files, each with two integers in them from # src_data at these indexes (3,4) and (7,8). file0 = "file{0}_0_2.00000000.dat".format(snk.unique_id()) file1 = "file{0}_1_6.00000000.dat".format(snk.unique_id()) # Open the files and read in the data, then remove the files # to clean up the directory. outfile0 = file(file0, 'rb') outfile1 = file(file1, 'rb') data0 = outfile0.read(8) data1 = outfile1.read(8) outfile0.close() outfile1.close() os.remove(file0) os.remove(file1) # Convert the 8 bytes from the files into a tuple of 2 ints. idata0 = struct.unpack('ii', data0) idata1 = struct.unpack('ii', data1) self.assertEqual(idata0, (3, 4)) self.assertEqual(idata1, (7, 8))
def __init__(self, uhd_address, options): gr.top_block.__init__(self) self.uhd_addr = uhd_address self.freq = options.freq self.samp_rate = options.samp_rate self.gain = options.gain self.threshold = options.threshold self.trigger = options.trigger self.uhd_src = uhd.single_usrp_source( device_addr=self.uhd_addr, stream_args=uhd.stream_args('fc32')) self.uhd_src.set_samp_rate(self.samp_rate) self.uhd_src.set_center_freq(self.freq, 0) self.uhd_src.set_gain(self.gain, 0) taps = firdes.low_pass_2(1, 1, 0.4, 0.1, 60) self.chanfilt = gr.fir_filter_ccc(10, taps) self.tagger = gr.burst_tagger(gr.sizeof_gr_complex) # Dummy signaler to collect a burst on known periods data = 1000 * [ 0, ] + 1000 * [ 1, ] self.signal = gr.vector_source_s(data, True) # Energy detector to get signal burst ## use squelch to detect energy self.det = gr.simple_squelch_cc(self.threshold, 0.01) ## convert to mag squared (float) self.c2m = gr.complex_to_mag_squared() ## average to debounce self.avg = gr.single_pole_iir_filter_ff(0.01) ## rescale signal for conversion to short self.scale = gr.multiply_const_ff(2**16) ## signal input uses shorts self.f2s = gr.float_to_short() # Use file sink burst tagger to capture bursts self.fsnk = gr.tagged_file_sink(gr.sizeof_gr_complex, self.samp_rate) ################################################## # Connections ################################################## self.connect((self.uhd_src, 0), (self.tagger, 0)) self.connect((self.tagger, 0), (self.fsnk, 0)) if self.trigger: # Connect a dummy signaler to the burst tagger self.connect((self.signal, 0), (self.tagger, 1)) else: # Connect an energy detector signaler to the burst tagger self.connect(self.uhd_src, self.det) self.connect(self.det, self.c2m, self.avg, self.scale, self.f2s) self.connect(self.f2s, (self.tagger, 1))
def test_deint_001(self): lenx = 64 src0 = gr.vector_source_s(range(lenx)) op = gr.deinterleave(gr.sizeof_short, 4) dst0 = gr.vector_sink_s() dst1 = gr.vector_sink_s() dst2 = gr.vector_sink_s() dst3 = gr.vector_sink_s() self.tb.connect(src0, op) op.connect(dst0, usesPortName="short_out_0") op.connect(dst1, usesPortName="short_out_1") op.connect(dst2, usesPortName="short_out_2") op.connect(dst3, usesPortName="short_out_3") self.tb.run() expected_result0 = tuple(range(0, lenx, 4)) expected_result1 = tuple(range(1, lenx, 4)) expected_result2 = tuple(range(2, lenx, 4)) expected_result3 = tuple(range(3, lenx, 4)) self.assertFloatTuplesAlmostEqual(expected_result0, dst0.data()) self.assertFloatTuplesAlmostEqual(expected_result1, dst1.data()) self.assertFloatTuplesAlmostEqual(expected_result2, dst2.data()) self.assertFloatTuplesAlmostEqual(expected_result3, dst3.data())
def test_fir_filter_scc_002(self): self.generate_scc_source() expected_data = ((-0.0080680437386-0.00158522999845j), (-0.0037795654498+0.00733159901574j), (0.00842926371843+0.00777021236718j), (0.0112090632319-0.00249325321056j), (-0.0027476802934-0.0115710813552j), (-0.0158688724041-0.00715934624895j), (-0.00802888441831+0.00620818417519j), (0.0131985172629+0.0149175003171j), (0.0190298333764+0.00956719089299j), (-0.00112380902283-0.00936658866704j), (-0.0204226914793-0.0333464704454j), (-0.00695514678955-0.0437445007265j), (0.0314490310848-0.0207983348519j), (0.0529675260186+0.0302227605134j), (0.0317338332534+0.0667510479689j), (-0.00775565672666+0.0437112376094j), (-0.024347923696-0.0303014591336j), (-0.0108893103898-0.0875638127327j), (0.00204296782613-0.0721434056759j), (-0.00527479872108-0.00698097236454j)) src = gr.vector_source_s(self.src_data) op = filter.freq_xlating_fir_filter_scc(4, self.taps, self.fc, self.fs) dst = gr.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
def test_fir_filter_scc_001(self): self.generate_scc_source() expected_data = ( (-0.00775564694777 + 0.0437113791704j), (0.0108830630779 + 0.0433648750186j), (0.015553932637 - 0.0133284125477j), (-0.0264905355871 - 0.0403266139328j), (-0.0243480335921 - 0.03030154109j), (-0.000327925226884 - 0.069333948195j), (-0.0306392069906 - 0.107313856483j), (-0.0452371090651 - 0.0854917764664j), (-0.0108894333243 - 0.0875641107559j), (-0.0182112380862 - 0.118961036205j), (-0.0447825863957 - 0.0922874584794j), (-0.0147479763255 - 0.0572904124856j), (0.00204290449619 - 0.0721436738968j), (-0.027713002637 - 0.0548989400268j), (-0.0149045493454 - 0.00210141134448j), (0.0176361314952 - 0.00149522523861j), (-0.00527482619509 - 0.00698099425063j), (-0.0151527002454 + 0.036265052855j), (0.0199296213686 + 0.0452499426901j), (0.0122985243797 + 0.0143278446048j)) src = gr.vector_source_s(self.src_data) op = filter.freq_xlating_fir_filter_scc(1, self.taps, self.fc, self.fs) dst = gr.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
def __init__(self, uhd_address, options): gr.top_block.__init__(self) self.uhd_addr = uhd_address self.freq = options.freq self.samp_rate = options.samp_rate self.gain = options.gain self.threshold = options.threshold self.trigger = options.trigger self.uhd_src = uhd.single_usrp_source( device_addr=self.uhd_addr, io_type=uhd.io_type_t.COMPLEX_FLOAT32, num_channels=1, ) self.uhd_src.set_samp_rate(self.samp_rate) self.uhd_src.set_center_freq(self.freq, 0) self.uhd_src.set_gain(self.gain, 0) taps = firdes.low_pass_2(1, 1, 0.4, 0.1, 60) self.chanfilt = gr.fir_filter_ccc(10, taps) self.tagger = gr.burst_tagger(gr.sizeof_gr_complex) # Dummy signaler to collect a burst on known periods data = 1000*[0,] + 1000*[1,] self.signal = gr.vector_source_s(data, True) # Energy detector to get signal burst ## use squelch to detect energy self.det = gr.simple_squelch_cc(self.threshold, 0.01) ## convert to mag squared (float) self.c2m = gr.complex_to_mag_squared() ## average to debounce self.avg = gr.single_pole_iir_filter_ff(0.01) ## rescale signal for conversion to short self.scale = gr.multiply_const_ff(2**16) ## signal input uses shorts self.f2s = gr.float_to_short() # Use file sink burst tagger to capture bursts self.fsnk = gr.tagged_file_sink(gr.sizeof_gr_complex, self.samp_rate) ################################################## # Connections ################################################## self.connect((self.uhd_src, 0), (self.tagger, 0)) self.connect((self.tagger, 0), (self.fsnk, 0)) if self.trigger: # Connect a dummy signaler to the burst tagger self.connect((self.signal, 0), (self.tagger, 1)) else: # Connect an energy detector signaler to the burst tagger self.connect(self.uhd_src, self.det) self.connect(self.det, self.c2m, self.avg, self.scale, self.f2s) self.connect(self.f2s, (self.tagger, 1))
def test_fir_filter_scc_002(self): self.generate_scc_source() expected_data = ( (-0.0080680437386 - 0.00158522999845j), (-0.0037795654498 + 0.00733159901574j), (0.00842926371843 + 0.00777021236718j), (0.0112090632319 - 0.00249325321056j), (-0.0027476802934 - 0.0115710813552j), (-0.0158688724041 - 0.00715934624895j), (-0.00802888441831 + 0.00620818417519j), (0.0131985172629 + 0.0149175003171j), (0.0190298333764 + 0.00956719089299j), (-0.00112380902283 - 0.00936658866704j), (-0.0204226914793 - 0.0333464704454j), (-0.00695514678955 - 0.0437445007265j), (0.0314490310848 - 0.0207983348519j), (0.0529675260186 + 0.0302227605134j), (0.0317338332534 + 0.0667510479689j), (-0.00775565672666 + 0.0437112376094j), (-0.024347923696 - 0.0303014591336j), (-0.0108893103898 - 0.0875638127327j), (0.00204296782613 - 0.0721434056759j), (-0.00527479872108 - 0.00698097236454j)) src = gr.vector_source_s(self.src_data) op = filter.freq_xlating_fir_filter_scc(4, self.taps, self.fc, self.fs) dst = gr.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
def test_fir_filter_scc_001(self): self.generate_scc_source() expected_data = ((-0.00775564694777+0.0437113791704j), (0.0108830630779+0.0433648750186j), (0.015553932637-0.0133284125477j), (-0.0264905355871-0.0403266139328j), (-0.0243480335921-0.03030154109j), (-0.000327925226884-0.069333948195j), (-0.0306392069906-0.107313856483j), (-0.0452371090651-0.0854917764664j), (-0.0108894333243-0.0875641107559j), (-0.0182112380862-0.118961036205j), (-0.0447825863957-0.0922874584794j), (-0.0147479763255-0.0572904124856j), (0.00204290449619-0.0721436738968j), (-0.027713002637-0.0548989400268j), (-0.0149045493454-0.00210141134448j), (0.0176361314952-0.00149522523861j), (-0.00527482619509-0.00698099425063j), (-0.0151527002454+0.036265052855j), (0.0199296213686+0.0452499426901j), (0.0122985243797+0.0143278446048j)) src = gr.vector_source_s(self.src_data) op = filter.freq_xlating_fir_filter_scc(1, self.taps, self.fc, self.fs) dst = gr.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
def test_deint_001 (self): lenx = 64 src0 = gr.vector_source_s (range (lenx)) op = gr.deinterleave (gr.sizeof_short,4) dst0 = gr.vector_sink_s () dst1 = gr.vector_sink_s () dst2 = gr.vector_sink_s () dst3 = gr.vector_sink_s () self.tb.connect (src0, op) op.connect(dst0,usesPortName="short_out_0") op.connect(dst1,usesPortName="short_out_1") op.connect(dst2,usesPortName="short_out_2") op.connect(dst3,usesPortName="short_out_3") self.tb.run () expected_result0 = tuple (range (0, lenx, 4)) expected_result1 = tuple (range (1, lenx, 4)) expected_result2 = tuple (range (2, lenx, 4)) expected_result3 = tuple (range (3, lenx, 4)) self.assertFloatTuplesAlmostEqual (expected_result0, dst0.data()) self.assertFloatTuplesAlmostEqual (expected_result1, dst1.data()) self.assertFloatTuplesAlmostEqual (expected_result2, dst2.data ()) self.assertFloatTuplesAlmostEqual (expected_result3, dst3.data ())
def test_fir_filter_scf_002(self): self.generate_scf_source() expected_data = ((0.00824625696987 - 1.50158575707e-05j), (0.0020101047121 - 0.0116540221497j), (-0.0126378880814 - 0.00259830290452j), (-0.00363933457993 + 0.00837504956871j), (0.00107023562305 + 0.00915473792702j), (0.0169738996774 + 0.00422182958573j), (0.00630031805485 - 0.025423232466j), (-0.0283014029264 + 0.00104465708137j), (0.00890890974551 + 0.0115978596732j), (-0.0142687577754 + 0.00306978379376j), (0.02845691517 + 0.0331163145602j), (0.0538152232766 - 0.0908300876617j), (-0.0843691527843 - 0.0956566259265j), (0.0476895272732 + 0.0747984498739j), (0.0898786485195 + 0.082478672266j), (-0.0330070182681 + 0.101965606213j), (0.0574697069824 - 0.0350842289627j), (-0.0770940706134 - 0.230615705252j), (-0.103762261569 - 0.0382265634835j), (0.11808334291 + 0.104863762856j)) src = gr.vector_source_s(self.src_data) op = filter.freq_xlating_fir_filter_scf(4, self.taps, self.fc, self.fs) dst = gr.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
def test_fir_filter_scf_001(self): self.generate_scf_source() expected_data = ( (-0.0330070219934 + 0.101965591311j), (-0.0484239049256 + 0.0872343629599j), (-0.0214109234512 + 0.102555386722j), (0.0484058149159 + 0.0557125210762j), (0.0574690811336 - 0.0350844524801j), (0.0365394353867 - 0.0802438184619j), (0.0453781634569 - 0.130992040038j), (0.00801951438189 - 0.214278846979j), (-0.0770946145058 - 0.230616629124j), (-0.105601429939 - 0.190731987357j), (-0.105361394584 - 0.177761554718j), (-0.131518915296 - 0.136102750897j), (-0.103761836886 - 0.0382263250649j), (-0.0167790111154 + 0.0152206514031j), (0.0277570039034 + 0.0300403907895j), (0.056065287441 + 0.0806603953242j), (0.118084669113 + 0.104863211513j), (0.128281414509 + 0.0677760615945j), (0.0748447552323 + 0.0619902014732j), (0.0512856245041 + 0.0775099247694j)) src = gr.vector_source_s(self.src_data) op = filter.freq_xlating_fir_filter_scf(1, self.taps, self.fc, self.fs) dst = gr.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
def test_fir_filter_scf_001(self): self.generate_scf_source() expected_data = ((-0.0330070219934+0.101965591311j), (-0.0484239049256+0.0872343629599j), (-0.0214109234512+0.102555386722j), (0.0484058149159+0.0557125210762j), (0.0574690811336-0.0350844524801j), (0.0365394353867-0.0802438184619j), (0.0453781634569-0.130992040038j), (0.00801951438189-0.214278846979j), (-0.0770946145058-0.230616629124j), (-0.105601429939-0.190731987357j), (-0.105361394584-0.177761554718j), (-0.131518915296-0.136102750897j), (-0.103761836886-0.0382263250649j), (-0.0167790111154+0.0152206514031j), (0.0277570039034+0.0300403907895j), (0.056065287441+0.0806603953242j), (0.118084669113+0.104863211513j), (0.128281414509+0.0677760615945j), (0.0748447552323+0.0619902014732j), (0.0512856245041+0.0775099247694j)) src = gr.vector_source_s(self.src_data) op = filter.freq_xlating_fir_filter_scf(1, self.taps, self.fc, self.fs) dst = gr.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
def test_fir_filter_scf_002(self): self.generate_scf_source() expected_data = ((0.00824625696987-1.50158575707e-05j), (0.0020101047121-0.0116540221497j), (-0.0126378880814-0.00259830290452j), (-0.00363933457993+0.00837504956871j), (0.00107023562305+0.00915473792702j), (0.0169738996774+0.00422182958573j), (0.00630031805485-0.025423232466j), (-0.0283014029264+0.00104465708137j), (0.00890890974551+0.0115978596732j), (-0.0142687577754+0.00306978379376j), (0.02845691517+0.0331163145602j), (0.0538152232766-0.0908300876617j), (-0.0843691527843-0.0956566259265j), (0.0476895272732+0.0747984498739j), (0.0898786485195+0.082478672266j), (-0.0330070182681+0.101965606213j), (0.0574697069824-0.0350842289627j), (-0.0770940706134-0.230615705252j), (-0.103762261569-0.0382265634835j), (0.11808334291+0.104863762856j)) src = gr.vector_source_s(self.src_data) op = filter.freq_xlating_fir_filter_scf(4, self.taps, self.fc, self.fs) dst = gr.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_data, result_data[-20:], 5)
def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Top Block") _icon_path = "/usr/share/icons/hicolor/32x32/apps/gnuradio-grc.png" self.SetIcon(wx.Icon(_icon_path, wx.BITMAP_TYPE_ANY)) ################################################## # Variables ################################################## self.symbol_rate = symbol_rate = 1000000 self.samp_rate = samp_rate = 500000 ################################################## # Blocks ################################################## self.uhd_usrp_sink_0 = uhd.usrp_sink( device_addr="", stream_args=uhd.stream_args( cpu_format="fc32", channels=range(1), ), ) self.uhd_usrp_sink_0.set_samp_rate(symbol_rate) self.uhd_usrp_sink_0.set_center_freq(915000000, 0) self.uhd_usrp_sink_0.set_gain(20, 0) self.random_source_x_0 = gr.vector_source_s( map(int, numpy.random.randint(0, 2, 2000000)), True) self.digital_qam_mod_0 = digital.qam.qam_mod( constellation_points=4, mod_code="gray", differential=True, samples_per_symbol=2, excess_bw=0.01, verbose=False, log=False, ) self.blocks_throttle_0 = blocks.throttle(gr.sizeof_float * 1, symbol_rate) self.blocks_short_to_float_0 = blocks.short_to_float(1, 1) self.blocks_multiply_xx_0 = blocks.multiply_vcc(1) self.blocks_float_to_uchar_0 = blocks.float_to_uchar() self.analog_sig_source_x_0 = analog.sig_source_c( samp_rate, analog.GR_COS_WAVE, 915000000, 1, 0) ################################################## # Connections ################################################## self.connect((self.random_source_x_0, 0), (self.blocks_short_to_float_0, 0)) self.connect((self.blocks_short_to_float_0, 0), (self.blocks_throttle_0, 0)) self.connect((self.blocks_throttle_0, 0), (self.blocks_float_to_uchar_0, 0)) self.connect((self.blocks_float_to_uchar_0, 0), (self.digital_qam_mod_0, 0)) self.connect((self.analog_sig_source_x_0, 0), (self.blocks_multiply_xx_0, 1)) self.connect((self.blocks_multiply_xx_0, 0), (self.uhd_usrp_sink_0, 0)) self.connect((self.digital_qam_mod_0, 0), (self.blocks_multiply_xx_0, 0))
def test_000_ss(self): src_data = (1, 2, 3, 4, 5, 6) dst_data = (6, 15) src = gr.vector_source_s(src_data) itg = gr.integrate_ss(3) dst = gr.vector_sink_s() self.tb.connect(src, itg, dst) self.tb.run() self.assertEqual(dst_data, dst.data())
def help_sf_const (self, src_data, exp_data, op): for s in zip (range (len (src_data)), src_data): src = gr.vector_source_s (s[1]) self.tb.connect (src, (op, s[0])) dst = gr.vector_sink_f () self.tb.connect (op, dst) self.tb.run () result_data = dst.data () self.assertEqual (exp_data, result_data)
def test_interleaved_short_to_complex(self): src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) expected_data = (1 + 2j, 3 + 4j, 5 + 6j, 7 + 8j, 9 + 10j) src = gr.vector_source_s(src_data) op = blocks_swig.interleaved_short_to_complex() dst = gr.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data())
def test_short_to_char(self): src_data = (256, 512, 768, 1024, 1280) expected_data = (1, 2, 3, 4, 5) src = gr.vector_source_s(src_data) op = blocks_swig.short_to_char() dst = gr.vector_sink_b() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data())
def test_and_const_ss (self): src_data = (1, 2, 3, 0x5004, 0x1150) expected_result = (0, 2, 2, 0x5000, 0x1100) src = gr.vector_source_s(src_data) op = blocks_swig.and_const_ss (0x55AA) dst = gr.vector_sink_s() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(dst.data(), expected_result)
def test_000_ss(self): src_data = (1, 2, 3, 4, 5, 6) dst_data = (6, 15) src = gr.vector_source_s(src_data) itg = blocks_swig.integrate_ss(3) dst = gr.vector_sink_s() self.tb.connect(src, itg, dst) self.tb.run() self.assertEqual(dst_data, dst.data())
def test_short_to_float_scale(self): src_data = (5, 10, 15, 20, 25) expected_data = (1.0, 2.0, 3.0, 4.0, 5.0) src = gr.vector_source_s(src_data) op = blocks_swig.short_to_float(1, 5) dst = gr.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data())
def help_const_ss(self, src_data, exp_data, op): src = gr.vector_source_s(src_data) srcv = gr.stream_to_vector(gr.sizeof_short, len(src_data)) rhs = gr.vector_to_stream(gr.sizeof_short, len(src_data)) dst = gr.vector_sink_s() self.tb.connect(src, srcv, op, rhs, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data)
def help_const_ss(self, src_data, exp_data, op): for s in zip(range(len(src_data)), src_data): src = gr.vector_source_s(s[1]) self.tb.connect(src, (op, s[0])) dst = gr.vector_sink_s() self.tb.connect(op, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data)
def test_interleaved_short_to_complex(self): src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) expected_data = (1+2j, 3+4j, 5+6j, 7+8j, 9+10j) src = gr.vector_source_s(src_data) op = blocks_swig.interleaved_short_to_complex() dst = gr.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data())
def test_001_fpdata_sink (self): src_data = (-3, 4, -5, 2, 3) expected_result = (-3, 4, -5, 2, 3) src = gr.vector_source_s (src_data) fpgnu = fpgnu_swig.fpdata_sink (1) dst = gr.vector_sink_s () self.tb.connect (src, fpgnu) self.tb.connect (fpgnu, dst) self.tb.run () result_data = dst.data ()
def test_skip_all(self): skip_cnt = len(self.src_data) expected_result = tuple(self.src_data[skip_cnt:]) src1 = gr.vector_source_s (self.src_data) op = gr.skiphead (gr.sizeof_short, skip_cnt) dst1 = gr.vector_sink_s () self.tb.connect (src1, op, dst1) self.tb.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def test_skip_all(self): skip_cnt = len(self.src_data) expected_result = tuple(self.src_data[skip_cnt:]) src1 = gr.vector_source_s(self.src_data) op = gr.skiphead(gr.sizeof_short, skip_cnt) dst1 = gr.vector_sink_s() self.tb.connect(src1, op, dst1) self.tb.run() dst_data = dst1.data() self.assertEqual(expected_result, dst_data)
def test_copy_drop (self): src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) expected_result = () src = gr.vector_source_s(src_data) op = gr.copy(gr.sizeof_short, False, 2) dst = gr.vector_sink_s() self.tb.connect(src, op, dst) self.tb.run() dst_data = dst.data() self.assertEqual(expected_result, dst_data)
def main(): data = scipy.arange(0, 32000, 1).tolist() trig = 100*[0,] + 100*[1,] src = gr.vector_source_s(data, True) trigger = gr.vector_source_s(trig, True) thr = gr.throttle(gr.sizeof_short, 10e3) ann = gr.annotator_alltoall(1000000, gr.sizeof_short) tagger = gr.burst_tagger(gr.sizeof_short) fsnk = gr.tagged_file_sink(gr.sizeof_short, 1) tb = gr.top_block() tb.connect(src, thr, (tagger, 0)) tb.connect(trigger, (tagger, 1)) tb.connect(tagger, fsnk) tb.run()
def help_sf (self, src_data, exp_data, op): for s in zip (range (len (src_data)), src_data): src = gr.vector_source_s (s[1]) src.source.connect(op,providesPortName="data_in_"+str(s[0])) src.streamID = str(s[0]) self.tb.sources.append(src) dst = gr.vector_sink_f () self.tb.connect (op, dst) self.tb.run () result_data = dst.data () self.assertEqual (exp_data, result_data)
def help_ss(self, src_data, exp_data, op, port_prefix='data_in_'): for s in zip(range(len(src_data)), src_data): src = gr.vector_source_s(s[1]) src.source.connect(op, providesPortName=port_prefix + str(s[0])) src.streamID = str(s[0]) self.tb.sources.append(src) dst = gr.vector_sink_s() self.tb.connect(op, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data)
def test_001_short(self): src_data = [n*1 for n in range(100)]; dst_data = [] for n in range(100): dst_data += [n, n, n] src = gr.vector_source_s(src_data) rpt = gr.repeat(gr.sizeof_short, 3) dst = gr.vector_sink_s() self.tb.connect(src, rpt, dst) self.tb.run() self.assertEqual(tuple(dst_data), dst.data())
def run_test(f, Kb, bitspersymbol, K, channel, modulation, dimensionality, tot_constellation, N0, seed): tb = gr.top_block() L = len(channel) # TX # this for loop is TOO slow in python!!! packet = [0] * (K + 2 * L) random.seed(seed) for i in range(len(packet)): packet[i] = random.randint(0, 2**bitspersymbol - 1) # random symbols for i in range(L): # first/last L symbols set to 0 packet[i] = 0 packet[len(packet) - i - 1] = 0 src = gr.vector_source_s(packet, False) mod = gr.chunks_to_symbols_sf(modulation[1], modulation[0]) # CHANNEL isi = gr.fir_filter_fff(1, channel) add = gr.add_ff() noise = gr.noise_source_f(gr.GR_GAUSSIAN, math.sqrt(N0 / 2), seed) # RX skip = gr.skiphead( gr.sizeof_float, L ) # skip the first L samples since you know they are coming from the L zero symbols #metrics = trellis.metrics_f(f.O(),dimensionality,tot_constellation,trellis.TRELLIS_EUCLIDEAN) # data preprocessing to generate metrics for Viterbi #va = trellis.viterbi_s(f,K+L,0,0) # Put -1 if the Initial/Final states are not set. va = trellis.viterbi_combined_s( f, K + L, 0, 0, dimensionality, tot_constellation, trellis.TRELLIS_EUCLIDEAN ) # using viterbi_combined_s instead of metrics_f/viterbi_s allows larger packet lengths because metrics_f is complaining for not being able to allocate large buffers. This is due to the large f.O() in this application... dst = gr.vector_sink_s() tb.connect(src, mod) tb.connect(mod, isi, (add, 0)) tb.connect(noise, (add, 1)) #tb.connect (add,metrics) #tb.connect (metrics,va,dst) tb.connect(add, skip, va, dst) tb.run() data = dst.data() ntotal = len(data) - L nright = 0 for i in range(ntotal): if packet[i + L] == data[i]: nright = nright + 1 #else: #print "Error in ", i return (ntotal, ntotal - nright)
def help_ss(self, size, src_data, exp_data, op): for s in zip(range (len (src_data)), src_data): src = gr.vector_source_s(s[1]) srcv = gr.stream_to_vector(gr.sizeof_short, size) self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) rhs = gr.vector_to_stream(gr.sizeof_short, size) dst = gr.vector_sink_s() self.tb.connect(op, rhs, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data)
def test_001 (self): repetitions = 4 #unsigned short input_bits, unsigned short repetitions uut = ofdm.repetition_encoder_sb(4, repetitions, [0]*(4*repetitions)) src = gr.vector_source_s([16+8+4+2+1, 16+1]) dst = gr.vector_sink_b() self.fg.connect(src, uut, dst) self.fg.run() ref = concatenate([[1,1,1,1]*repetitions, [1,0,0,0]*repetitions]) self.assertEqual(list(ref), list(dst.data()))
def test_deint_001(self): lenx = 64 src = gr.vector_source_s(range(lenx)) op = gr.deinterleave(gr.sizeof_short, 1) dst0 = gr.vector_sink_s() self.tb.connect(src, op) self.tb.connect((op, 0), dst0) self.tb.run() expected_result0 = tuple(range(0, lenx, 1)) self.assertFloatTuplesAlmostEqual(expected_result0, dst0.data())
def test_deint_001 (self): lenx = 64 src = gr.vector_source_s (range (lenx)) op = gr.deinterleave (gr.sizeof_short, 1) dst0 = gr.vector_sink_s () self.tb.connect (src, op) self.tb.connect ((op, 0), dst0) self.tb.run () expected_result0 = tuple (range (0, lenx, 1)) self.assertFloatTuplesAlmostEqual (expected_result0, dst0.data ())
def help_ss(self, size, src_data, exp_data, op): for s in zip(range(len(src_data)), src_data): src = gr.vector_source_s(s[1]) srcv = gr.stream_to_vector(gr.sizeof_short, size) self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) rhs = gr.vector_to_stream(gr.sizeof_short, size) dst = gr.vector_sink_s() self.tb.connect(op, rhs, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data)
def test_001(self): self.maxDiff = None tb = gr.top_block() src1 = gr.vector_source_s(range(0, 100)) src2 = gr.vector_source_s(range(0, 100)) src3 = gr.vector_source_s(range(0, 100)) # itemsize, M, N, offset km2 = gr.keep_m_in_n(gr.sizeof_short, 2, 1, 2, 0) km3 = gr.keep_m_in_n(gr.sizeof_short, 2, 1, 3, 1) km7 = gr.keep_m_in_n(gr.sizeof_short, 2, 1, 7, 2) snk2 = gr.vector_sink_s() snk3 = gr.vector_sink_s() snk7 = gr.vector_sink_s() tb.connect(src1, km2, snk2) tb.connect(src2, km3, snk3) tb.connect(src3, km7, snk7) tb.run() self.assertEqual(range(0, 100, 2), list(snk2.data())) self.assertEqual(range(1, 100, 3), list(snk3.data())) self.assertEqual(range(2, 100, 7), list(snk7.data()))
def test_003 (self): repetitions = 4 inout = [8+4+2+1, 1] #unsigned short input_bits, unsigned short repetitions uut1 = ofdm.repetition_encoder_sb(4, repetitions, [1,0,1,1,1,0,1,1,1,0,1,1,0,1,1,0]) uut2 = ofdm.repetition_decoder_bs(4, repetitions, [1,0,1,1,1,0,1,1,1,0,1,1,0,1,1,0]) src = gr.vector_source_s(inout) dst = gr.vector_sink_s() self.fg.connect(src, uut1, uut2, dst) self.fg.run() self.assertEqual(inout, list(dst.data()))
def test_003_s(self): value = 12 repeats = 100 src_data = [value] * repeats src = gr.vector_source_s(src_data) dst = gr.probe_signal_s() self.tb.connect(src, dst) self.tb.run() output = dst.level self.assertEqual(value, output)
def test_001(self): src_data = [1, 2, 3, 4] expected_result = [256, 512, 768, 1024] src = gr.vector_source_s(src_data) op = gr.endian_swap(2) dst = gr.vector_sink_s() self.tb.connect(src, op, dst) self.tb.run() result_data = list(dst.data()) self.assertEqual(expected_result, result_data)
def main(): data = scipy.arange(0, 32000, 1).tolist() trig = 100 * [ 0, ] + 100 * [ 1, ] src = gr.vector_source_s(data, True) trigger = gr.vector_source_s(trig, True) thr = gr.throttle(gr.sizeof_short, 10e3) ann = gr.annotator_alltoall(1000000, gr.sizeof_short) tagger = gr.burst_tagger(gr.sizeof_short) fsnk = gr.tagged_file_sink(gr.sizeof_short, 1) tb = gr.top_block() tb.connect(src, thr, (tagger, 0)) tb.connect(trigger, (tagger, 1)) tb.connect(tagger, fsnk) tb.run()
def test_001(self): src_data = range(0, 32767, 32767 / 127) src_data = [int(s) for s in src_data] expected_result = range(0, 128) src = gr.vector_source_s(src_data) op = gr.short_to_char() dst = gr.vector_sink_b() self.tb.connect(src, op, dst) self.tb.run() result_data = list(dst.data()) self.assertEqual(expected_result, result_data)