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 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_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 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_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 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 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_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_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)
