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_001(self):
src1_data = [0,2,-3,0,12,0]
src2_data = [0,0,3,0,10,0]
src3_data = (0,0,3,0,1,0)
src4_data = (0,1,8,6,3,4)
a = sb.DataSource(dataFormat="short")
b = sb.DataSource(dataFormat="short")
c = sb.DataSource(dataFormat="short")
d = sb.DataSource(dataFormat="short")
argmax = gr.argmax(gr.sizeof_short, len(src1_data), 4)
a.connect(argmax,providesPortName="short_in_1")
b.connect(argmax,providesPortName="short_in_2")
c.connect(argmax,providesPortName="short_in_3")
d.connect(argmax,providesPortName="short_in_4")
dest1 = gr.vector_sink_s ()
dest2 = gr.vector_sink_s ()
argmax.connect(dest1,usesPortName="short_out_1")
argmax.connect(dest2,usesPortName="short_out_2")
sb.start()
a.push(src1_data,EOS=True)
b.push(src2_data,EOS=True)
c.push(src2_data,EOS=True)
d.push(src2_data,EOS=True)
index = dest1.getData(eos_block=True)
source = dest2.getData(eos_block=True)
self.assertEqual ( tuple(index), (4,))
self.assertEqual ( tuple(source), (0,))
def test_001(self):
src1_data = [0, 2, -3, 0, 12, 0]
src2_data = [0, 0, 3, 0, 10, 0]
src3_data = (0, 0, 3, 0, 1, 0)
src4_data = (0, 1, 8, 6, 3, 4)
a = sb.DataSource(dataFormat="short")
b = sb.DataSource(dataFormat="short")
c = sb.DataSource(dataFormat="short")
d = sb.DataSource(dataFormat="short")
argmax = gr.argmax(gr.sizeof_short, len(src1_data), 4)
a.connect(argmax, providesPortName="short_in_1")
b.connect(argmax, providesPortName="short_in_2")
c.connect(argmax, providesPortName="short_in_3")
d.connect(argmax, providesPortName="short_in_4")
dest1 = gr.vector_sink_s()
dest2 = gr.vector_sink_s()
argmax.connect(dest1, usesPortName="short_out_1")
argmax.connect(dest2, usesPortName="short_out_2")
sb.start()
a.push(src1_data, EOS=True)
b.push(src2_data, EOS=True)
c.push(src2_data, EOS=True)
d.push(src2_data, EOS=True)
index = dest1.getData(eos_block=True)
source = dest2.getData(eos_block=True)
self.assertEqual(tuple(index), (4, ))
self.assertEqual(tuple(source), (0, ))
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_001(self):
tb = self.tb
src1_data = (0, 0.2, -0.3, 0, 12, 0)
src2_data = (0, 0.0, 3.0, 0, 10, 0)
src3_data = (0, 0.0, 3.0, 0, 1, 0)
src1 = gr.vector_source_f(src1_data)
s2v1 = gr.stream_to_vector(gr.sizeof_float, len(src1_data))
tb.connect(src1, s2v1)
src2 = gr.vector_source_f(src2_data)
s2v2 = gr.stream_to_vector(gr.sizeof_float, len(src1_data))
tb.connect(src2, s2v2)
src3 = gr.vector_source_f(src3_data)
s2v3 = gr.stream_to_vector(gr.sizeof_float, len(src1_data))
tb.connect(src3, s2v3)
dst1 = gr.vector_sink_s()
dst2 = gr.vector_sink_s()
argmax = gr.argmax_fs(len(src1_data))
tb.connect(s2v1, (argmax, 0))
tb.connect(s2v2, (argmax, 1))
tb.connect(s2v3, (argmax, 2))
tb.connect((argmax, 0), dst1)
tb.connect((argmax, 1), dst2)
tb.run()
index = dst1.data()
source = dst2.data()
self.assertEqual(index, (4, ))
self.assertEqual(source, (0, ))
def test_001(self):
fg = self.fg
src1_data = (0,0.2,-0.3,0,12,0)
src2_data = (0,0.0,3.0,0,10,0)
src3_data = (0,0.0,3.0,0,1,0)
src1 = gr.vector_source_f (src1_data)
s2v1 = gr.stream_to_vector(gr.sizeof_float, len(src1_data))
fg.connect( src1, s2v1 )
src2 = gr.vector_source_f (src2_data)
s2v2 = gr.stream_to_vector(gr.sizeof_float, len(src1_data))
fg.connect( src2, s2v2 )
src3 = gr.vector_source_f (src3_data)
s2v3 = gr.stream_to_vector(gr.sizeof_float, len(src1_data))
fg.connect( src3, s2v3 )
dst1 = gr.vector_sink_s ()
dst2 = gr.vector_sink_s ()
argmax = gr.argmax_fs (len(src1_data))
fg.connect (s2v1, (argmax, 0))
fg.connect (s2v2, (argmax, 1))
fg.connect (s2v3, (argmax, 2))
fg.connect ((argmax,0), dst1)
fg.connect ((argmax,1), dst2)
fg.run ()
index = dst1.data ()
source = dst2.data ()
self.assertEqual ( index, (4,))
self.assertEqual ( source, (0,))
def test_001(self):
src1_data = [0,0.2,-0.3,0,12,0]
a = sb.DataSource(dataFormat="float")
argmax = gr.argmax(gr.sizeof_float, len(src1_data),1 )
a.connect(argmax,providesPortName="float_in")
dest1 = gr.vector_sink_s ()
dest2 = gr.vector_sink_s ()
argmax.connect(dest1,usesPortName="short_out_1")
argmax.connect(dest2,usesPortName="short_out_2")
sb.start()
a.push(src1_data,EOS=True)
index = dest1.getData(eos_block=True)
source = dest2.getData(eos_block=True)
self.assertEqual ( tuple(index), (4,))
self.assertEqual ( tuple(source), (0,))
def test_001(self):
src1_data = [0, 0.2, -0.3, 0, 12, 0]
a = sb.DataSource(dataFormat="float")
argmax = gr.argmax(gr.sizeof_float, len(src1_data), 1)
a.connect(argmax, providesPortName="float_in")
dest1 = gr.vector_sink_s()
dest2 = gr.vector_sink_s()
argmax.connect(dest1, usesPortName="short_out_1")
argmax.connect(dest2, usesPortName="short_out_2")
sb.start()
a.push(src1_data, EOS=True)
index = dest1.getData(eos_block=True)
source = dest2.getData(eos_block=True)
self.assertEqual(tuple(index), (4, ))
self.assertEqual(tuple(source), (0, ))
def test_int_001(self):
lenx = 64
src0 = range(0, lenx, 4)
src1 = range(1, lenx, 4)
src2 = range(2, lenx, 4)
src3 = range(3, lenx, 4)
a = sb.DataSource(dataFormat="short")
b = sb.DataSource(dataFormat="short")
c = sb.DataSource(dataFormat="short")
d = sb.DataSource(dataFormat="short")
op = gr.interleave(gr.sizeof_short, 4)
dst = gr.vector_sink_s()
a.connect(op, providesPortName="short_in_0")
b.connect(op, providesPortName="short_in_1")
c.connect(op, providesPortName="short_in_2")
d.connect(op, providesPortName="short_in_3")
a.push(src0, EOS=True)
b.push(src1, EOS=True)
c.push(src2, EOS=True)
d.push(src3, EOS=True)
self.tb.connect(op, dst)
self.tb.run()
expected_result = tuple(range(lenx))
result_data = dst.data()
self.assertFloatTuplesAlmostEqual(expected_result, result_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_int_001 (self):
lenx = 64
src0 = range (0, lenx, 4)
src1 = range (1, lenx, 4)
src2 = range (2, lenx, 4)
src3 = range (3, lenx, 4)
a = sb.DataSource(dataFormat="short")
b = sb.DataSource(dataFormat="short")
c = sb.DataSource(dataFormat="short")
d = sb.DataSource(dataFormat="short")
op = gr.interleave (gr.sizeof_short, 4)
dst = gr.vector_sink_s ()
a.connect(op, providesPortName="short_in_0")
b.connect(op, providesPortName="short_in_1")
c.connect(op, providesPortName="short_in_2")
d.connect(op, providesPortName="short_in_3")
a.push(src0,EOS=True)
b.push(src1,EOS=True)
c.push(src2,EOS=True)
d.push(src3,EOS=True)
self.tb.connect (op, dst)
self.tb.run ()
expected_result = tuple (range (lenx))
result_data = dst.data ()
self.assertFloatTuplesAlmostEqual (expected_result, result_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 main():
gr.enable_realtime_scheduling()
parser = OptionParser(option_class=eng_option, conflict_handler="resolve")
(options, args) = parser.parse_args ()
d = {'verbose': True, 'samples_per_symbol': 2, 'usrpx': None, 'excess_bw': 0.34999999999999998, 'fusb_block_size': 0, 'log': False, 'costas_alpha': 0.14999999999999999, 'bitrate': 100000.0, 'decim': DECIM, 'omega_relative_limit': 0.0050000000000000001, 'fusb_nblocks': 0, 'which': 0, 'rx_subdev_spec': None, 'freq_error': 0.0, 'lo_offset': None, 'modulation': 'gmsk', 'gain_mu': None, 'interface': 'eth0', 'freq': None, 'rx_freq': 2.475e9, 'rx_gain': RXGAIN, 'tx_freq': 2440000000.0, 'mu': 0.5, 'mac_addr': '', 'show_rx_gain_range': True, 'gray_code': True, 'tx_subdev_spec' : None, 'tx_gain' : None, 'show_tx_gain_range': False}
for i, j in d.items():
setattr(options, i, j)
u = usrp_options.create_usrp_source(options)
adc_rate = u.adc_rate()
if options.verbose:
print 'USRP Source:', u
(_bitrate, _samples_per_symbol, _decim) = \
pick_rx_bitrate(options.bitrate, 2, \
options.samples_per_symbol, options.decim, adc_rate, \
u.get_decim_rates())
u.set_decim(_decim)
if not u.set_center_freq(options.rx_freq):
print "Failed to set Rx frequency to %s" % (eng_notation.num_to_str(options.rx_freq))
raise ValueError, eng_notation.num_to_str(options.rx_freq)
tb = gr.top_block()
dst = gr.vector_sink_s ()
dump = gr.file_sink(gr.sizeof_gr_complex, 'packet.dat')
tb.connect(u, dump)
tb.run()
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_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_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 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 test_float_to_short_identity(self):
src_data = (1.0, 2.0, 3.0, 4.0, 5.0)
expected_data = (1, 2, 3, 4, 5)
src = gr.vector_source_f(src_data)
op = blocks_swig.float_to_short()
dst = gr.vector_sink_s()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(expected_data, dst.data())
def test_complex_to_interleaved_short(self):
src_data = (1 + 2j, 3 + 4j, 5 + 6j, 7 + 8j, 9 + 10j)
expected_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
src = gr.vector_source_c(src_data)
op = blocks_swig.complex_to_interleaved_short()
dst = gr.vector_sink_s()
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_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 test_float_to_short_identity(self):
src_data = (1.0, 2.0, 3.0, 4.0, 5.0)
expected_data = (1, 2, 3, 4, 5)
src = gr.vector_source_f(src_data)
op = blocks_swig.float_to_short()
dst = gr.vector_sink_s()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(expected_data, dst.data())
def test_char_to_short(self):
src_data = (1, 2, 3, 4, 5)
expected_data = (256, 512, 768, 1024, 1280)
src = gr.vector_source_b(src_data)
op = blocks_swig.char_to_short()
dst = gr.vector_sink_s()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(expected_data, dst.data())
def test_char_to_short(self):
src_data = (1, 2, 3, 4, 5)
expected_data = (256, 512, 768, 1024, 1280)
src = gr.vector_source_b(src_data)
op = blocks_swig.char_to_short()
dst = gr.vector_sink_s()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(expected_data, dst.data())
def test_complex_to_interleaved_short(self):
src_data = (1+2j, 3+4j, 5+6j, 7+8j, 9+10j)
expected_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
src = gr.vector_source_c(src_data)
op = blocks_swig.complex_to_interleaved_short()
dst = gr.vector_sink_s()
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_ss_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_s ()
self.tb.connect (op, 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_float_to_short_scale(self):
src_data = (1.0, 2.0, 3.0, 4.0, 5.0)
expected_data = (5, 10, 15, 20, 25)
src = gr.vector_source_f(src_data)
op = blocks_swig.float_to_short(1, 5)
dst = gr.vector_sink_s()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(expected_data, dst.data())
def test_float_to_short_scale(self):
src_data = (1.0, 2.0, 3.0, 4.0, 5.0)
expected_data = (5, 10, 15, 20, 25)
src = gr.vector_source_f(src_data)
op = blocks_swig.float_to_short(1, 5)
dst = gr.vector_sink_s()
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 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_const_s (self):
tb = self.tb
expected_result = (1, 1, 1, 1)
src1 = gr.sig_source_s (1e6, gr.GR_CONST_WAVE, 0, 1)
op = gr.head (gr.sizeof_short, 4)
dst1 = gr.vector_sink_s ()
tb.connect (src1, op)
tb.connect (op, dst1)
tb.run ()
dst_data = dst1.data ()
self.assertEqual (expected_result, dst_data)
def test_sqr_s(self):
tb = self.tb
expected_result = (0, 0, 0, 0, 1, 1, 1, 1, 0)
src1 = gr.sig_source_s(8, gr.GR_SQR_WAVE, 1.0, 1.0)
op = gr.head(gr.sizeof_short, 9)
dst1 = gr.vector_sink_s()
tb.connect(src1, op)
tb.connect(op, dst1)
tb.run()
dst_data = dst1.data()
self.assertEqual(expected_result, dst_data)
def test_sqr_s (self):
tb = self.tb
expected_result = (0, 0, 0, 0, 1, 1, 1, 1, 0)
src1 = gr.sig_source_s (8, gr.GR_SQR_WAVE, 1.0, 1.0)
op = gr.head (gr.sizeof_short, 9)
dst1 = gr.vector_sink_s ()
tb.connect (src1, op)
tb.connect (op, dst1)
tb.run ()
dst_data = dst1.data ()
self.assertEqual (expected_result, dst_data)
def test_const_s(self):
tb = self.tb
expected_result = (1, 1, 1, 1)
src1 = gr.sig_source_s(1e6, gr.GR_CONST_WAVE, 0, 1)
op = gr.head(gr.sizeof_short, 4)
dst1 = gr.vector_sink_s()
tb.connect(src1, op)
tb.connect(op, dst1)
tb.run()
dst_data = dst1.data()
self.assertEqual(expected_result, dst_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 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 test_fir_filter_fsf_002(self):
src_data = 40*[1, 2, 3, 4]
expected_data = (0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 50, 50, 50, 50,
50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
50, 50, 50, 50, 50, 50, 50, 50, 50, 50)
src = gr.vector_source_f(src_data)
op = filter.fir_filter_fsf(4, 20*[0.5, 0.5])
dst = gr.vector_sink_s()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = dst.data()
self.assertComplexTuplesAlmostEqual(expected_data, result_data, 5)
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 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_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 __init__(self):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option)
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
raise SystemExit, 1
src = gr.lfsr_32k_source_s()
head = gr.head(gr.sizeof_short, 2048)
self.dst = gr.vector_sink_s()
self.connect(src, head, self.dst)
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_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 __init__(self):
gr.top_block.__init__(self)
parser = OptionParser(option_class=eng_option)
(options, args) = parser.parse_args ()
if len(args) != 0:
parser.print_help()
raise SystemExit, 1
src = gr.lfsr_32k_source_s()
head = gr.head(gr.sizeof_short, 2048)
self.dst = gr.vector_sink_s()
self.connect(src, head, self.dst)
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 test_002(self):
src_data = (32766, 32767, 32768, -32767, -32768, -32769)
expected_result = [32766, 32767, 32767, -32767, -32768, -32768]
src = gr.vector_source_f(src_data)
op = gr.float_to_short()
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 test_int_001(self):
lenx = 64
src0 = range(0, lenx, 1)
a = sb.DataSource(dataFormat="short")
op = gr.interleave(gr.sizeof_short, 1)
dst = gr.vector_sink_s()
a.connect(op, providesPortName="short_in")
a.push(src0, EOS=True)
self.tb.connect(op, dst)
self.tb.run()
expected_result = tuple(range(lenx))
result_data = dst.data()
self.assertFloatTuplesAlmostEqual(expected_result, result_data)
