def test_003(self): # number of input streams != number of output streams src0_data = self.make_random_int_tuple(16000) src1_data = self.make_random_int_tuple(16000) src0 = gr.vector_source_i(src0_data) src1 = gr.vector_source_i(src1_data) op = gr.kludge_copy(gr.sizeof_int) dst0 = gr.vector_sink_i() dst1 = gr.vector_sink_i() self.fg.connect(src0, (op, 0), dst0) self.fg.connect(src1, (op, 1)) self.assertRaises(ValueError, self.fg.run)
def test_001( self ): vlen = 256 N = 100000 refdata = random_integers(0, 1, N) data = random_integers(0, 1, N) ref = numpy.array([0]*vlen) for x in range(len(data)): ref[x%vlen] += 1 if refdata[x] != data[x] else 0 src0 = gr.vector_source_b( refdata.tolist() ) src1 = gr.vector_source_b( data.tolist() ) src2 = gr.vector_source_i( [vlen]*N ) uut = ofdm.bit_position_dependent_BER( "test" ) self.tb.connect( src0, ( uut, 0 ) ) self.tb.connect( src1, ( uut, 1 ) ) self.tb.connect( src2, ( uut, 2 ) ) self.tb.run() ret = numpy.array( uut.get_cntr_vec() ) self.assert_( (ret==ref).all() )
def test_002(self): # 2 input streams; 2 output streams src0_data = self.make_random_int_tuple(16000) src1_data = self.make_random_int_tuple(16000) src0 = gr.vector_source_i(src0_data) src1 = gr.vector_source_i(src1_data) op = gr.kludge_copy(gr.sizeof_int) dst0 = gr.vector_sink_i() dst1 = gr.vector_sink_i() self.fg.connect(src0, (op, 0), dst0) self.fg.connect(src1, (op, 1), dst1) self.fg.run() dst0_data = dst0.data() dst1_data = dst1.data() self.assertEqual(src0_data, dst0_data) self.assertEqual(src1_data, dst1_data)
def test_001_coder3m7 (self): """ Check Golay-encoding m=7 for 5 possible inputs """ src_data = (121,9,235,32,492,194,342,100,10,1) expected_data = ( 786312737, -786354655, -786312738, -786354655, 303895266, -303951134, -303895267, -303951134, -2071231372, 2071233652, -2071231372, -2071233653, -487776787, 487726573, 487776786, 487726573, 2104655245, 2104656498, -2104655246, 2104656498, 1954253691, -1954247813, 1954253691, 1954247812, -668457176, -668411689, -668457176, 668411688, 773968161, 773926622, -773968162, 773926622, 303895266, -303951134, 303895266, 303951133, 303951133, -303895267, -303951134, -303895267) src1 = gr.vector_source_i(src_data) coding_action = chancoding.rmg_encoder_vii(7,11) sink = gr.vector_sink_i(4) self.tb.connect(src1, coding_action) self.tb.connect(coding_action, sink) self.tb.run() for i in range( len(expected_data) ): self.assertEqual( sink.data()[i] , expected_data[i], i)
def test_deint_001 (self): lenx = 64 src0 = gr.vector_source_i (range (lenx)) op = gr.deinterleave (gr.sizeof_int,4) dst0 = gr.vector_sink_i () dst1 = gr.vector_sink_i () dst2 = gr.vector_sink_i () dst3 = gr.vector_sink_i () self.tb.connect (src0, op) op.connect(dst0,usesPortName="long_out_0") op.connect(dst1,usesPortName="long_out_1") op.connect(dst2,usesPortName="long_out_2") op.connect(dst3,usesPortName="long_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_003( self ): vlen = 200 N = 100000 _n = N / vlen refdata = random_integers(0, 1, N) data = random_integers(0, 1, N) vlen = concatenate( [ [vlen]*(_n/2),[vlen/2]*(_n/2),[vlen/4]*(_n)] ) src0 = gr.vector_source_b( refdata.tolist() ) src1 = gr.vector_source_b( data.tolist() ) src2 = gr.vector_source_i( vlen.tolist() ) uut = ofdm.bit_position_dependent_BER( "test" ) self.tb.connect( src0, ( uut, 0 ) ) self.tb.connect( src1, ( uut, 1 ) ) self.tb.connect( src2, ( uut, 2 ) ) if os.path.exists("test_000.uint"): os.remove("test_000.uint") if os.path.exists("test_001.uint"): os.remove("test_001.uint") self.assert_( not os.path.exists("test_000.uint") ) self.assert_( not os.path.exists("test_001.uint") ) self.tb.run() self.assert_( os.path.exists("test_000.uint")) self.assert_( os.path.exists("test_001.uint"))
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 scrambletest (self): length = 128 count = 1024 data = tuple([random.randint(0, 255) for i in range(count*length)]) seed = tuple([random.randint(1, 127) for i in range(count)]) src = gr.vector_source_b(data) seedsrc = gr.vector_source_i(seed) enc = raw.scrambler_bb(length, 0) dec = raw.scrambler_bb(length, 0) dst = gr.vector_sink_b() encoded = gr.vector_sink_b() self.tb.connect(src, enc, dec, dst) self.tb.connect(seedsrc, (enc,1)) self.tb.connect(seedsrc, (dec,1)) self.tb.connect(enc, encoded) self.tb.run() #print "data = ", data #print "unpacked = ", unpacked.data() #print "encoded = ", encoded.data() #print "decoded = ", decoded.data() #print "dst = ", dst.data() self.assertNotEqual(data, encoded.data()) self.assertEqual(data, dst.data()) self.assertEqual(data, dst.data())
def test_001(self): # Just run some data through and make sure it doesn't puke. src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) src = gr.vector_source_i(src_data) op = blocks.tag_debug(gr.sizeof_int, "tag QA") self.tb.connect(src, op) self.tb.run() x = op.current_tags()
def test_int_to_float_identity(self): src_data = (1, 2, 3, 4, 5) expected_data = (1.0, 2.0, 3.0, 4.0, 5.0) src = gr.vector_source_i(src_data) op = blocks_swig.int_to_float() dst = gr.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
def help_const_ii(self, src_data, exp_data, op): src = gr.vector_source_i(src_data) srcv = gr.stream_to_vector(gr.sizeof_int, len(src_data)) rhs = gr.vector_to_stream(gr.sizeof_int, len(src_data)) dst = gr.vector_sink_i() self.tb.connect(src, srcv, op, rhs, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data)
def test_001_ii(self): src_data = (1, 2, 3, 4, 5, 6) dst_data = (6, 15) src = gr.vector_source_i(src_data) itg = blocks_swig.integrate_ii(3) dst = gr.vector_sink_i() self.tb.connect(src, itg, dst) self.tb.run() self.assertEqual(dst_data, dst.data())
def test_and_const_ii (self): src_data = (1, 2, 3, 0x5004, 0x1150) expected_result = (0, 2, 2, 0x5000, 0x1100) src = gr.vector_source_i(src_data) op = blocks_swig.and_const_ii (0x55AA) dst = gr.vector_sink_i() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(dst.data(), expected_result)
def help_ii (self, src_data, exp_data, op): for s in zip (range (len (src_data)), src_data): src = gr.vector_source_i (s[1]) self.tb.connect (src, (op, s[0])) dst = gr.vector_sink_i () self.tb.connect (op, dst) self.tb.run () result_data = dst.data () self.assertEqual (exp_data, result_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 = gr.vector_source_i(src_data) op = blocks_swig.int_to_float(1, 5) dst = gr.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
def help_ii(self, src_data, exp_data, op): for s in zip(range(len(src_data)), src_data): src = gr.vector_source_i(s[1]) self.tb.connect(src, (op, s[0])) dst = gr.vector_sink_i() self.tb.connect(op, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data)
def body_110 (self): fg = self.fg src_data = (0, 1, 2, 3) src1 = gr.vector_source_i (src_data) dst1 = gr.vector_sink_i () fg.connect ((src1, 0), (dst1, 0)) fg.run () dst_data = dst1.data () self.assertEqual (src_data, dst_data)
def run(self, n_receive=None): """ Run the simulation. Args: n_receive: Stop after receiving this many samples. """ b100.set_image(self.fpgaimage) # steps_rqd only in for compatibility from gnuradio import gr, uhd if n_receive is None: n_receive = 10000 # Flip high and low bits of in_raw flipped_raw = flip_bits(self.in_raw, self.width) flipped_raw = unsigned_to_signed(flipped_raw, self.width) stream_args = uhd.stream_args(cpu_format='sc16', channels=range(1)) from_usrp = uhd.usrp_source(device_addr='', stream_args=stream_args) head = gr.head(4, n_receive) snk = gr.vector_sink_i() to_usrp = uhd.usrp_sink(device_addr='', stream_args=stream_args) src = gr.vector_source_i(flipped_raw) tb = gr.top_block() tb.connect(from_usrp, head, snk) tb.connect(src, to_usrp) tb.run() self.out_raw = snk.data() # Remove 0's start_offset = None stop_offset = None enumerated_raw = list(enumerate(self.out_raw)) for i, r in enumerated_raw: if r != 0: start_offset = i break for i, r in reversed(enumerated_raw): if r != 0: stop_offset = i break if start_offset is None or stop_offset is None: raise StandardError("Could not find any non-zero returned data.") self.out_raw = self.out_raw[start_offset:stop_offset + 1] # Shift to positive integers positive = [] for r in self.out_raw: if r < 0: r += pow(2, self.width) positive.append(r) self.out_raw = positive # Flip bits in out_raw self.out_raw = flip_bits(self.out_raw, self.width) if self.output_msgs: header_shift = pow(2, self.width - 1) samples, packets = stream_to_samples_and_packets(self.out_raw) self.out_samples = [ int_to_c(s, self.width / 2 - 1) for s in samples ] self.out_messages = packets
def test_skip_all(self): skip_cnt = len(self.src_data) expected_result = tuple(self.src_data[skip_cnt:]) src1 = gr.vector_source_i(self.src_data) op = gr.skiphead(gr.sizeof_int, skip_cnt) dst1 = gr.vector_sink_i() 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_i (self.src_data) op = gr.skiphead (gr.sizeof_int, skip_cnt) dst1 = gr.vector_sink_i () self.tb.connect (src1, op, dst1) self.tb.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def test_copy (self): src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) expected_result = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) src = gr.vector_source_i(src_data) op = gr.copy(gr.sizeof_int, True,4) dst = gr.vector_sink_i() self.tb.connect(src, op, dst) self.tb.run() dst_data = dst.data() self.assertEqual(expected_result, dst_data)
def test_001(self): # 1 input stream; 1 output stream src0_data = self.make_random_int_tuple(16000) src0 = gr.vector_source_i(src0_data) op = gr.kludge_copy(gr.sizeof_int) dst0 = gr.vector_sink_i() self.fg.connect(src0, op, dst0) self.fg.run() dst0_data = dst0.data() self.assertEqual(src0_data, dst0_data)
def test_001(self): # 1 input stream; 1 output stream src0_data = self.make_random_int_tuple(16000) src0 = gr.vector_source_i(src0_data) op = gr.kludge_copy(gr.sizeof_int) dst0 = gr.vector_sink_i() self.tb.connect(src0, op, dst0) self.tb.run() dst0_data = dst0.data() self.assertEqual(src0_data, dst0_data)
def run(self, n_receive=None): """ Run the simulation. Args: n_receive: Stop after receiving this many samples. """ b100.set_image(self.fpgaimage) # steps_rqd only in for compatibility from gnuradio import gr, uhd if n_receive is None: n_receive = 10000 # Flip high and low bits of in_raw flipped_raw = flip_bits(self.in_raw, self.width) flipped_raw = unsigned_to_signed(flipped_raw, self.width) stream_args = uhd.stream_args(cpu_format='sc16', channels=range(1)) from_usrp = uhd.usrp_source(device_addr='', stream_args=stream_args) head = gr.head(4, n_receive) snk = gr.vector_sink_i() to_usrp = uhd.usrp_sink(device_addr='', stream_args=stream_args) src = gr.vector_source_i(flipped_raw) tb = gr.top_block() tb.connect(from_usrp, head, snk) tb.connect(src, to_usrp) tb.run() self.out_raw = snk.data() # Remove 0's start_offset = None stop_offset = None enumerated_raw = list(enumerate(self.out_raw)) for i, r in enumerated_raw: if r != 0: start_offset = i break for i, r in reversed(enumerated_raw): if r != 0: stop_offset = i break if start_offset is None or stop_offset is None: raise StandardError("Could not find any non-zero returned data.") self.out_raw = self.out_raw[start_offset: stop_offset+1] # Shift to positive integers positive = [] for r in self.out_raw: if r < 0: r += pow(2, self.width) positive.append(r) self.out_raw = positive # Flip bits in out_raw self.out_raw = flip_bits(self.out_raw, self.width) if self.output_msgs: header_shift = pow(2, self.width-1) samples, packets = stream_to_samples_and_packets(self.out_raw) self.out_samples = [int_to_c(s, self.width/2-1) for s in samples] self.out_messages = packets
def body_301_hier (self): fg = self.fg src_data = (0, 1, 2, 3) expected_result = (5, 8, 11, 14) src1 = gr.vector_source_i (src_data) op = mult_add (fg, 3, 5) dst1 = gr.vector_sink_i () fg.connect (src1, op, dst1) fg.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def body_302_hier (self): fg = self.fg src_data = (0, 1, 2, 3) expected_result = (10, 11, 12, 13) src1 = gr.vector_source_i (src_data) op = gr.compose (fg, gr.add_const_ii (10)) dst1 = gr.vector_sink_i () fg.connect (src1, op, dst1) fg.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def body_303_hier (self): fg = self.fg src_data = (0, 1, 2, 3) expected_result = (35, 38, 41, 44) src1 = gr.vector_source_i (src_data) op = gr.compose (fg, gr.add_const_ii (10), mult_add (fg, 3, 5)) dst1 = gr.vector_sink_i () fg.connect (src1, op, dst1) fg.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def test_012_connect (self): fg = self.fg src_data = (0, 1, 2, 3) expected_result = (2, 3, 4, 5) src1 = gr.vector_source_i (src_data) op = gr.add_const_ii (2) dst1 = gr.vector_sink_i () fg.connect (src1, op) fg.connect (op, dst1) # print "edge_list:", fg.edge_list fg.validate ()
def body_300_hier (self): fg = self.fg src_data = (0, 1, 2, 3) expected_result = (10, 11, 12, 13) src1 = gr.vector_source_i (src_data) op = wrap_add (fg, 10) dst1 = gr.vector_sink_i () fg.connect (src1, op, dst1) fg.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def help_ii(self, src_data, exp_data, op, port_prefix='data_in_'): for s in zip(range(len(src_data)), src_data): src = gr.vector_source_i(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_i() self.tb.connect(op, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data)
def test_head (self): src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) expected_result = (1, 2, 3, 4) src1 = gr.vector_source_i (src_data) op = gr.head (gr.sizeof_int, 4) dst1 = gr.vector_sink_i () self.tb.connect (src1, op) self.tb.connect (op, dst1) self.tb.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def body_111v (self): fg = self.fg src_data = (0, 1, 2, 3) expected_result = (2, 3, 4, 5) src1 = gr.vector_source_i (src_data) op = gr.add_const_ii (2) dst1 = gr.vector_sink_i () fg.connect (src1, op, dst1) fg.run () dst_data = dst1.data () self.assertEqual (expected_result, dst_data)
def test_head(self): src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) expected_result = (1, 2, 3, 4) src1 = gr.vector_source_i(src_data) op = gr.head(gr.sizeof_int, 4) dst1 = gr.vector_sink_i() self.tb.connect(src1, op) self.tb.connect(op, dst1) self.tb.run() dst_data = dst1.data() self.assertEqual(expected_result, dst_data)
def help_ii (self, src_data, exp_data, op, port_prefix='data_in_'): for s in zip (range (len (src_data)), src_data): src = gr.vector_source_i (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_i () self.tb.connect (op, dst) self.tb.run () result_data = dst.data () self.assertEqual (exp_data, result_data)
def test_deint_001(self): lenx = 64 src = gr.vector_source_i(range(lenx)) op = gr.deinterleave(gr.sizeof_int, 1) dst0 = gr.vector_sink_i() 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_ii(self, size, src_data, exp_data, op): for s in zip(range (len (src_data)), src_data): src = gr.vector_source_i(s[1]) srcv = gr.stream_to_vector(gr.sizeof_int, size) self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) rhs = gr.vector_to_stream(gr.sizeof_int, size) dst = gr.vector_sink_i() self.tb.connect(op, rhs, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data)
def help_ii(self, size, src_data, exp_data, op): for s in zip(range(len(src_data)), src_data): src = gr.vector_source_i(s[1]) srcv = gr.stream_to_vector(gr.sizeof_int, size) self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) rhs = gr.vector_to_stream(gr.sizeof_int, size) dst = gr.vector_sink_i() self.tb.connect(op, rhs, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data)
def test_001_int(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_i(src_data) rpt = gr.repeat(gr.sizeof_int, 3) dst = gr.vector_sink_i() self.tb.connect(src, rpt, dst) self.tb.run() self.assertEqual(tuple(dst_data), dst.data())
def test_001(self): self.maxDiff = None tb = gr.top_block() src1 = gr.vector_source_i(range(0, 100)) src2 = gr.vector_source_i(range(0, 100)) src3 = gr.vector_source_i(range(0, 100)) # itemsize, M, N, offset km2 = gr.keep_m_in_n(gr.sizeof_int, 4, 1, 2, 0) km3 = gr.keep_m_in_n(gr.sizeof_int, 4, 1, 3, 1) km7 = gr.keep_m_in_n(gr.sizeof_int, 4, 1, 7, 2) snk2 = gr.vector_sink_i() snk3 = gr.vector_sink_i() snk7 = gr.vector_sink_i() 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_005_i(self): value = 12 repeats = 100 src_data = [value] * repeats src = gr.vector_source_i(src_data) dst = gr.probe_signal_i() self.tb.connect(src, dst) self.tb.run() output = dst.level self.assertEqual(value, output)
def test_002_code_r5m5 (self): """ Check encoding r=5 m=5 for 5 possible inputs """ expected_data = (-1771465066, 1721341545, 252654387, 858993459, -1431672471) src_data = (125,182,392,16,419) src1 = gr.vector_source_i(src_data) coding_action = chancoding.rm_encoder_vii(5,5) sink = gr.vector_sink_i() self.tb.connect(src1, coding_action) self.tb.connect(coding_action, sink) self.tb.run() for i in range( len(expected_data) ): self.assertEqual( sink.data()[i] , expected_data[i], i)
def test_001(self): src_data = (0, 1, 2, 3, 4, 5, -1, -2, -3, -4, -5) expected_result = [float(s) for s in src_data] src = gr.vector_source_i(src_data) op = gr.int_to_float() dst = gr.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() result_data = dst.data() self.assertFloatTuplesAlmostEqual(expected_result, result_data)
def test_002(self): src_data=(-100,-99,-98,-97,-96,-1) expected_result = ((max(src_data)), ) src = gr.vector_source_i(src_data) s2v = gr.stream_to_vector(gr.sizeof_int, len(src_data)) op = gr.max_(gr.sizeof_int, 1, len(src_data) ) dst = gr.vector_sink_i() self.tb.connect(src, s2v, op, dst) self.tb.run() result_data = dst.data() self.assertEqual(expected_result, result_data)
def test_002(self): src_data = [1, 2, 3, 4] expected_result = [16777216, 33554432, 50331648, 67108864] src = gr.vector_source_i(src_data) op = gr.endian_swap(4) dst = gr.vector_sink_i() self.tb.connect(src, op, dst) self.tb.run() result_data = list(dst.data()) self.assertEqual(expected_result, result_data)
def test_002_pack4bits_6_elements_input(self): """ Check unpacking 4 Bits """ expected_data = (1, 0, 0, 1) src_data = (9, ) src1 = gr.vector_source_i(src_data, 0, 1) pack_bits = chancoding.packed_to_unpacked_vib(4) sink = gr.vector_sink_b() self.tb.connect(src1, pack_bits) self.tb.connect(pack_bits, sink) self.tb.run() for i in range(len(expected_data)): self.assertEqual(sink.data()[i], expected_data[i], i)
def test_003_code_r3m7 (self): """ Check encoding r=3 m=7 for 5 possible inputs """ src_data = (1902679864, 3, 147491936, 6, 24782, 0, 2472, 0, 12, 0) expected_data = ( -571585657, 756958344, 506300235, 517113780, 84238240, 919170156, 184180560, 959868060, 858993459, -859032781, -1717986919, 1718000025, -1431677611, 1431677610, 1515890085, 1515890085, -65536, 65535, -65536, 65535) src = gr.vector_source_i(src_data, 0, 2) encoder = chancoding.rm_encoder_vii(3,7) sink = gr.vector_sink_i(4) self.tb.connect(src, encoder, sink) self.tb.run() for i in range( len(expected_data) ): self.assertEqual( sink.data()[i] , expected_data[i], i)
def test_if_004(self): const = [-3, -1, 1, 3] src_data = (0, 1, 2, 3, 3, 2, 1, 0) expected_result = (-3, -1, 1, 3, 3, 1, -1, -3) src = gr.vector_source_i(src_data) op = digital.chunks_to_symbols_if(const) dst = gr.vector_sink_f() self.tb.connect(src, op) self.tb.connect(op, dst) self.tb.run() actual_result = dst.data() self.assertEqual(expected_result, actual_result)
def test_003_pack8bits_non_zero(self): """ Check unpacking 8 bits one time """ expected_data = (1, 0, 1, 1, 0, 0, 0, 0) src_data = (13, ) src1 = gr.vector_source_i(src_data, 0, 1) pack_bits = chancoding.packed_to_unpacked_vib(8) sink = gr.vector_sink_b() self.tb.connect(src1, pack_bits) self.tb.connect(pack_bits, sink) self.tb.run() for i in range(len(expected_data)): self.assertEqual(sink.data()[i], expected_data[i], i)
def test_ic_003(self): const = [1 + 0j, 0 + 1j, -1 + 0j, 0 - 1j] src_data = (0, 1, 2, 3, 3, 2, 1, 0) expected_result = (1 + 0j, 0 + 1j, -1 + 0j, 0 - 1j, 0 - 1j, -1 + 0j, 0 + 1j, 1 + 0j) src = gr.vector_source_i(src_data) op = digital.chunks_to_symbols_ic(const) dst = gr.vector_sink_c() self.tb.connect(src, op) self.tb.connect(op, dst) self.tb.run() actual_result = dst.data() self.assertEqual(expected_result, actual_result)
def test_006_vi(self): vector_length = 10 repeats = 10 value = [5 + i for i in range(0, vector_length)] src_data = value * repeats src = gr.vector_source_i(src_data) s2v = gr.stream_to_vector(gr.sizeof_float, vector_length) dst = gr.probe_signal_vi(vector_length) self.tb.connect(src, s2v, dst) self.tb.run() output = dst.level self.assertEqual(len(output), vector_length) self.assertAlmostEqual(value[3], output[3], places=6)
def test_001_overlap(self): src_data = range(16) expected_data = tuple( list((0, ) * 4) + range(4) + range(0, 8) + range(4, 12) + range(8, 16)) vlen = 8 src = gr.vector_source_i(src_data, False) s2v = specest.stream_to_vector_overlap(gr.sizeof_int, vlen, 4) dst = gr.vector_sink_i(vlen) self.tb.connect(src, s2v, dst) self.tb.run() dst_data = dst.data() self.assertEqual(expected_data, dst_data)
def test_002_codear5m5(self): """ Check Golay-encoding m5 for 5 possible inputs """ expected_data = (2027768814, -487726574, -290184584, 1195919287, -1220065209, -763895484, -507784568, 1220065208, 487776786, -303895267) src_data = (1084, 9, 1027, 32, 47, 1053, 1033, 46, 10, 1) src1 = gr.vector_source_i(src_data) coding_action = chancoding.rmg_encoder_vii(5, 5) sink = gr.vector_sink_i() self.tb.connect(src1, coding_action) self.tb.connect(coding_action, sink) self.tb.run() for i in range(len(expected_data)): self.assertEqual(sink.data()[i], expected_data[i], i)
def test_201b(self): random.seed(0) src_data = [] for i in xrange(100): src_data.append((random.randint(-2**31, 2**31 - 1))) src_data = tuple(src_data) expected_results = src_data src = gr.vector_source_i(tuple(src_data), False) op1 = blocks.packed_to_unpacked_ii(8, gr.GR_LSB_FIRST) op2 = blocks.unpacked_to_packed_ii(8, gr.GR_LSB_FIRST) dst = gr.vector_sink_i() self.tb.connect(src, op1, op2) self.tb.connect(op2, dst) self.tb.run() self.assertEqual(expected_results, dst.data())
def test_sample_and_hold_ii(self): src_data1 = tuple([i for i in range(10)]) src_data2 = (0, 0, 1, 1, 0, 1, 0, 0, 1, 1) expected_result = (0, 0, 2, 3, 3, 5, 5, 5, 8, 9) src1 = gr.vector_source_i(src_data1) src2 = gr.vector_source_b(src_data2) op = gr.sample_and_hold_ii() dst = gr.vector_sink_i() self.tb.connect(src1, op) self.tb.connect(src2, op) self.tb.connect(op, dst) self.tb.run() result_data = dst.data() self.assertEqual(expected_result, result_data)