def test_stretch_01(self): tb = self.tb data = 10*[1,] data0 = map(lambda x: x/20.0, data) data1 = map(lambda x: x/10.0, data) expected_result0 = 10*[0.05,] expected_result1 = 10*[0.1,] src0 = blocks.vector_source_f(data0, False) src1 = blocks.vector_source_f(data1, False) inter = blocks.streams_to_vector(gr.sizeof_float, 2) op = blocks.stretch_ff(0.1, 2) deinter = blocks.vector_to_streams(gr.sizeof_float, 2) dst0 = blocks.vector_sink_f() dst1 = blocks.vector_sink_f() tb.connect(src0, (inter,0)) tb.connect(src1, (inter,1)) tb.connect(inter, op) tb.connect(op, deinter) tb.connect((deinter,0), dst0) tb.connect((deinter,1), dst1) tb.run() dst0_data = dst0.data() dst1_data = dst1.data() self.assertFloatTuplesAlmostEqual(expected_result0, dst0_data, 4) self.assertFloatTuplesAlmostEqual(expected_result1, dst1_data, 4)
def test_interleaving(self): # Takes 3 streams (a, b and c) # Outputs 2 streams. # First (d) is interleaving of a and b. # Second (e) is interleaving of a and b and c. c is taken in # chunks of 2 which are reversed. A = (1, 2, 3, 4, 5) B = (11, 12, 13, 14, 15) C = (99, 98, 97, 96, 95, 94, 93, 92, 91, 90) expected_D = (1, 11, 2, 12, 3, 13, 4, 14, 5, 15) expected_E = (1, 11, 98, 99, 2, 12, 96, 97, 3, 13, 94, 95, 4, 14, 92, 93, 5, 15, 90, 91) mapping = [[(0, 0), (1, 0)], # mapping to produce D [(0, 0), (1, 0), (2, 1), (2, 0)], # mapping to produce E ] srcA = blocks.vector_source_f(A, False, 1) srcB = blocks.vector_source_f(B, False, 1) srcC = blocks.vector_source_f(C, False, 2) vmap = blocks.vector_map(gr.sizeof_int, (1, 1, 2), mapping) dstD = blocks.vector_sink_f(2) dstE = blocks.vector_sink_f(4) self.tb.connect(srcA, (vmap, 0)) self.tb.connect(srcB, (vmap, 1)) self.tb.connect(srcC, (vmap, 2)) self.tb.connect((vmap, 0), dstD) self.tb.connect((vmap, 1), dstE) self.tb.run() self.assertEqual(expected_D, dstD.data()) self.assertEqual(expected_E, dstE.data())
def test_f_003(self): # Test scenariou where we have defined a puncture pattern with # more bits than the puncsize with a delay. The python code # doesn't account for this when creating self.expected, but # this should be equivalent to a puncpat of the correct size. self.puncsize = 4 self.puncpat0 = 0x5555 # too many bits set self.puncpat1 = 0x55 # num bits = puncsize self.delay = 1 src = blocks.vector_source_f(self.src_data) op0 = fec.puncture_ff(self.puncsize, self.puncpat0, self.delay) op1 = fec.puncture_ff(self.puncsize, self.puncpat1, self.delay) dst0 = blocks.vector_sink_f() dst1 = blocks.vector_sink_f() self.tb.connect(src, op0, dst0) self.tb.connect(src, op1, dst1) self.tb.run() dst_data0 = list(dst0.data()) dst_data1 = list(dst1.data()) self.assertEqual(dst_data1, dst_data0)
def test_deint_001 (self): lenx = 64 src = blocks.vector_source_f (range (lenx)) op = blocks.deinterleave (gr.sizeof_float) dst0 = blocks.vector_sink_f () dst1 = blocks.vector_sink_f () dst2 = blocks.vector_sink_f () dst3 = blocks.vector_sink_f () self.tb.connect (src, op) self.tb.connect ((op, 0), dst0) self.tb.connect ((op, 1), dst1) self.tb.connect ((op, 2), dst2) self.tb.connect ((op, 3), dst3) 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_010_run(self): expected = (1.0, 2.0, 3.0, 4.0) hblock = gr.top_block("test_block") src = blocks.vector_source_f(expected, False) sink1 = blocks.vector_sink_f() sink2 = blocks.vector_sink_f() hblock.connect(src, sink1) hblock.connect(src, sink2) hblock.run() actual1 = sink1.data() actual2 = sink2.data() self.assertEquals(expected, actual1) self.assertEquals(expected, actual2)
def test_complex_to_float_2(self): src_data = (1 + 2j, 3 + 4j, 5 + 6j, 7 + 8j, 9 + 10j) expected_data1 = (1.0, 3.0, 5.0, 7.0, 9.0) expected_data2 = (2.0, 4.0, 6.0, 8.0, 10.0) src = blocks.vector_source_c(src_data) op = blocks.complex_to_float() dst1 = blocks.vector_sink_f() dst2 = blocks.vector_sink_f() self.tb.connect(src, op) self.tb.connect((op, 0), dst1) self.tb.connect((op, 1), dst2) self.tb.run() self.assertFloatTuplesAlmostEqual(expected_data1, dst1.data()) self.assertFloatTuplesAlmostEqual(expected_data2, dst2.data())
def test_complex_to_float_2(self): src_data = (1+2j, 3+4j, 5+6j, 7+8j, 9+10j) expected_data1 = (1.0, 3.0, 5.0, 7.0, 9.0) expected_data2 = (2.0, 4.0, 6.0, 8.0, 10.0) src = blocks.vector_source_c(src_data) op = blocks.complex_to_float() dst1 = blocks.vector_sink_f() dst2 = blocks.vector_sink_f() self.tb.connect(src, op) self.tb.connect((op, 0), dst1) self.tb.connect((op, 1), dst2) self.tb.run() self.assertFloatTuplesAlmostEqual(expected_data1, dst1.data()) self.assertFloatTuplesAlmostEqual(expected_data2, dst2.data())
def test_001_detect (self): """ Send two bursts, with zeros in between, and check they are both detected at the correct position and no false alarms occur """ n_zeros = 15 fft_len = 32 cp_len = 4 sig_len = (fft_len + cp_len) * 10 sync_symbol = [(random.randint(0, 1)*2)-1 for x in range(fft_len/2)] * 2 tx_signal = [0,] * n_zeros + \ sync_symbol[-cp_len:] + \ sync_symbol + \ [(random.randint(0, 1)*2)-1 for x in range(sig_len)] tx_signal = tx_signal * 2 add = blocks.add_cc() sync = digital.ofdm_sync_sc_cfb(fft_len, cp_len) sink_freq = blocks.vector_sink_f() sink_detect = blocks.vector_sink_b() self.tb.connect(blocks.vector_source_c(tx_signal), (add, 0)) self.tb.connect(analog.noise_source_c(analog.GR_GAUSSIAN, .01), (add, 1)) self.tb.connect(add, sync) self.tb.connect((sync, 0), sink_freq) self.tb.connect((sync, 1), sink_detect) self.tb.run() sig1_detect = sink_detect.data()[0:len(tx_signal)/2] sig2_detect = sink_detect.data()[len(tx_signal)/2:] self.assertTrue(abs(sig1_detect.index(1) - (n_zeros + fft_len + cp_len)) < cp_len) self.assertTrue(abs(sig2_detect.index(1) - (n_zeros + fft_len + cp_len)) < cp_len) self.assertEqual(numpy.sum(sig1_detect), 1) self.assertEqual(numpy.sum(sig2_detect), 1)
def test_004_ofdm_packets (self): """ Send several bursts using ofdm_tx, see if the number of detects is correct. Burst lengths and content are random. """ n_bursts = 42 fft_len = 64 cp_len = 16 # Here, coarse freq offset is allowed max_freq_offset = 2*numpy.pi/fft_len * 4 freq_offset = ((2 * random.random()) - 1) * max_freq_offset tx_signal = [] packets = [] tagname = "packet_length" min_packet_length = 10 max_packet_length = 50 sync_sequence = [random.randint(0, 1)*2-1 for x in range(fft_len/2)] for i in xrange(n_bursts): packet_length = random.randint(min_packet_length, max_packet_length+1) packet = [random.randint(0, 255) for i in range(packet_length)] packets.append(packet) data, tags = tagged_streams.packets_to_vectors(packets, tagname, vlen=1) total_length = len(data) src = blocks.vector_source_b(data, False, 1, tags) mod = ofdm_tx(packet_length_tag_key=tagname) sync = digital.ofdm_sync_sc_cfb(fft_len, cp_len) sink_freq = blocks.vector_sink_f() sink_detect = blocks.vector_sink_b() noise_level = 0.005 channel = channels.channel_model(noise_level, freq_offset / 2 / numpy.pi) self.tb.connect(src, mod, channel, sync, sink_freq) self.tb.connect((sync, 1), sink_detect) self.tb.run() self.assertEqual(numpy.sum(sink_detect.data()), n_bursts)
def test_003_multiburst (self): """ Send several bursts, see if the number of detects is correct. Burst lengths and content are random. """ n_bursts = 42 fft_len = 32 cp_len = 4 tx_signal = [] for i in xrange(n_bursts): sync_symbol = [(random.randint(0, 1)*2)-1 for x in range(fft_len/2)] * 2 tx_signal += [0,] * random.randint(0, 2*fft_len) + \ sync_symbol[-cp_len:] + \ sync_symbol + \ [(random.randint(0, 1)*2)-1 for x in range(fft_len * random.randint(5,23))] add = blocks.add_cc() sync = digital.ofdm_sync_sc_cfb(fft_len, cp_len) sink_freq = blocks.vector_sink_f() sink_detect = blocks.vector_sink_b() channel = channels.channel_model(0.005) self.tb.connect(blocks.vector_source_c(tx_signal), channel, sync) self.tb.connect((sync, 0), sink_freq) self.tb.connect((sync, 1), sink_detect) self.tb.run() n_bursts_detected = numpy.sum(sink_detect.data()) # We allow for one false alarm or missed burst self.assertTrue(abs(n_bursts_detected - n_bursts) <= 1, msg="""Because of statistics, it is possible (though unlikely) that the number of detected bursts differs slightly. If the number of detects is off by one or two, run the test again and see what happen. Detection error was: %d """ % (numpy.sum(sink_detect.data()) - n_bursts) )
def xtest_fff_004(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 = blocks.vector_source_f(src_data) op = filter.fft_filter_fff(1, taps) dst = blocks.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 test_descriptor_001(self): src_data = range(1000) expected_result = range(1000) filename = "tmp.32f" fhandle0 = open(filename, "wb") fd0 = fhandle0.fileno() src = blocks.vector_source_f(src_data) snk = blocks.file_descriptor_sink(gr.sizeof_float, fd0) self.tb.connect(src, snk) self.tb.run() os.fsync(fd0) fhandle0.close() fhandle1 = open(filename, "rb") fd1 = fhandle1.fileno() src2 = blocks.file_descriptor_source(gr.sizeof_float, fd1, False) snk2 = blocks.vector_sink_f() self.tb.disconnect(src, snk) self.tb.connect(src2, snk2) self.tb.run() os.fsync(fd1) fhandle1.close() os.remove(filename) result_data = snk2.data() self.assertFloatTuplesAlmostEqual(expected_result, result_data)
def xtest_fff_004(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 = blocks.vector_source_f(src_data) op = filter.fft_filter_fff(1, taps) dst = blocks.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 test_quad_demod_001(self): f = 1000.0 fs = 8000.0 src_data = [] for i in xrange(200): ti = i/fs src_data.append(cmath.exp(2j*cmath.pi*f*ti)) # f/fs is a quarter turn per sample. # Set the gain based on this to get 1 out. gain = 1.0/(cmath.pi/4) expected_result = [0,] + 199*[1.0] src = blocks.vector_source_c(src_data) op = analog.quadrature_demod_cf(gain) dst = blocks.vector_sink_f() self.tb.connect(src, op) self.tb.connect(op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_result, result_data, 5)
def test_003(self): # Cause a 8 bit errors out of 8*N bits # using test mode # Exit if BER < -2.0 mode = True N = 1000 data0 = numpy.random.randint(0, 256, N).tolist() data1 = copy.deepcopy(data0) data1[0] ^= 0xFF src0 = blocks.vector_source_b(data0) src1 = blocks.vector_source_b(data1) op = fec.ber_bf(mode, 10, -2.0) dst = blocks.vector_sink_f() self.tb.connect(src0, (op, 0)) self.tb.connect(src1, (op, 1)) self.tb.connect(op, dst) self.tb.run() data = dst.data() expected_result = [-2.0] print data print expected_result self.assertFloatTuplesAlmostEqual(expected_result, data, 5)
def test_001_detect(self): """ Send two bursts, with zeros in between, and check they are both detected at the correct position and no false alarms occur """ n_zeros = 15 fft_len = 32 cp_len = 4 sig_len = (fft_len + cp_len) * 10 sync_symbol = [(random.randint(0, 1) * 2) - 1 for x in range(fft_len / 2)] * 2 tx_signal = [0,] * n_zeros + \ sync_symbol[-cp_len:] + \ sync_symbol + \ [(random.randint(0, 1)*2)-1 for x in range(sig_len)] tx_signal = tx_signal * 2 add = blocks.add_cc() sync = digital.ofdm_sync_sc_cfb(fft_len, cp_len) sink_freq = blocks.vector_sink_f() sink_detect = blocks.vector_sink_b() self.tb.connect(blocks.vector_source_c(tx_signal), (add, 0)) self.tb.connect(analog.noise_source_c(analog.GR_GAUSSIAN, .01), (add, 1)) self.tb.connect(add, sync) self.tb.connect((sync, 0), sink_freq) self.tb.connect((sync, 1), sink_detect) self.tb.run() sig1_detect = sink_detect.data()[0:len(tx_signal) / 2] sig2_detect = sink_detect.data()[len(tx_signal) / 2:] self.assertTrue( abs(sig1_detect.index(1) - (n_zeros + fft_len + cp_len)) < cp_len) self.assertTrue( abs(sig2_detect.index(1) - (n_zeros + fft_len + cp_len)) < cp_len) self.assertEqual(numpy.sum(sig1_detect), 1) self.assertEqual(numpy.sum(sig2_detect), 1)
def test_002(self): port = 65500 n_data = 100 src_data = [float(x) for x in range(n_data)] expected_result = tuple(src_data) src = blocks.vector_source_f(src_data, False) udp_snd = blocks.udp_sink(gr.sizeof_float, 'localhost', port) self.tb_snd.connect(src, udp_snd) udp_rcv = blocks.udp_source(gr.sizeof_float, 'localhost', port) dst = blocks.vector_sink_f() self.tb_rcv.connect(udp_rcv, dst) self.tb_rcv.start() self.tb_snd.run() udp_snd.disconnect() self.timeout = False q = Timer(2.0,self.stop_rcv) q.start() self.tb_rcv.wait() q.cancel() result_data = dst.data() self.assertEqual(expected_result, result_data) self.assert_(not self.timeout)
def test_005_(self): src_data = (1.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0) dwav = numpy.array(src_data) wvps = numpy.zeros(3) # wavelet power spectrum scl = 1.0 / sqr(dwav[0]) k = 1 for e in range(len(wvps)): wvps[e] = scl * sqr(dwav[k:k + (01 << e)]).sum() k += 01 << e src = blocks.vector_source_f(src_data, False, len(src_data)) kon = wavelet_swig.wvps_ff(len(src_data)) dst = blocks.vector_sink_f(int(math.ceil(math.log(len(src_data), 2)))) self.tb.connect(src, kon) self.tb.connect(kon, dst) self.tb.run() snk_data = dst.data() sum = 0 for (u, v) in zip(snk_data, wvps): w = u - v sum += w * w sum /= float(len(snk_data)) assert sum < 1e-6
def test_fff_000(self): N = 1000 # number of samples to use fs = 1000 # baseband sampling rate rrate = 1.123 # resampling rate nfilts = 32 taps = filter.firdes.low_pass_2( nfilts, nfilts * fs, fs / 2, fs / 10, attenuation_dB=80, window=filter.firdes.WIN_BLACKMAN_hARRIS) freq = 100 data = sig_source_f(fs, freq, 1, N) signal = blocks.vector_source_f(data) pfb = filter.pfb_arb_resampler_fff(rrate, taps) snk = blocks.vector_sink_f() self.tb.connect(signal, pfb, snk) self.tb.run() Ntest = 50 L = len(snk.data()) t = map(lambda x: float(x) / (fs * rrate), xrange(L)) phase = 0.53013 expected_data = map( lambda x: math.sin(2. * math.pi * freq * x + phase), t) dst_data = snk.data() self.assertFloatTuplesAlmostEqual(expected_data[-Ntest:], dst_data[-Ntest:], 3)
def test_quad_demod_001(self): f = 1000.0 fs = 8000.0 src_data = [] for i in xrange(200): ti = i / fs src_data.append(cmath.exp(2j * cmath.pi * f * ti)) # f/fs is a quarter turn per sample. # Set the gain based on this to get 1 out. gain = 1.0 / (cmath.pi / 4) expected_result = [ 0, ] + 199 * [1.0] src = blocks.vector_source_c(src_data) op = analog.quadrature_demod_cf(gain) dst = blocks.vector_sink_f() self.tb.connect(src, op) self.tb.connect(op, dst) self.tb.run() result_data = dst.data() self.assertComplexTuplesAlmostEqual(expected_result, result_data, 5)
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 = blocks.vector_source_f(src_data) op = filter.rational_resampler_base_fff(interp, 1, taps) dst = blocks.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 test_005_(self): src_data = (1.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0) dwav = numpy.array(src_data) wvps = numpy.zeros(3) # wavelet power spectrum scl = 1.0/sqr(dwav[0]) k = 1 for e in range(len(wvps)): wvps[e] = scl*sqr(dwav[k:k+(01<<e)]).sum() k += 01<<e src = blocks.vector_source_f(src_data, False, len(src_data)) kon = wavelet_swig.wvps_ff(len(src_data)) dst = blocks.vector_sink_f(int(math.ceil(math.log(len(src_data), 2)))) self.tb.connect(src, kon) self.tb.connect(kon, dst) self.tb.run() snk_data = dst.data() sum = 0 for (u,v) in zip(snk_data, wvps): w = u - v sum += w * w sum /= float(len(snk_data)) assert sum < 1e-6
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 = blocks.vector_source_f(src_data) op = filter.rational_resampler_base_fff(1, decim, taps) dst = blocks.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 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 = blocks.vector_source_f(src_data) op = filter.rational_resampler_base_fff(1, decim, taps) dst = blocks.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 test_003(self): udp_rcv = blocks.udp_source(gr.sizeof_float, '0.0.0.0', 0, eof=False) rcv_port = udp_rcv.get_port() udp_snd = blocks.udp_sink(gr.sizeof_float, '127.0.0.1', 65500) udp_snd.connect('localhost', rcv_port) n_data = 16 src_data = [float(x) for x in range(n_data)] expected_result = tuple(src_data) src = blocks.vector_source_f(src_data) dst = blocks.vector_sink_f() self.tb_snd.connect(src, udp_snd) self.tb_rcv.connect(udp_rcv, dst) self.tb_rcv.start() self.tb_snd.run() udp_snd.disconnect() self.timeout = False q = Timer(2.0,self.stop_rcv) q.start() self.tb_rcv.wait() q.cancel() result_data = dst.data() self.assertEqual(expected_result, result_data) self.assert_(self.timeout) # source ignores EOF?
def test_003_multiburst(self): """ Send several bursts, see if the number of detects is correct. Burst lengths and content are random. """ n_bursts = 42 fft_len = 32 cp_len = 4 tx_signal = [] for i in xrange(n_bursts): sync_symbol = [(random.randint(0, 1) * 2) - 1 for x in range(fft_len / 2)] * 2 tx_signal += [0,] * random.randint(0, 2*fft_len) + \ sync_symbol[-cp_len:] + \ sync_symbol + \ [(random.randint(0, 1)*2)-1 for x in range(fft_len * random.randint(5,23))] add = blocks.add_cc() sync = digital.ofdm_sync_sc_cfb(fft_len, cp_len) sink_freq = blocks.vector_sink_f() sink_detect = blocks.vector_sink_b() channel = channels.channel_model(0.005) self.tb.connect(blocks.vector_source_c(tx_signal), channel, sync) self.tb.connect((sync, 0), sink_freq) self.tb.connect((sync, 1), sink_detect) self.tb.run() n_bursts_detected = numpy.sum(sink_detect.data()) # We allow for one false alarm or missed burst self.assertTrue( abs(n_bursts_detected - n_bursts) <= 1, msg="""Because of statistics, it is possible (though unlikely) that the number of detected bursts differs slightly. If the number of detects is off by one or two, run the test again and see what happen. Detection error was: %d """ % (numpy.sum(sink_detect.data()) - n_bursts))
def test_002(self): # Cause 8 bit errors out of 8*N bits # using test mode mode = True N = 1000 data0 = numpy.random.randint(0, 256, N).tolist() data1 = copy.deepcopy(data0) data1[0] ^= 0xFF src0 = blocks.vector_source_b(data0) src1 = blocks.vector_source_b(data1) op = fec.ber_bf(mode, 1, -2.0) dst = blocks.vector_sink_f() self.tb.connect(src0, (op, 0)) self.tb.connect(src1, (op, 1)) self.tb.connect(op, dst) self.tb.run() data = dst.data() expected_result = [ numpy.log10(8.0 / (8.0 * N)), ] self.assertFloatTuplesAlmostEqual(expected_result, data, 5)
def test_002(self): port = 65500 n_data = 100 src_data = [float(x) for x in range(n_data)] expected_result = tuple(src_data) src = blocks.vector_source_f(src_data, False) udp_snd = blocks.udp_sink(gr.sizeof_float, 'localhost', port) self.tb_snd.connect(src, udp_snd) udp_rcv = blocks.udp_source(gr.sizeof_float, 'localhost', port) dst = blocks.vector_sink_f() self.tb_rcv.connect(udp_rcv, dst) self.tb_rcv.start() self.tb_snd.run() udp_snd.disconnect() self.timeout = False q = Timer(2.0, self.stop_rcv) q.start() self.tb_rcv.wait() q.cancel() result_data = dst.data() self.assertEqual(expected_result, result_data) self.assert_(not self.timeout)
def test02(self): # Test float/float version omega = 2 gain_omega = 0.01 mu = 0.5 gain_mu = 0.01 omega_rel_lim = 0.001 self.test = digital.clock_recovery_mm_ff(omega, gain_omega, mu, gain_mu, omega_rel_lim) data = 100*[1,] self.src = blocks.vector_source_f(data, False) self.snk = blocks.vector_sink_f() self.tb.connect(self.src, self.test, self.snk) self.tb.run() expected_result = 100*[0.99972, ] # doesn't quite get to 1.0 dst_data = self.snk.data() # Only compare last Ncmp samples Ncmp = 30 len_e = len(expected_result) len_d = len(dst_data) expected_result = expected_result[len_e - Ncmp:] dst_data = dst_data[len_d - Ncmp:] #print expected_result #print dst_data self.assertFloatTuplesAlmostEqual(expected_result, dst_data, 5)
def test_fir_filter_fff_001(self): src_data = 40*[1, 2, 3, 4] expected_data = (0.5, 1.5, 3.0, 5.0, 5.5, 6.5, 8.0, 10.0, 10.5, 11.5, 13.0, 15.0, 15.5, 16.5, 18.0, 20.0, 20.5, 21.5, 23.0, 25.0, 25.5, 26.5, 28.0, 30.0, 30.5, 31.5, 33.0, 35.0, 35.5, 36.5, 38.0, 40.0, 40.5, 41.5, 43.0, 45.0, 45.5, 46.5, 48.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0) src = blocks.vector_source_f(src_data) op = filter.fir_filter_fff(1, 20*[0.5, 0.5]) dst = blocks.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertFloatTuplesAlmostEqual(expected_data, result_data, 5)
def test_003(self): udp_rcv = blocks.udp_source(gr.sizeof_float, '0.0.0.0', 0, eof=False) rcv_port = udp_rcv.get_port() udp_snd = blocks.udp_sink(gr.sizeof_float, '127.0.0.1', 65500) udp_snd.connect('localhost', rcv_port) n_data = 16 src_data = [float(x) for x in range(n_data)] expected_result = tuple(src_data) src = blocks.vector_source_f(src_data) dst = blocks.vector_sink_f() self.tb_snd.connect(src, udp_snd) self.tb_rcv.connect(udp_rcv, dst) self.tb_rcv.start() self.tb_snd.run() udp_snd.disconnect() self.timeout = False q = Timer(2.0, self.stop_rcv) q.start() self.tb_rcv.wait() q.cancel() result_data = dst.data() self.assertEqual(expected_result, result_data) self.assert_(self.timeout) # source ignores EOF?
def test_020_run(self): hblock = gr.top_block("test_block") data = (1.0, 2.0, 3.0, 4.0) src = blocks.vector_source_f(data, False) dst = blocks.vector_sink_f() hblock.connect(src, dst) hblock.run() self.assertEquals(data, dst.data())
def test_convolve(self): tb = gr.top_block() src = blocks.vector_source_f([1, 2, 3, 4, 5, 6, 7, 8], False) cv = convolve() sink = blocks.vector_sink_f() tb.connect(src, cv, sink) tb.run() self.assertEqual(sink.data(), (1, 2, 3, 4, 5, 6, 7, 8))
def test_decim2x(self): tb = gr.top_block() src = blocks.vector_source_f([1, 2, 3, 4, 5, 6, 7, 8], False) d2x = decim2x() sink = blocks.vector_sink_f() tb.connect(src, d2x, sink) tb.run() self.assertEqual(sink.data(), (1, 3, 5, 7))
def test_interp2x(self): tb = gr.top_block() src = blocks.vector_source_f([1, 3, 5, 7, 9], False) i2x = interp2x() sink = blocks.vector_sink_f() tb.connect(src, i2x, sink) tb.run() self.assertEqual(sink.data(), (1, 1, 3, 3, 5, 5, 7, 7, 9, 9))
def test_complex_to_real(self): src_data = (1+2j, 3+4j, 5+6j, 7+8j, 9+10j) expected_data = (1.0, 3.0, 5.0, 7.0, 9.0) src = blocks.vector_source_c(src_data) op = blocks.complex_to_real() dst = blocks.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
def test_char_to_float_scale(self): src_data = (1, 2, 3, 4, 5) expected_data = (0.5, 1.0, 1.5, 2.0, 2.5) src = blocks.vector_source_b(src_data) op = blocks.char_to_float(scale=2.0) dst = blocks.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
def test_char_to_float_identity(self): src_data = (1, 2, 3, 4, 5) expected_data = (1.0, 2.0, 3.0, 4.0, 5.0) src = blocks.vector_source_b(src_data) op = blocks.char_to_float() dst = blocks.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() self.assertFloatTuplesAlmostEqual(expected_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 = blocks.vector_source_s(src_data) op = blocks.short_to_float(1, 5) dst = blocks.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data())
def test_int_to_float_scale(self): src_data = (1, 2, 3, 4, 5) expected_data = (0.2, 0.4, 0.6, 0.8, 1.0) src = blocks.vector_source_i(src_data) op = blocks.int_to_float(1, 5) dst = blocks.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
def test_complex_to_real(self): src_data = (1 + 2j, 3 + 4j, 5 + 6j, 7 + 8j, 9 + 10j) expected_data = (1.0, 3.0, 5.0, 7.0, 9.0) src = blocks.vector_source_c(src_data) op = blocks.complex_to_real() dst = blocks.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
def test_complex_to_mag_squared(self): src_data = (1 + 2j, 3 - 4j, 5 + 6j, 7 - 8j, -9 + 10j) expected_data = (5.0, 25.0, 61.0, 113.0, 181.0) src = blocks.vector_source_c(src_data) op = blocks.complex_to_mag_squared() dst = blocks.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
def test_complex_to_mag(self): src_data = (1 + 2j, 3 - 4j, 5 + 6j, 7 - 8j, -9 + 10j) expected_data = (sqrt(5), sqrt(25), sqrt(61), sqrt(113), sqrt(181)) src = blocks.vector_source_c(src_data) op = blocks.complex_to_mag() dst = blocks.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() self.assertFloatTuplesAlmostEqual(expected_data, dst.data(), 5)
def test_complex_to_arg(self): src_data = (1+2j, 3-4j, 5+6j, 7-8j, -9+10j) expected_data = (atan2(2, 1), atan2(-4,3), atan2(6, 5), atan2(-8, 7), atan2(10,-9)) src = blocks.vector_source_c(src_data) op = blocks.complex_to_arg() dst = blocks.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() self.assertFloatTuplesAlmostEqual(expected_data, dst.data(), 2)
def help_ff(self, src_data, exp_data, op): for s in zip(range(len(src_data)), src_data): src = blocks.vector_source_f(s[1]) self.tb.connect(src, (op, s[0])) dst = blocks.vector_sink_f() self.tb.connect(op, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data)