diff options
Diffstat (limited to 'gr-blocks/python')
51 files changed, 1508 insertions, 404 deletions
diff --git a/gr-blocks/python/qa_add_mult_div_sub.py b/gr-blocks/python/qa_add_mult_div_sub.py index 0aca03d3fd..6d48a6c389 100755 --- a/gr-blocks/python/qa_add_mult_div_sub.py +++ b/gr-blocks/python/qa_add_mult_div_sub.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# Copyright 2004,2007,2010,2012 Free Software Foundation, Inc. +# Copyright 2004,2007,2010,2012,2013 Free Software Foundation, Inc. # # This file is part of GNU Radio # @@ -21,7 +21,7 @@ # from gnuradio import gr, gr_unittest -import blocks_swig +import blocks_swig as blocks class test_add_mult_div_sub(gr_unittest.TestCase): @@ -33,9 +33,9 @@ class test_add_mult_div_sub(gr_unittest.TestCase): 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]) + src = blocks.vector_source_i(s[1]) self.tb.connect(src, (op, s[0])) - dst = gr.vector_sink_i() + dst = blocks.vector_sink_i() self.tb.connect(op, dst) self.tb.run() result_data = dst.data() @@ -43,9 +43,9 @@ class test_add_mult_div_sub(gr_unittest.TestCase): def help_ss(self, src_data, exp_data, op): for s in zip(range(len(src_data)), src_data): - src = gr.vector_source_s(s[1]) + src = blocks.vector_source_s(s[1]) self.tb.connect(src, (op, s[0])) - dst = gr.vector_sink_s() + dst = blocks.vector_sink_s() self.tb.connect(op, dst) self.tb.run() result_data = dst.data() @@ -53,9 +53,9 @@ class test_add_mult_div_sub(gr_unittest.TestCase): def help_ff(self, src_data, exp_data, op): for s in zip(range(len(src_data)), src_data): - src = gr.vector_source_f(s[1]) + src = blocks.vector_source_f(s[1]) self.tb.connect(src, (op, s[0])) - dst = gr.vector_sink_f() + dst = blocks.vector_sink_f() self.tb.connect(op, dst) self.tb.run() result_data = dst.data() @@ -63,9 +63,9 @@ class test_add_mult_div_sub(gr_unittest.TestCase): def help_cc(self, src_data, exp_data, op): for s in zip(range(len(src_data)), src_data): - src = gr.vector_source_c(s[1]) + src = blocks.vector_source_c(s[1]) self.tb.connect(src, (op, s[0])) - dst = gr.vector_sink_c() + dst = blocks.vector_sink_c() self.tb.connect(op, dst) self.tb.run() result_data = dst.data() @@ -77,28 +77,28 @@ class test_add_mult_div_sub(gr_unittest.TestCase): src1_data = (1, 2, 3, 4, 5) src2_data = (8, -3, 4, 8, 2) expected_result = (9, -1, 7, 12, 7) - op = blocks_swig.add_ss() + op = blocks.add_ss() self.help_ss((src1_data, src2_data), expected_result, op) def test_add_ii(self): src1_data = (1, 2, 3, 4, 5) src2_data = (8, -3, 4, 8, 2) expected_result = (9, -1, 7, 12, 7) - op = blocks_swig.add_ii() + op = blocks.add_ii() self.help_ii((src1_data, src2_data), expected_result, op) def test_add_ff(self): src1_data = (1.0, 2.0, 3.0, 4.0, 5.0) src2_data = (8.0, -3.0, 4.0, 8.0, 2.0) expected_result = (9.0, -1.0, 7.0, 12.0, 7.0) - op = blocks_swig.add_ff() + op = blocks.add_ff() self.help_ff((src1_data, src2_data), expected_result, op) def test_add_cc(self): src1_data = (1+1j, 2+2j, 3+3j, 4+4j, 5+5j) src2_data = (8+8j, -3-3j, 4+4j, 8+8j, 2+2j) expected_result = (9+9j, -1-1j, 7+7j, 12+12j, 7+7j) - op = blocks_swig.add_cc() + op = blocks.add_cc() self.help_cc((src1_data, src2_data), expected_result, op) # add_const_XX @@ -106,25 +106,25 @@ class test_add_mult_div_sub(gr_unittest.TestCase): def test_add_const_ss(self): src_data = (1, 2, 3, 4, 5) expected_result = (6, 7, 8, 9, 10) - op = blocks_swig.add_const_ss(5) + op = blocks.add_const_ss(5) self.help_ss((src_data,), expected_result, op) def test_add_const_ii(self): src_data = (1, 2, 3, 4, 5) expected_result = (6, 7, 8, 9, 10) - op = blocks_swig.add_const_ii(5) + op = blocks.add_const_ii(5) self.help_ii((src_data,), expected_result, op) def test_add_const_ff(self): src_data = (1, 2, 3, 4, 5) expected_result = (6, 7, 8, 9, 10) - op = blocks_swig.add_const_ff(5) + op = blocks.add_const_ff(5) self.help_ff((src_data,), expected_result, op) def test_add_const_cc(self): src_data = (1, 2, 3, 4, 5) expected_result = (1+5j, 2+5j, 3+5j, 4+5j, 5+5j) - op = blocks_swig.add_const_cc(5j) + op = blocks.add_const_cc(5j) self.help_cc((src_data,), expected_result, op) # multiply_XX @@ -133,7 +133,7 @@ class test_add_mult_div_sub(gr_unittest.TestCase): src1_data = (1, 2, 3, 4, 5) src2_data = (8, -3, 4, 8, 2) expected_result = (8, -6, 12, 32, 10) - op = blocks_swig.multiply_ss() + op = blocks.multiply_ss() self.help_ss((src1_data, src2_data), expected_result, op) @@ -141,7 +141,7 @@ class test_add_mult_div_sub(gr_unittest.TestCase): src1_data = (1, 2, 3, 4, 5) src2_data = (8, -3, 4, 8, 2) expected_result = (8, -6, 12, 32, 10) - op = blocks_swig.multiply_ii() + op = blocks.multiply_ii() self.help_ii((src1_data, src2_data), expected_result, op) @@ -149,7 +149,7 @@ class test_add_mult_div_sub(gr_unittest.TestCase): src1_data = (1, 2, 3, 4, 5) src2_data = (8, -3, 4, 8, 2) expected_result = (8, -6, 12, 32, 10) - op = blocks_swig.multiply_ff() + op = blocks.multiply_ff() self.help_ff((src1_data, src2_data), expected_result, op) @@ -157,7 +157,7 @@ class test_add_mult_div_sub(gr_unittest.TestCase): src1_data = (1+1j, 2+2j, 3+3j, 4+4j, 5+5j) src2_data = (8, -3, 4, 8, 2) expected_result = (8+8j, -6-6j, 12+12j, 32+32j, 10+10j) - op = blocks_swig.multiply_cc() + op = blocks.multiply_cc() self.help_cc((src1_data, src2_data), expected_result, op) @@ -166,38 +166,38 @@ class test_add_mult_div_sub(gr_unittest.TestCase): def test_multiply_const_ss(self): src_data = (-1, 0, 1, 2, 3) expected_result = (-5, 0, 5, 10, 15) - op = blocks_swig.multiply_const_ss(5) + op = blocks.multiply_const_ss(5) self.help_ss((src_data,), expected_result, op) def test_multiply_const_ii(self): src_data = (-1, 0, 1, 2, 3) expected_result = (-5, 0, 5, 10, 15) - op = blocks_swig.multiply_const_ii(5) + op = blocks.multiply_const_ii(5) self.help_ii((src_data,), expected_result, op) def test_multiply_const_ff(self): src_data = (-1, 0, 1, 2, 3) expected_result = (-5, 0, 5, 10, 15) - op = blocks_swig.multiply_const_ff(5) + op = blocks.multiply_const_ff(5) self.help_ff((src_data,), expected_result, op) def test_multiply_const_cc(self): src_data = (-1-1j, 0+0j, 1+1j, 2+2j, 3+3j) expected_result = (-5-5j, 0+0j, 5+5j, 10+10j, 15+15j) - op = blocks_swig.multiply_const_cc(5) + op = blocks.multiply_const_cc(5) self.help_cc((src_data,), expected_result, op) def test_multiply_const_cc2(self): src_data = (-1-1j, 0+0j, 1+1j, 2+2j, 3+3j) expected_result = (-3-7j, 0+0j, 3+7j, 6+14j, 9+21j) - op = blocks_swig.multiply_const_cc(5+2j) + op = blocks.multiply_const_cc(5+2j) self.help_cc((src_data,), expected_result, op) def test_sub_ii(self): src1_data = (1, 2, 3, 4, 5) src2_data = (8, -3, 4, 8, 2) expected_result = (-7, 5, -1, -4, 3) - op = blocks_swig.sub_ii() + op = blocks.sub_ii() self.help_ii((src1_data, src2_data), expected_result, op) @@ -205,7 +205,7 @@ class test_add_mult_div_sub(gr_unittest.TestCase): src1_data = ( 5, 9, -15, 1024) src2_data = (10, 3, -5, 64) expected_result = (0.5, 3, 3, 16) - op = blocks_swig.divide_ff() + op = blocks.divide_ff() self.help_ff((src1_data, src2_data), expected_result, op) if __name__ == '__main__': diff --git a/gr-blocks/python/qa_add_mult_v.py b/gr-blocks/python/qa_add_mult_v.py index 13cb71df2c..39040b159a 100755 --- a/gr-blocks/python/qa_add_mult_v.py +++ b/gr-blocks/python/qa_add_mult_v.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# Copyright 2004,2007,2010,2012 Free Software Foundation, Inc. +# Copyright 2004,2007,2010,2012,2013 Free Software Foundation, Inc. # # This file is part of GNU Radio # @@ -33,12 +33,12 @@ class test_add_mult_v(gr_unittest.TestCase): 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]) + src = blocks.vector_source_s(s[1]) srcv = blocks.stream_to_vector(gr.sizeof_short, size) self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) rhs = blocks.vector_to_stream(gr.sizeof_short, size) - dst = gr.vector_sink_s() + dst = blocks.vector_sink_s() self.tb.connect(op, rhs, dst) self.tb.run() result_data = dst.data() @@ -46,12 +46,12 @@ class test_add_mult_v(gr_unittest.TestCase): 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]) + src = blocks.vector_source_i(s[1]) srcv = blocks.stream_to_vector(gr.sizeof_int, size) self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) rhs = blocks.vector_to_stream(gr.sizeof_int, size) - dst = gr.vector_sink_i() + dst = blocks.vector_sink_i() self.tb.connect(op, rhs, dst) self.tb.run() result_data = dst.data() @@ -59,12 +59,12 @@ class test_add_mult_v(gr_unittest.TestCase): def help_ff(self, size, src_data, exp_data, op): for s in zip(range (len (src_data)), src_data): - src = gr.vector_source_f(s[1]) + src = blocks.vector_source_f(s[1]) srcv = blocks.stream_to_vector(gr.sizeof_float, size) self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) rhs = blocks.vector_to_stream(gr.sizeof_float, size) - dst = gr.vector_sink_f() + dst = blocks.vector_sink_f() self.tb.connect(op, rhs, dst) self.tb.run() result_data = dst.data() @@ -72,52 +72,52 @@ class test_add_mult_v(gr_unittest.TestCase): def help_cc(self, size, src_data, exp_data, op): for s in zip(range (len (src_data)), src_data): - src = gr.vector_source_c(s[1]) + src = blocks.vector_source_c(s[1]) srcv = blocks.stream_to_vector(gr.sizeof_gr_complex, size) self.tb.connect(src, srcv) self.tb.connect(srcv, (op, s[0])) rhs = blocks.vector_to_stream(gr.sizeof_gr_complex, size) - dst = gr.vector_sink_c() + dst = blocks.vector_sink_c() self.tb.connect(op, rhs, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data) def help_const_ss(self, src_data, exp_data, op): - src = gr.vector_source_s(src_data) + src = blocks.vector_source_s(src_data) srcv = blocks.stream_to_vector(gr.sizeof_short, len(src_data)) rhs = blocks.vector_to_stream(gr.sizeof_short, len(src_data)) - dst = gr.vector_sink_s() + dst = blocks.vector_sink_s() self.tb.connect(src, srcv, op, rhs, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data) def help_const_ii(self, src_data, exp_data, op): - src = gr.vector_source_i(src_data) + src = blocks.vector_source_i(src_data) srcv = blocks.stream_to_vector(gr.sizeof_int, len(src_data)) rhs = blocks.vector_to_stream(gr.sizeof_int, len(src_data)) - dst = gr.vector_sink_i() + dst = blocks.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 help_const_ff(self, src_data, exp_data, op): - src = gr.vector_source_f(src_data) + src = blocks.vector_source_f(src_data) srcv = blocks.stream_to_vector(gr.sizeof_float, len(src_data)) rhs = blocks.vector_to_stream(gr.sizeof_float, len(src_data)) - dst = gr.vector_sink_f() + dst = blocks.vector_sink_f() self.tb.connect(src, srcv, op, rhs, dst) self.tb.run() result_data = dst.data() self.assertEqual(exp_data, result_data) def help_const_cc(self, src_data, exp_data, op): - src = gr.vector_source_c(src_data) + src = blocks.vector_source_c(src_data) srcv = blocks.stream_to_vector(gr.sizeof_gr_complex, len(src_data)) rhs = blocks.vector_to_stream(gr.sizeof_gr_complex, len(src_data)) - dst = gr.vector_sink_c() + dst = blocks.vector_sink_c() self.tb.connect(src, srcv, op, rhs, dst) self.tb.run() result_data = dst.data() diff --git a/gr-blocks/python/qa_argmax.py b/gr-blocks/python/qa_argmax.py index ec82b71cd4..2fc8641d16 100644 --- a/gr-blocks/python/qa_argmax.py +++ b/gr-blocks/python/qa_argmax.py @@ -39,20 +39,20 @@ class test_arg_max(gr_unittest.TestCase): 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) + src1 = blocks.vector_source_f(src1_data) s2v1 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data)) tb.connect(src1, s2v1) - src2 = gr.vector_source_f(src2_data) + src2 = blocks.vector_source_f(src2_data) s2v2 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data)) tb.connect(src2, s2v2) - src3 = gr.vector_source_f(src3_data) + src3 = blocks.vector_source_f(src3_data) s2v3 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data)) tb.connect(src3, s2v3) - dst1 = gr.vector_sink_s() - dst2 = gr.vector_sink_s() + dst1 = blocks.vector_sink_s() + dst2 = blocks.vector_sink_s() argmax = blocks.argmax_fs(len(src1_data)) tb.connect(s2v1, (argmax, 0)) diff --git a/gr-blocks/python/qa_bin_statistics.py b/gr-blocks/python/qa_bin_statistics.py index 666f7c0d68..45d5105eb2 100755 --- a/gr-blocks/python/qa_bin_statistics.py +++ b/gr-blocks/python/qa_bin_statistics.py @@ -120,7 +120,7 @@ class test_bin_statistics(gr_unittest.TestCase): 13, 14, 15, 16 )]) - src = gr.vector_source_f(src_data, False) + src = blocks.vector_source_f(src_data, False) s2v = blocks.stream_to_vector(gr.sizeof_float, vlen) stats = blocks.bin_statistics_f(vlen, msgq, tune, tune_delay, dwell_delay) self.tb.connect(src, s2v, stats) @@ -148,7 +148,7 @@ class test_bin_statistics(gr_unittest.TestCase): expected_results = tuple([float(x) for x in ( 9, 10, 11, 12)]) - src = gr.vector_source_f(src_data, False) + src = blocks.vector_source_f(src_data, False) s2v = blocks.stream_to_vector(gr.sizeof_float, vlen) stats = blocks.bin_statistics_f(vlen, msgq, tune, tune_delay, dwell_delay) self.tb.connect(src, s2v, stats) @@ -178,7 +178,7 @@ class test_bin_statistics(gr_unittest.TestCase): expected_results = tuple([float(x) for x in ( 9, 10, 11, 12)]) - src = gr.vector_source_f(src_data, False) + src = blocks.vector_source_f(src_data, False) s2v = blocks.stream_to_vector(gr.sizeof_float, vlen) stats = blocks.bin_statistics_f(vlen, msgq, tune, tune_delay, dwell_delay) self.tb.connect(src, s2v, stats) @@ -210,7 +210,7 @@ class test_bin_statistics(gr_unittest.TestCase): expected_results = tuple([float(x) for x in ( 9, 10, 11, 12)]) - src = gr.vector_source_f(src_data, False) + src = blocks.vector_source_f(src_data, False) s2v = blocks.stream_to_vector(gr.sizeof_float, vlen) stats = blocks.bin_statistics_f(vlen, msgq, tune, tune_delay, dwell_delay) self.tb.connect(src, s2v, stats) diff --git a/gr-blocks/python/qa_block_gateway.py b/gr-blocks/python/qa_block_gateway.py new file mode 100644 index 0000000000..20a2660cba --- /dev/null +++ b/gr-blocks/python/qa_block_gateway.py @@ -0,0 +1,256 @@ +# +# Copyright 2011-2013 Free Software Foundation, Inc. +# +# This file is part of GNU Radio +# +# GNU Radio is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3, or (at your option) +# any later version. +# +# GNU Radio is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Radio; see the file COPYING. If not, write to +# the Free Software Foundation, Inc., 51 Franklin Street, +# Boston, MA 02110-1301, USA. +# + +from gnuradio import gr, gr_unittest +import pmt +import numpy +import blocks_swig as blocks + +class add_2_f32_1_f32(gr.sync_block): + def __init__(self): + gr.sync_block.__init__( + self, + name = "add 2 f32", + in_sig = [numpy.float32, numpy.float32], + out_sig = [numpy.float32], + ) + + def work(self, input_items, output_items): + output_items[0][:] = input_items[0] + input_items[1] + return len(output_items[0]) + +class add_2_fc32_1_fc32(gr.sync_block): + def __init__(self): + gr.sync_block.__init__( + self, + name = "add 2 fc32", + in_sig = [numpy.complex64, numpy.complex64], + out_sig = [numpy.complex64], + ) + + def work(self, input_items, output_items): + output_items[0][:] = input_items[0] + input_items[1] + return len(output_items[0]) + +class convolve(gr.sync_block): + """ + A demonstration using block history to properly perform a convolution. + """ + def __init__(self): + gr.sync_block.__init__( + self, + name = "convolve", + in_sig = [numpy.float32], + out_sig = [numpy.float32] + ) + self._taps = [1, 0, 0, 0] + self.set_history(len(self._taps)) + + def work(self, input_items, output_items): + output_items[0][:] = numpy.convolve(input_items[0], self._taps, mode='valid') + return len(output_items[0]) + +class decim2x(gr.decim_block): + def __init__(self): + gr.decim_block.__init__( + self, + name = "decim2x", + in_sig = [numpy.float32], + out_sig = [numpy.float32], + decim = 2 + ) + + def work(self, input_items, output_items): + output_items[0][:] = input_items[0][::2] + return len(output_items[0]) + +class interp2x(gr.interp_block): + def __init__(self): + gr.interp_block.__init__( + self, + name = "interp2x", + in_sig = [numpy.float32], + out_sig = [numpy.float32], + interp = 2 + ) + + def work(self, input_items, output_items): + output_items[0][1::2] = input_items[0] + output_items[0][::2] = input_items[0] + return len(output_items[0]) + +class tag_source(gr.sync_block): + def __init__(self): + gr.sync_block.__init__( + self, + name = "tag source", + in_sig = None, + out_sig = [numpy.float32], + ) + + def work(self, input_items, output_items): + num_output_items = len(output_items[0]) + + #put code here to fill the output items... + + #make a new tag on the middle element every time work is called + count = self.nitems_written(0) + num_output_items/2 + key = pmt.string_to_symbol("example_key") + value = pmt.string_to_symbol("example_value") + self.add_item_tag(0, count, key, value) + + return num_output_items + +class tag_sink(gr.sync_block): + def __init__(self): + gr.sync_block.__init__( + self, + name = "tag sink", + in_sig = [numpy.float32], + out_sig = None, + ) + self.key = None + + def work(self, input_items, output_items): + num_input_items = len(input_items[0]) + + #put code here to process the input items... + + #print all the tags received in this work call + nread = self.nitems_read(0) + tags = self.get_tags_in_range(0, nread, nread+num_input_items) + for tag in tags: + #print tag.offset + #print pmt.symbol_to_string(tag.key) + #print pmt.symbol_to_string(tag.value) + self.key = pmt.symbol_to_string(tag.key) + + return num_input_items + +class fc32_to_f32_2(gr.sync_block): + def __init__(self): + gr.sync_block.__init__( + self, + name = "fc32_to_f32_2", + in_sig = [numpy.complex64], + out_sig = [(numpy.float32, 2)], + ) + + def work(self, input_items, output_items): + output_items[0][::,0] = numpy.real(input_items[0]) + output_items[0][::,1] = numpy.imag(input_items[0]) + return len(output_items[0]) + +class vector_to_stream(gr.interp_block): + def __init__(self, itemsize, nitems_per_block): + gr.interp_block.__init__( + self, + name = "vector_to_stream", + in_sig = [(itemsize, nitems_per_block)], + out_sig = [itemsize], + interp = nitems_per_block + ) + self.block_size = nitems_per_block + + def work(self, input_items, output_items): + n = 0 + for i in xrange(len(input_items[0])): + for j in xrange(self.block_size): + output_items[0][n] = input_items[0][i][j] + n += 1 + + return len(output_items[0]) + +class test_block_gateway(gr_unittest.TestCase): + + def test_add_f32(self): + tb = gr.top_block() + src0 = blocks.vector_source_f([1, 3, 5, 7, 9], False) + src1 = blocks.vector_source_f([0, 2, 4, 6, 8], False) + adder = add_2_f32_1_f32() + sink = blocks.vector_sink_f() + tb.connect((src0, 0), (adder, 0)) + tb.connect((src1, 0), (adder, 1)) + tb.connect(adder, sink) + tb.run() + self.assertEqual(sink.data(), (1, 5, 9, 13, 17)) + + def test_add_fc32(self): + tb = gr.top_block() + src0 = blocks.vector_source_c([1, 3j, 5, 7j, 9], False) + src1 = blocks.vector_source_c([0, 2j, 4, 6j, 8], False) + adder = add_2_fc32_1_fc32() + sink = blocks.vector_sink_c() + tb.connect((src0, 0), (adder, 0)) + tb.connect((src1, 0), (adder, 1)) + tb.connect(adder, sink) + tb.run() + self.assertEqual(sink.data(), (1, 5j, 9, 13j, 17)) + + 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_tags(self): + src = tag_source() + sink = tag_sink() + head = blocks.head(gr.sizeof_float, 50000) #should be enough items to get a tag through + tb = gr.top_block() + tb.connect(src, head, sink) + tb.run() + self.assertEqual(sink.key, "example_key") + + def test_fc32_to_f32_2(self): + tb = gr.top_block() + src = blocks.vector_source_c([1+2j, 3+4j, 5+6j, 7+8j, 9+10j], False) + convert = fc32_to_f32_2() + v2s = vector_to_stream(numpy.float32, 2) + sink = blocks.vector_sink_f() + tb.connect(src, convert, v2s, sink) + tb.run() + self.assertEqual(sink.data(), (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)) + +if __name__ == '__main__': + gr_unittest.run(test_block_gateway, "test_block_gateway.xml") + diff --git a/gr-blocks/python/qa_boolean_operators.py b/gr-blocks/python/qa_boolean_operators.py index 5572f60acb..8755dad2fc 100755 --- a/gr-blocks/python/qa_boolean_operators.py +++ b/gr-blocks/python/qa_boolean_operators.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# Copyright 2004,2007,2008,2010 Free Software Foundation, Inc. +# Copyright 2004,2007,2008,2010,2013 Free Software Foundation, Inc. # # This file is part of GNU Radio # @@ -21,7 +21,7 @@ # from gnuradio import gr, gr_unittest -import blocks_swig +import blocks_swig as blocks class test_boolean_operators (gr_unittest.TestCase): @@ -33,9 +33,9 @@ class test_boolean_operators (gr_unittest.TestCase): def help_ss (self, src_data, exp_data, op): for s in zip (range (len (src_data)), src_data): - src = gr.vector_source_s (s[1]) + src = blocks.vector_source_s (s[1]) self.tb.connect (src, (op, s[0])) - dst = gr.vector_sink_s () + dst = blocks.vector_sink_s () self.tb.connect (op, dst) self.tb.run () result_data = dst.data () @@ -43,9 +43,9 @@ class test_boolean_operators (gr_unittest.TestCase): def help_bb (self, src_data, exp_data, op): for s in zip (range (len (src_data)), src_data): - src = gr.vector_source_b (s[1]) + src = blocks.vector_source_b (s[1]) self.tb.connect (src, (op, s[0])) - dst = gr.vector_sink_b () + dst = blocks.vector_sink_b () self.tb.connect (op, dst) self.tb.run () result_data = dst.data () @@ -53,9 +53,9 @@ class test_boolean_operators (gr_unittest.TestCase): 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]) + src = blocks.vector_source_i (s[1]) self.tb.connect (src, (op, s[0])) - dst = gr.vector_sink_i () + dst = blocks.vector_sink_i () self.tb.connect (op, dst) self.tb.run () result_data = dst.data () @@ -65,7 +65,7 @@ class test_boolean_operators (gr_unittest.TestCase): src1_data = (1, 2, 3, 0x5004, 0x1150) src2_data = (8, 2, 1 , 0x0508, 0x1105) expected_result = (9, 0, 2, 0x550C, 0x0055) - op = blocks_swig.xor_ss () + op = blocks.xor_ss () self.help_ss ((src1_data, src2_data), expected_result, op) @@ -73,7 +73,7 @@ class test_boolean_operators (gr_unittest.TestCase): src1_data = (1, 2, 3, 4, 0x50) src2_data = (8, 2, 1 , 8, 0x05) expected_result = (9, 0, 2, 0xC, 0x55) - op = blocks_swig.xor_bb () + op = blocks.xor_bb () self.help_bb ((src1_data, src2_data), expected_result, op) @@ -82,7 +82,7 @@ class test_boolean_operators (gr_unittest.TestCase): src1_data = (1, 2, 3, 0x5000004, 0x11000050) src2_data = (8, 2, 1 , 0x0500008, 0x11000005) expected_result = (9, 0, 2, 0x550000C, 0x00000055) - op = blocks_swig.xor_ii () + op = blocks.xor_ii () self.help_ii ((src1_data, src2_data), expected_result, op) @@ -91,7 +91,7 @@ class test_boolean_operators (gr_unittest.TestCase): src1_data = (1, 2, 3, 0x5004, 0x1150) src2_data = (8, 2, 1 , 0x0508, 0x1105) expected_result = (0, 2, 1, 0x0000, 0x1100) - op = blocks_swig.and_ss () + op = blocks.and_ss () self.help_ss ((src1_data, src2_data), expected_result, op) @@ -100,7 +100,7 @@ class test_boolean_operators (gr_unittest.TestCase): src2_data = (8, 2, 2, 1, 0x08, 0x05) src3_data = (8, 2, 1, 1, 0x08, 0x05) expected_result = (0, 2, 0, 1, 0x00, 0x00) - op = blocks_swig.and_bb () + op = blocks.and_bb () self.help_bb ((src1_data, src2_data, src3_data), expected_result, op) @@ -108,16 +108,16 @@ class test_boolean_operators (gr_unittest.TestCase): src1_data = (1, 2, 3, 0x50005004, 0x11001150) src2_data = (8, 2, 1 , 0x05000508, 0x11001105) expected_result = (0, 2, 1, 0x00000000, 0x11001100) - op = blocks_swig.and_ii () + op = blocks.and_ii () self.help_ii ((src1_data, src2_data), expected_result, op) 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() + src = blocks.vector_source_s(src_data) + op = blocks.and_const_ss (0x55AA) + dst = blocks.vector_sink_s() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(dst.data(), expected_result) @@ -125,9 +125,9 @@ class test_boolean_operators (gr_unittest.TestCase): def test_and_const_bb (self): src_data = (1, 2, 3, 0x50, 0x11) expected_result = (0, 2, 2, 0x00, 0x00) - src = gr.vector_source_b(src_data) - op = blocks_swig.and_const_bb (0xAA) - dst = gr.vector_sink_b() + src = blocks.vector_source_b(src_data) + op = blocks.and_const_bb (0xAA) + dst = blocks.vector_sink_b() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(dst.data(), expected_result) @@ -136,9 +136,9 @@ class test_boolean_operators (gr_unittest.TestCase): 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() + src = blocks.vector_source_i(src_data) + op = blocks.and_const_ii (0x55AA) + dst = blocks.vector_sink_i() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(dst.data(), expected_result) @@ -148,7 +148,7 @@ class test_boolean_operators (gr_unittest.TestCase): src1_data = (1, 2, 3, 0x5004, 0x1150) src2_data = (8, 2, 1 , 0x0508, 0x1105) expected_result = (9, 2, 3, 0x550C, 0x1155) - op = blocks_swig.or_ss () + op = blocks.or_ss () self.help_ss ((src1_data, src2_data), expected_result, op) @@ -157,7 +157,7 @@ class test_boolean_operators (gr_unittest.TestCase): src2_data = (8, 2, 2, 1 , 0x08, 0x05) src3_data = (8, 2, 1, 1 , 0x08, 0x05) expected_result = (9, 2, 3, 3, 0x0C, 0x55) - op = blocks_swig.or_bb () + op = blocks.or_bb () self.help_bb ((src1_data, src2_data, src3_data), expected_result, op) @@ -165,28 +165,28 @@ class test_boolean_operators (gr_unittest.TestCase): src1_data = (1, 2, 3, 0x50005004, 0x11001150) src2_data = (8, 2, 1 , 0x05000508, 0x11001105) expected_result = (9, 2, 3, 0x5500550C, 0x11001155) - op = blocks_swig.or_ii () + op = blocks.or_ii () self.help_ii ((src1_data, src2_data), expected_result, op) def test_not_ss (self): src1_data = (1, 2, 3, 0x5004, 0x1150) expected_result = (~1, ~2, ~3, ~0x5004, ~0x1150) - op = blocks_swig.not_ss () + op = blocks.not_ss () self.help_ss ((((src1_data),)), expected_result, op) def test_not_bb (self): src1_data = (1, 2, 2, 3, 0x04, 0x50) expected_result = (0xFE, 0xFD, 0xFD, 0xFC, 0xFB, 0xAF) - op = blocks_swig.not_bb () + op = blocks.not_bb () self.help_bb (((src1_data), ), expected_result, op) def test_not_ii (self): src1_data = (1, 2, 3, 0x50005004, 0x11001150) expected_result = (~1 , ~2, ~3, ~0x50005004, ~0x11001150) - op = blocks_swig.not_ii () + op = blocks.not_ii () self.help_ii (((src1_data),), expected_result, op) diff --git a/gr-blocks/python/qa_burst_tagger.py b/gr-blocks/python/qa_burst_tagger.py index 52d688d103..9923d2a368 100644 --- a/gr-blocks/python/qa_burst_tagger.py +++ b/gr-blocks/python/qa_burst_tagger.py @@ -35,8 +35,8 @@ class test_burst_tagger(gr_unittest.TestCase): 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) + src = blocks.vector_source_i(src_data) + trg = blocks.vector_source_s(trg_data) op = blocks.burst_tagger(gr.sizeof_int) snk = blocks.tag_debug(gr.sizeof_int, "burst tagger QA") self.tb.connect(src, (op,0)) diff --git a/gr-blocks/python/qa_conjugate.py b/gr-blocks/python/qa_conjugate.py index 1808aa9c0b..7aab2e70a7 100644 --- a/gr-blocks/python/qa_conjugate.py +++ b/gr-blocks/python/qa_conjugate.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# Copyright 2012 Free Software Foundation, Inc. +# Copyright 2012,2013 Free Software Foundation, Inc. # # This file is part of GNU Radio # @@ -21,7 +21,7 @@ # from gnuradio import gr, gr_unittest -import blocks_swig +import blocks_swig as blocks class test_conjugate (gr_unittest.TestCase): @@ -40,9 +40,9 @@ class test_conjugate (gr_unittest.TestCase): 2+2j, 1+1j, 2-2j, 1-1j, 0-0j) - src = gr.vector_source_c(src_data) - op = blocks_swig.conjugate_cc () - dst = gr.vector_sink_c () + src = blocks.vector_source_c(src_data) + op = blocks.conjugate_cc () + dst = blocks.vector_sink_c () self.tb.connect(src, op) self.tb.connect(op, dst) diff --git a/gr-blocks/python/qa_copy.py b/gr-blocks/python/qa_copy.py index 012d790609..04f6454231 100755 --- a/gr-blocks/python/qa_copy.py +++ b/gr-blocks/python/qa_copy.py @@ -46,7 +46,7 @@ class test_copy(gr_unittest.TestCase): src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) expected_result = () src = blocks.vector_source_b(src_data) - op = gr.copy(gr.sizeof_char) + op = blocks.copy(gr.sizeof_char) op.set_enabled(False) dst = blocks.vector_sink_b() self.tb.connect(src, op, dst) diff --git a/gr-blocks/python/qa_cpp_py_binding.py b/gr-blocks/python/qa_cpp_py_binding.py new file mode 100755 index 0000000000..950f21b9f7 --- /dev/null +++ b/gr-blocks/python/qa_cpp_py_binding.py @@ -0,0 +1,174 @@ +#!/usr/bin/env python +# +# Copyright 2012,2013 Free Software Foundation, Inc. +# +# This file is part of GNU Radio +# +# GNU Radio is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3, or (at your option) +# any later version. +# +# GNU Radio is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Radio; see the file COPYING. If not, write to +# the Free Software Foundation, Inc., 51 Franklin Street, +# Boston, MA 02110-1301, USA. +# + +# +# This program tests mixed python and c++ ctrlport exports in a single app +# + +import Ice +import sys, time, random, numpy +from gnuradio import gr, gr_unittest + +from gnuradio.ctrlport import GNURadio +from gnuradio import ctrlport +import os + +import blocks_swig as blocks + +def get1(): + return "success" + +def get2(): + return "failure" + +class inc_class: + def __init__(self): + self.val = 1 + def pp(self): + self.val = self.val+1 + return self.val + +get3 = inc_class() + +def get4(): + random.seed(0) + rv = random.random() + return rv + +def get5(): + numpy.random.seed(0) + samp_t = numpy.random.randn(24)+1j*numpy.random.randn(24); + samp_f = numpy.fft.fft(samp_t); + log_pow_f = 20*numpy.log10(numpy.abs(samp_f)) + rv = list(log_pow_f) + return rv; + +def get6(): + numpy.random.seed(0) + samp_t = numpy.random.randn(1024)+1j*numpy.random.randn(1024); + rv = list(samp_t) + return rv; + +class test_cpp_py_binding(gr_unittest.TestCase): + + def setUp(self): + self.tb = gr.top_block() + os.environ['GR_CONF_CONTROLPORT_ON'] = 'True' + + def tearDown(self): + self.tb = None + + def test_001(self): + v1 = gr.RPC_get_string("pyland", "v1", "unit_1_string", + "Python Exported String", "", "", "", + gr.DISPNULL) + v1.activate(get1) + + v2 = gr.RPC_get_string("pyland", "v2", "unit_2_string", + "Python Exported String", "", "", "", + gr.DISPNULL) + v2.activate(get2) + + v3 = gr.RPC_get_int("pyland", "v3", "unit_3_int", + "Python Exported Int", 0, 100, 1, + gr.DISPNULL) + v3.activate(get3.pp) + + v4 = gr.RPC_get_double("pyland", "time", "unit_4_time_double", + "Python Exported Double", 0, 1000, 1, + gr.DISPNULL) + v4.activate(get4) + + v5 = gr.RPC_get_vector_float("pyland", "fvec", "unit_5_float_vector", + "Python Exported Float Vector", [], [], [], + gr.DISPTIME | gr.DISPOPTCPLX) + v5.activate(get5) + + v6 = gr.RPC_get_vector_gr_complex("pyland", "cvec", "unit_6_gr_complex_vector", + "Python Exported Complex Vector", [], [], [], + gr.DISPXY | gr.DISPOPTSCATTER) + v6.activate(get6) + + # print some variables locally + val = get1() + rval = v1.get() + self.assertEqual(val, rval) + + val = get2() + rval = v2.get() + self.assertEqual(val, rval) + + val = get3.pp() + rval = v3.get() + self.assertEqual(val+1, rval) + + val = get4() + rval = v4.get() + self.assertEqual(val, rval) + + val = get5() + rval = v5.get() + self.assertComplexTuplesAlmostEqual(val, rval, 5) + + val = get6() + rval = v6.get() + self.assertComplexTuplesAlmostEqual(val, rval, 5) + + def test_002(self): + data = range(1,9) + + self.src = blocks.vector_source_c(data) + self.p1 = gr.ctrlport_probe_c("aaa","C++ exported variable") + self.p2 = gr.ctrlport_probe_c("bbb","C++ exported variable") + probe_name = self.p2.alias() + + self.tb.connect(self.src, self.p1) + self.tb.connect(self.src, self.p2) + self.tb.start() + + # Probes return complex values as list of floats with re, im + # Imaginary parts of this data set are 0. + expected_result = [1, 0, 2, 0, 3, 0, 4, 0, + 5, 0, 6, 0, 7, 0, 8, 0] + + # Make sure we have time for flowgraph to run + time.sleep(0.1) + + # Get available endpoint + ep = gr.rpcmanager_get().endpoints()[0] + + # Initialize a simple Ice client from endpoint + ic = Ice.initialize(sys.argv) + base = ic.stringToProxy(ep) + radio = GNURadio.ControlPortPrx.checkedCast(base) + + # Get all exported knobs + ret = radio.get([probe_name + "::bbb"]) + for name in ret.keys(): + result = ret[name].value + self.assertEqual(result, expected_result) + + self.tb.stop() + +if __name__ == '__main__': + gr_unittest.run(test_cpp_py_binding, "test_cpp_py_binding.xml") + diff --git a/gr-blocks/python/qa_cpp_py_binding_set.py b/gr-blocks/python/qa_cpp_py_binding_set.py new file mode 100755 index 0000000000..28ddc48b2f --- /dev/null +++ b/gr-blocks/python/qa_cpp_py_binding_set.py @@ -0,0 +1,152 @@ +#!/usr/bin/env python +# +# Copyright 2012,2013 Free Software Foundation, Inc. +# +# This file is part of GNU Radio +# +# GNU Radio is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3, or (at your option) +# any later version. +# +# GNU Radio is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Radio; see the file COPYING. If not, write to +# the Free Software Foundation, Inc., 51 Franklin Street, +# Boston, MA 02110-1301, USA. +# + +# +# This program tests mixed python and c++ GRCP sets in a single app +# + +import Ice +import sys, time, random, numpy +from gnuradio import gr, gr_unittest + +from gnuradio.ctrlport import GNURadio +from gnuradio import ctrlport +import os + +import blocks_swig as blocks + +class inc_class: + def __init__(self,val): + self.val = val; + + def _get(self): + #print "returning get (val = %s)"%(str(self.val)); + return self.val; + + def _set(self,val): + #print "updating val to %s"%(str(val)); + self.val = val; + return; + +getset1 = inc_class(10); +getset2 = inc_class(100.0); +getset3 = inc_class("test"); + +class test_cpp_py_binding_set(gr_unittest.TestCase): + def setUp(self): + self.tb = gr.top_block() + os.environ['GR_CONF_CONTROLPORT_ON'] = 'True' + + def tearDown(self): + self.tb = None + + def test_001(self): + + g1 = gr.RPC_get_int("pyland", "v1", "unit_1_int", + "Python Exported Int", 0, 100, 10, + gr.DISPNULL) + g1.activate(getset1._get) + s1 = gr.RPC_get_int("pyland", "v1", "unit_1_int", + "Python Exported Int", 0, 100, 10, + gr.DISPNULL) + s1.activate(getset1._set) + time.sleep(0.01) + + # test int variables + getset1._set(21) + val = getset1._get() + rval = g1.get() + self.assertEqual(val, rval) + + g2 = gr.RPC_get_float("pyland", "v2", "unit_2_float", + "Python Exported Float", -100, 1000.0, 100.0, + gr.DISPNULL) + g2.activate(getset2._get) + s2 = gr.RPC_get_float("pyland", "v2", "unit_2_float", + "Python Exported Float", -100, 1000.0, 100.0, + gr.DISPNULL) + s2.activate(getset2._set) + time.sleep(0.01) + + # test float variables + getset2._set(123.456) + val = getset2._get() + rval = g2.get() + self.assertAlmostEqual(val, rval, 4) + + g3 = gr.RPC_get_string("pyland", "v3", "unit_3_string", + "Python Exported String", "", "", "", + gr.DISPNULL) + g3.activate(getset3._get) + s3 = gr.RPC_get_string("pyland", "v3", "unit_3_string", + "Python Exported String", "", "", "", + gr.DISPNULL) + s3.activate(getset3._set) + time.sleep(0.01) + + # test string variables + getset3._set("third test") + val = getset3._get() + rval = g3.get() + self.assertEqual(val, rval) + + + def test_002(self): + data = range(1, 10) + + self.src = blocks.vector_source_c(data, True) + self.p = blocks.nop(gr.sizeof_gr_complex) + self.p.set_ctrlport_test(0); + probe_info = self.p.alias() + + self.tb.connect(self.src, self.p) + + # Get available endpoint + ep = gr.rpcmanager_get().endpoints()[0] + + # Initialize a simple Ice client from endpoint + ic = Ice.initialize(sys.argv) + base = ic.stringToProxy(ep) + radio = GNURadio.ControlPortPrx.checkedCast(base) + + self.tb.start() + + # Make sure we have time for flowgraph to run + time.sleep(0.1) + + # Get all exported knobs + key_name_test = probe_info+"::test" + ret = radio.get([key_name_test,]) + + ret[key_name_test].value = 10 + radio.set({key_name_test: ret[key_name_test]}) + + ret = radio.get([]) + result_test = ret[key_name_test].value + self.assertEqual(result_test, 10) + + self.tb.stop() + self.tb.wait() + +if __name__ == '__main__': + gr_unittest.run(test_cpp_py_binding_set, "test_cpp_py_binding_set.xml") + diff --git a/gr-blocks/python/qa_delay.py b/gr-blocks/python/qa_delay.py index 031cadb2d7..44b87c14ae 100755 --- a/gr-blocks/python/qa_delay.py +++ b/gr-blocks/python/qa_delay.py @@ -37,9 +37,9 @@ class test_delay(gr_unittest.TestCase): src_data = [float(x) for x in range(0, 100)] expected_result = tuple(delta_t*[0.0] + src_data) - src = gr.vector_source_f(src_data) + src = blocks.vector_source_f(src_data) op = blocks.delay(gr.sizeof_float, delta_t) - dst = gr.vector_sink_f() + dst = blocks.vector_sink_f() tb.connect(src, op, dst) tb.run() @@ -52,9 +52,9 @@ class test_delay(gr_unittest.TestCase): src_data = [float(x) for x in range(0, 100)] expected_result = tuple(delta_t*[0.0] + src_data) - src = gr.vector_source_f(src_data) + src = blocks.vector_source_f(src_data) op = blocks.delay(gr.sizeof_float, delta_t) - dst = gr.vector_sink_f() + dst = blocks.vector_sink_f() tb.connect(src, op, dst) tb.run() diff --git a/gr-blocks/python/qa_file_metadata.py b/gr-blocks/python/qa_file_metadata.py index cf7a075f42..3112ea69b0 100644 --- a/gr-blocks/python/qa_file_metadata.py +++ b/gr-blocks/python/qa_file_metadata.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# Copyright 2012 Free Software Foundation, Inc. +# Copyright 2012,2013 Free Software Foundation, Inc. # # This file is part of GNU Radio # @@ -54,7 +54,7 @@ class test_file_metadata(gr_unittest.TestCase): extras_str = pmt.serialize_str(extras) data = sig_source_c(samp_rate, 1000, 1, N) - src = gr.vector_source_c(data) + src = blocks.vector_source_c(data) fsnk = blocks.file_meta_sink(gr.sizeof_gr_complex, outfile, samp_rate, 1, blocks.GR_FILE_FLOAT, True, @@ -96,9 +96,9 @@ class test_file_metadata(gr_unittest.TestCase): # Test file metadata source src.rewind() fsrc = blocks.file_meta_source(outfile, False) - vsnk = gr.vector_sink_c() + vsnk = blocks.vector_sink_c() tsnk = blocks.tag_debug(gr.sizeof_gr_complex, "QA") - ssnk = gr.vector_sink_c() + ssnk = blocks.vector_sink_c() self.tb.disconnect(src, fsnk) self.tb.connect(fsrc, vsnk) self.tb.connect(fsrc, tsnk) @@ -133,7 +133,7 @@ class test_file_metadata(gr_unittest.TestCase): extras_str = pmt.serialize_str(extras) data = sig_source_c(samp_rate, 1000, 1, N) - src = gr.vector_source_c(data) + src = blocks.vector_source_c(data) fsnk = blocks.file_meta_sink(gr.sizeof_gr_complex, outfile, samp_rate, 1, blocks.GR_FILE_FLOAT, True, @@ -175,9 +175,9 @@ class test_file_metadata(gr_unittest.TestCase): # Test file metadata source src.rewind() fsrc = blocks.file_meta_source(outfile, False, detached, outfile_hdr) - vsnk = gr.vector_sink_c() + vsnk = blocks.vector_sink_c() tsnk = blocks.tag_debug(gr.sizeof_gr_complex, "QA") - ssnk = gr.vector_sink_c() + ssnk = blocks.vector_sink_c() self.tb.disconnect(src, fsnk) self.tb.connect(fsrc, vsnk) self.tb.connect(fsrc, tsnk) diff --git a/gr-blocks/python/qa_file_source_sink.py b/gr-blocks/python/qa_file_source_sink.py index 2898f760ec..cf3b512db0 100644 --- a/gr-blocks/python/qa_file_source_sink.py +++ b/gr-blocks/python/qa_file_source_sink.py @@ -38,12 +38,12 @@ class test_file_source_sink(gr_unittest.TestCase): expected_result = range(1000) filename = "tmp.32f" - src = gr.vector_source_f(src_data) + src = blocks.vector_source_f(src_data) snk = blocks.file_sink(gr.sizeof_float, filename) snk.set_unbuffered(True) src2 = blocks.file_source(gr.sizeof_float, filename) - snk2 = gr.vector_sink_f() + snk2 = blocks.vector_sink_f() self.tb.connect(src, snk) self.tb.run() @@ -65,7 +65,7 @@ class test_file_source_sink(gr_unittest.TestCase): fhandle0 = open(filename, "wb") fd0 = fhandle0.fileno() - src = gr.vector_source_f(src_data) + src = blocks.vector_source_f(src_data) snk = blocks.file_descriptor_sink(gr.sizeof_float, fd0) self.tb.connect(src, snk) @@ -76,7 +76,7 @@ class test_file_source_sink(gr_unittest.TestCase): fhandle1 = open(filename, "rb") fd1 = fhandle1.fileno() src2 = blocks.file_descriptor_source(gr.sizeof_float, fd1, False) - snk2 = gr.vector_sink_f() + snk2 = blocks.vector_sink_f() self.tb.disconnect(src, snk) self.tb.connect(src2, snk2) diff --git a/gr-blocks/python/qa_hier_block2.py b/gr-blocks/python/qa_hier_block2.py new file mode 100755 index 0000000000..f482fda8cf --- /dev/null +++ b/gr-blocks/python/qa_hier_block2.py @@ -0,0 +1,398 @@ +#!/usr/bin/env python + +from gnuradio import gr, gr_unittest +import blocks_swig as blocks +import numpy + +class add_ff(gr.sync_block): + def __init__(self): + gr.sync_block.__init__( + self, + name = "add_ff", + in_sig = [numpy.float32, numpy.float32], + out_sig = [numpy.float32], + ) + + def work(self, input_items, output_items): + output_items[0][:] = input_items[0] + input_items[1] + return len(output_items[0]) + +class multiply_const_ff(gr.sync_block): + def __init__(self, k): + gr.sync_block.__init__( + self, + name = "multiply_ff", + in_sig = [numpy.float32], + out_sig = [numpy.float32], + ) + self.k = k + + def work(self, input_items, output_items): + output_items[0][:] = map(lambda x: self.k*x, input_items[0]) + return len(output_items[0]) + +class test_hier_block2(gr_unittest.TestCase): + + def setUp(self): + pass + + def tearDown(self): + pass + + def test_001_make(self): + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + self.assertEqual("test_block", hblock.name()) + self.assertEqual(1, hblock.input_signature().max_streams()) + self.assertEqual(1, hblock.output_signature().min_streams()) + self.assertEqual(1, hblock.output_signature().max_streams()) + self.assertEqual(gr.sizeof_int, hblock.output_signature().sizeof_stream_item(0)) + + def test_002_connect_input(self): + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + hblock.connect(hblock, nop1) + + def test_004_connect_output(self): + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + hblock.connect(nop1, hblock) + + def test_005_connect_output_in_use(self): + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + nop2 = blocks.nop(gr.sizeof_int) + hblock.connect(nop1, hblock) + self.assertRaises(ValueError, + lambda: hblock.connect(nop2, hblock)) + + def test_006_connect_invalid_src_port_neg(self): + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + self.assertRaises(ValueError, + lambda: hblock.connect((hblock, -1), nop1)) + + def test_005_connect_invalid_src_port_exceeds(self): + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + self.assertRaises(ValueError, + lambda: hblock.connect((hblock, 1), nop1)) + + def test_007_connect_invalid_dst_port_neg(self): + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + nop2 = blocks.nop(gr.sizeof_int) + self.assertRaises(ValueError, + lambda: hblock.connect(nop1, (nop2, -1))) + + def test_008_connect_invalid_dst_port_exceeds(self): + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.null_sink(gr.sizeof_int) + nop2 = blocks.null_sink(gr.sizeof_int) + self.assertRaises(ValueError, + lambda: hblock.connect(nop1, (nop2, 1))) + + def test_009_check_topology(self): + hblock = gr.top_block("test_block") + hblock.check_topology(0, 0) + + 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_012_disconnect_input(self): + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + hblock.connect(hblock, nop1) + hblock.disconnect(hblock, nop1) + + def test_013_disconnect_input_not_connected(self): + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + nop2 = blocks.nop(gr.sizeof_int) + hblock.connect(hblock, nop1) + self.assertRaises(ValueError, + lambda: hblock.disconnect(hblock, nop2)) + + def test_014_disconnect_input_neg(self): + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + hblock.connect(hblock, nop1) + self.assertRaises(ValueError, + lambda: hblock.disconnect((hblock, -1), nop1)) + + def test_015_disconnect_input_exceeds(self): + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + hblock.connect(hblock, nop1) + self.assertRaises(ValueError, + lambda: hblock.disconnect((hblock, 1), nop1)) + + def test_016_disconnect_output(self): + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + hblock.connect(nop1, hblock) + hblock.disconnect(nop1, hblock) + + def test_017_disconnect_output_not_connected(self): + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + nop2 = blocks.nop(gr.sizeof_int) + hblock.connect(nop1, hblock) + self.assertRaises(ValueError, + lambda: hblock.disconnect(nop2, hblock)) + + def test_018_disconnect_output_neg(self): + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + hblock.connect(hblock, nop1) + self.assertRaises(ValueError, + lambda: hblock.disconnect(nop1, (hblock, -1))) + + def test_019_disconnect_output_exceeds(self): + hblock = gr.hier_block2("test_block", + gr.io_signature(1,1,gr.sizeof_int), + gr.io_signature(1,1,gr.sizeof_int)) + nop1 = blocks.nop(gr.sizeof_int) + hblock.connect(nop1, hblock) + self.assertRaises(ValueError, + lambda: hblock.disconnect(nop1, (hblock, 1))) + + 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_021_connect_single(self): + hblock = gr.top_block("test_block") + blk = gr.hier_block2("block", + gr.io_signature(0, 0, 0), + gr.io_signature(0, 0, 0)) + hblock.connect(blk) + + def test_022_connect_single_with_ports(self): + hblock = gr.top_block("test_block") + blk = gr.hier_block2("block", + gr.io_signature(1, 1, 1), + gr.io_signature(1, 1, 1)) + self.assertRaises(ValueError, + lambda: hblock.connect(blk)) + + def test_023_connect_single_twice(self): + hblock = gr.top_block("test_block") + blk = gr.hier_block2("block", + gr.io_signature(0, 0, 0), + gr.io_signature(0, 0, 0)) + hblock.connect(blk) + self.assertRaises(ValueError, + lambda: hblock.connect(blk)) + + def test_024_disconnect_single(self): + hblock = gr.top_block("test_block") + blk = gr.hier_block2("block", + gr.io_signature(0, 0, 0), + gr.io_signature(0, 0, 0)) + hblock.connect(blk) + hblock.disconnect(blk) + + def test_025_disconnect_single_not_connected(self): + hblock = gr.top_block("test_block") + blk = gr.hier_block2("block", + gr.io_signature(0, 0, 0), + gr.io_signature(0, 0, 0)) + self.assertRaises(ValueError, + lambda: hblock.disconnect(blk)) + + def test_026_run_single(self): + expected_data = (1.0,) + tb = gr.top_block("top_block") + hb = gr.hier_block2("block", + gr.io_signature(0, 0, 0), + gr.io_signature(0, 0, 0)) + src = blocks.vector_source_f(expected_data) + dst = blocks.vector_sink_f() + hb.connect(src, dst) + tb.connect(hb) + tb.run() + self.assertEquals(expected_data, dst.data()) + + def test_027a_internally_unconnected_input(self): + tb = gr.top_block() + hb = gr.hier_block2("block", + gr.io_signature(1, 1, 1), + gr.io_signature(1, 1, 1)) + hsrc = blocks.vector_source_b([1,]) + hb.connect(hsrc, hb) # wire output internally + src = blocks.vector_source_b([1, ]) + dst = blocks.vector_sink_b() + tb.connect(src, hb, dst) # hb's input is not connected internally + self.assertRaises(RuntimeError, + lambda: tb.run()) + + def test_027b_internally_unconnected_output(self): + tb = gr.top_block() + + hb = gr.hier_block2("block", + gr.io_signature(1, 1, 1), + gr.io_signature(1, 1, 1)) + hdst = blocks.vector_sink_b() + hb.connect(hb, hdst) # wire input internally + src = blocks.vector_source_b([1, ]) + dst = blocks.vector_sink_b() + tb.connect(src, hb, dst) # hb's output is not connected internally + self.assertRaises(RuntimeError, + lambda: tb.run()) + + def test_027c_fully_unconnected_output(self): + tb = gr.top_block() + hb = gr.hier_block2("block", + gr.io_signature(1, 1, 1), + gr.io_signature(1, 1, 1)) + hsrc = blocks.vector_sink_b() + hb.connect(hb, hsrc) # wire input internally + src = blocks.vector_source_b([1, ]) + dst = blocks.vector_sink_b() + tb.connect(src, hb) # hb's output is not connected internally or externally + self.assertRaises(RuntimeError, + lambda: tb.run()) + + def test_027d_fully_unconnected_input(self): + tb = gr.top_block() + hb = gr.hier_block2("block", + gr.io_signature(1, 1, 1), + gr.io_signature(1, 1, 1)) + hdst = blocks.vector_source_b([1,]) + hb.connect(hdst, hb) # wire output internally + dst = blocks.vector_sink_b() + tb.connect(hb, dst) # hb's input is not connected internally or externally + self.assertRaises(RuntimeError, + lambda: tb.run()) + + def test_028_singleton_reconfigure(self): + tb = gr.top_block() + hb = gr.hier_block2("block", + gr.io_signature(0, 0, 0), gr.io_signature(0, 0, 0)) + src = blocks.vector_source_b([1, ]) + dst = blocks.vector_sink_b() + hb.connect(src, dst) + tb.connect(hb) # Singleton connect + tb.lock() + tb.disconnect_all() + tb.connect(src, dst) + tb.unlock() + + def test_029_singleton_disconnect(self): + tb = gr.top_block() + src = blocks.vector_source_b([1, ]) + dst = blocks.vector_sink_b() + tb.connect(src, dst) + tb.disconnect(src) # Singleton disconnect + tb.connect(src, dst) + tb.run() + self.assertEquals(dst.data(), (1,)) + + def test_030_nested_input(self): + tb = gr.top_block() + src = blocks.vector_source_b([1,]) + hb1 = gr.hier_block2("hb1", + gr.io_signature(1, 1, gr.sizeof_char), + gr.io_signature(0, 0, 0)) + hb2 = gr.hier_block2("hb2", + gr.io_signature(1, 1, gr.sizeof_char), + gr.io_signature(0, 0, 0)) + dst = blocks.vector_sink_b() + tb.connect(src, hb1) + hb1.connect(hb1, hb2) + hb2.connect(hb2, blocks.copy(gr.sizeof_char), dst) + tb.run() + self.assertEquals(dst.data(), (1,)) + + def test_031_multiple_internal_inputs(self): + tb = gr.top_block() + src = blocks.vector_source_f([1.0,]) + hb = gr.hier_block2("hb", + gr.io_signature(1, 1, gr.sizeof_float), + gr.io_signature(1, 1, gr.sizeof_float)) + m1 = multiply_const_ff(1.0) + m2 = multiply_const_ff(2.0) + add = add_ff() + hb.connect(hb, m1) # m1 is connected to hb external input #0 + hb.connect(hb, m2) # m2 is also connected to hb external input #0 + hb.connect(m1, (add, 0)) + hb.connect(m2, (add, 1)) + hb.connect(add, hb) # add is connected to hb external output #0 + dst = blocks.vector_sink_f() + tb.connect(src, hb, dst) + tb.run() + self.assertEquals(dst.data(), (3.0,)) + + def test_032_nested_multiple_internal_inputs(self): + tb = gr.top_block() + src = blocks.vector_source_f([1.0,]) + hb = gr.hier_block2("hb", + gr.io_signature(1, 1, gr.sizeof_float), + gr.io_signature(1, 1, gr.sizeof_float)) + hb2 = gr.hier_block2("hb", + gr.io_signature(1, 1, gr.sizeof_float), + gr.io_signature(1, 1, gr.sizeof_float)) + + m1 = multiply_const_ff(1.0) + m2 = multiply_const_ff(2.0) + add = add_ff() + hb2.connect(hb2, m1) # m1 is connected to hb2 external input #0 + hb2.connect(hb2, m2) # m2 is also connected to hb2 external input #0 + hb2.connect(m1, (add, 0)) + hb2.connect(m2, (add, 1)) + hb2.connect(add, hb2) # add is connected to hb2 external output #0 + hb.connect(hb, hb2, hb) # hb as hb2 as nested internal block + dst = blocks.vector_sink_f() + tb.connect(src, hb, dst) + tb.run() + self.assertEquals(dst.data(), (3.0,)) + + +if __name__ == "__main__": + gr_unittest.run(test_hier_block2, "test_hier_block2.xml") diff --git a/gr-blocks/python/qa_integrate.py b/gr-blocks/python/qa_integrate.py index c404f1b309..9d9d9345f4 100755 --- a/gr-blocks/python/qa_integrate.py +++ b/gr-blocks/python/qa_integrate.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# Copyright 2008,2010 Free Software Foundation, Inc. +# Copyright 2008,2010,2013 Free Software Foundation, Inc. # # This file is part of GNU Radio # @@ -21,7 +21,7 @@ # from gnuradio import gr, gr_unittest -import blocks_swig +import blocks_swig as blocks import math class test_integrate (gr_unittest.TestCase): @@ -35,9 +35,9 @@ class test_integrate (gr_unittest.TestCase): 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() + src = blocks.vector_source_s(src_data) + itg = blocks.integrate_ss(3) + dst = blocks.vector_sink_s() self.tb.connect(src, itg, dst) self.tb.run() self.assertEqual(dst_data, dst.data()) @@ -45,9 +45,9 @@ class test_integrate (gr_unittest.TestCase): 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() + src = blocks.vector_source_i(src_data) + itg = blocks.integrate_ii(3) + dst = blocks.vector_sink_i() self.tb.connect(src, itg, dst) self.tb.run() self.assertEqual(dst_data, dst.data()) @@ -55,9 +55,9 @@ class test_integrate (gr_unittest.TestCase): def test_002_ff(self): src_data = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0] dst_data = [6.0, 15.0] - src = gr.vector_source_f(src_data) - itg = blocks_swig.integrate_ff(3) - dst = gr.vector_sink_f() + src = blocks.vector_source_f(src_data) + itg = blocks.integrate_ff(3) + dst = blocks.vector_sink_f() self.tb.connect(src, itg, dst) self.tb.run() self.assertFloatTuplesAlmostEqual(dst_data, dst.data(), 6) @@ -65,9 +65,9 @@ class test_integrate (gr_unittest.TestCase): def test_003_cc(self): src_data = [1.0+1.0j, 2.0+2.0j, 3.0+3.0j, 4.0+4.0j, 5.0+5.0j, 6.0+6.0j] dst_data = [6.0+6.0j, 15.0+15.0j] - src = gr.vector_source_c(src_data) - itg = blocks_swig.integrate_cc(3) - dst = gr.vector_sink_c() + src = blocks.vector_source_c(src_data) + itg = blocks.integrate_cc(3) + dst = blocks.vector_sink_c() self.tb.connect(src, itg, dst) self.tb.run() self.assertComplexTuplesAlmostEqual(dst_data, dst.data(), 6) diff --git a/gr-blocks/python/qa_interleave.py b/gr-blocks/python/qa_interleave.py index 376d487b10..a65824ec33 100755 --- a/gr-blocks/python/qa_interleave.py +++ b/gr-blocks/python/qa_interleave.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# Copyright 2004,2007,2010,2012 Free Software Foundation, Inc. +# Copyright 2004,2007,2010,2012,2013 Free Software Foundation, Inc. # # This file is part of GNU Radio # @@ -21,7 +21,7 @@ # from gnuradio import gr, gr_unittest -import blocks_swig +import blocks_swig as blocks import math class test_interleave (gr_unittest.TestCase): @@ -34,12 +34,12 @@ class test_interleave (gr_unittest.TestCase): def test_int_001 (self): lenx = 64 - src0 = gr.vector_source_f (range (0, lenx, 4)) - src1 = gr.vector_source_f (range (1, lenx, 4)) - src2 = gr.vector_source_f (range (2, lenx, 4)) - src3 = gr.vector_source_f (range (3, lenx, 4)) - op = blocks_swig.interleave (gr.sizeof_float) - dst = gr.vector_sink_f () + src0 = blocks.vector_source_f (range (0, lenx, 4)) + src1 = blocks.vector_source_f (range (1, lenx, 4)) + src2 = blocks.vector_source_f (range (2, lenx, 4)) + src3 = blocks.vector_source_f (range (3, lenx, 4)) + op = blocks.interleave (gr.sizeof_float) + dst = blocks.vector_sink_f () self.tb.connect (src0, (op, 0)) self.tb.connect (src1, (op, 1)) @@ -53,12 +53,12 @@ class test_interleave (gr_unittest.TestCase): def test_deint_001 (self): lenx = 64 - src = gr.vector_source_f (range (lenx)) - op = blocks_swig.deinterleave (gr.sizeof_float) - dst0 = gr.vector_sink_f () - dst1 = gr.vector_sink_f () - dst2 = gr.vector_sink_f () - dst3 = gr.vector_sink_f () + 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) diff --git a/gr-blocks/python/qa_keep_m_in_n.py b/gr-blocks/python/qa_keep_m_in_n.py index 0898217ba9..22e8c45138 100755 --- a/gr-blocks/python/qa_keep_m_in_n.py +++ b/gr-blocks/python/qa_keep_m_in_n.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# Copyright 2008,2010,2012 Free Software Foundation, Inc. +# Copyright 2008,2010,2012,2013 Free Software Foundation, Inc. # # This file is part of GNU Radio # @@ -20,7 +20,7 @@ # from gnuradio import gr, gr_unittest -import blocks_swig +import blocks_swig as blocks import sys import random @@ -35,15 +35,15 @@ class test_keep_m_in_n(gr_unittest.TestCase): def test_001(self): self.maxDiff = None; tb = gr.top_block() - src = gr.vector_source_b( range(0,100) ) + src = blocks.vector_source_b( range(0,100) ) # itemsize, M, N, offset - km2 = blocks_swig.keep_m_in_n( 1, 1, 2, 0 ); - km3 = blocks_swig.keep_m_in_n( 1, 1, 3, 1 ); - km7 = blocks_swig.keep_m_in_n( 1, 1, 7, 2 ); - snk2 = gr.vector_sink_b(); - snk3 = gr.vector_sink_b(); - snk7 = gr.vector_sink_b(); + km2 = blocks.keep_m_in_n( 1, 1, 2, 0 ); + km3 = blocks.keep_m_in_n( 1, 1, 3, 1 ); + km7 = blocks.keep_m_in_n( 1, 1, 7, 2 ); + snk2 = blocks.vector_sink_b(); + snk3 = blocks.vector_sink_b(); + snk7 = blocks.vector_sink_b(); tb.connect(src,km2,snk2); tb.connect(src,km3,snk3); tb.connect(src,km7,snk7); diff --git a/gr-blocks/python/qa_keep_one_in_n.py b/gr-blocks/python/qa_keep_one_in_n.py index 8c5f44b84b..f06ed33d6b 100755 --- a/gr-blocks/python/qa_keep_one_in_n.py +++ b/gr-blocks/python/qa_keep_one_in_n.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# Copyright 2012 Free Software Foundation, Inc. +# Copyright 2012,2013 Free Software Foundation, Inc. # # This file is part of GNU Radio # @@ -21,7 +21,7 @@ # from gnuradio import gr, gr_unittest -import blocks_swig +import blocks_swig as blocks class test_keep_one_in_n(gr_unittest.TestCase): @@ -34,9 +34,9 @@ class test_keep_one_in_n(gr_unittest.TestCase): def test_001(self): src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) expected_data = (5, 10) - src = gr.vector_source_b(src_data); - op = blocks_swig.keep_one_in_n(gr.sizeof_char, 5) - dst = gr.vector_sink_b() + src = blocks.vector_source_b(src_data); + op = blocks.keep_one_in_n(gr.sizeof_char, 5) + dst = blocks.vector_sink_b() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(dst.data(), expected_data) diff --git a/gr-blocks/python/qa_max.py b/gr-blocks/python/qa_max.py index 4af70bd4be..982f4b5590 100755 --- a/gr-blocks/python/qa_max.py +++ b/gr-blocks/python/qa_max.py @@ -36,10 +36,10 @@ class test_max(gr_unittest.TestCase): src_data = (0,0.2,-0.3,0,12,0) expected_result = (float(max(src_data)),) - src = gr.vector_source_f(src_data) + src = blocks.vector_source_f(src_data) s2v = blocks.stream_to_vector(gr.sizeof_float, len(src_data)) op = blocks.max_ff(len(src_data)) - dst = gr.vector_sink_f() + dst = blocks.vector_sink_f() self.tb.connect(src, s2v, op, dst) self.tb.run() @@ -50,10 +50,10 @@ class test_max(gr_unittest.TestCase): src_data=(-100,-99,-98,-97,-96,-1) expected_result = (float(max(src_data)),) - src = gr.vector_source_f(src_data) + src = blocks.vector_source_f(src_data) s2v = blocks.stream_to_vector(gr.sizeof_float, len(src_data)) op = blocks.max_ff(len(src_data)) - dst = gr.vector_sink_f() + dst = blocks.vector_sink_f() self.tb.connect(src, s2v, op, dst) self.tb.run() diff --git a/gr-blocks/python/qa_message.py b/gr-blocks/python/qa_message.py index a556f65cee..27cf186ed3 100755 --- a/gr-blocks/python/qa_message.py +++ b/gr-blocks/python/qa_message.py @@ -93,8 +93,8 @@ class test_message(gr_unittest.TestCase): def test_300(self): input_data = (0,1,2,3,4,5,6,7,8,9) - src = gr.vector_source_b(input_data) - dst = gr.vector_sink_b() + src = blocks.vector_source_b(input_data) + dst = blocks.vector_sink_b() tb = gr.top_block() tb.connect(src, dst) tb.run() @@ -103,7 +103,7 @@ class test_message(gr_unittest.TestCase): def test_301(self): # Use itemsize, limit constructor src = blocks.message_source(gr.sizeof_char) - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() tb = gr.top_block() tb.connect(src, dst) src.msgq().insert_tail(gr.message_from_string('01234')) @@ -118,7 +118,7 @@ class test_message(gr_unittest.TestCase): # Use itemsize, msgq constructor msgq = gr.msg_queue() src = blocks.message_source(gr.sizeof_char, msgq) - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() tb = gr.top_block() tb.connect(src, dst) src.msgq().insert_tail(gr.message_from_string('01234')) diff --git a/gr-blocks/python/qa_moving_average.py b/gr-blocks/python/qa_moving_average.py index 169b4746c2..d3fbdbbfdf 100644 --- a/gr-blocks/python/qa_moving_average.py +++ b/gr-blocks/python/qa_moving_average.py @@ -53,9 +53,9 @@ class test_moving_average(gr_unittest.TestCase): data = make_random_float_tuple(N, 1) expected_result = N*[0,] - src = gr.vector_source_f(data, False) + src = blocks.vector_source_f(data, False) op = blocks.moving_average_ff(100, 0.001) - dst = gr.vector_sink_f() + dst = blocks.vector_sink_f() tb.connect(src, op) tb.connect(op, dst) @@ -74,9 +74,9 @@ class test_moving_average(gr_unittest.TestCase): data = make_random_complex_tuple(N, 1) expected_result = N*[0,] - src = gr.vector_source_c(data, False) + src = blocks.vector_source_c(data, False) op = blocks.moving_average_cc(100, 0.001) - dst = gr.vector_sink_c() + dst = blocks.vector_sink_c() tb.connect(src, op) tb.connect(op, dst) diff --git a/gr-blocks/python/qa_multiply_conjugate.py b/gr-blocks/python/qa_multiply_conjugate.py index f51563f854..a18d80324c 100644 --- a/gr-blocks/python/qa_multiply_conjugate.py +++ b/gr-blocks/python/qa_multiply_conjugate.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# Copyright 2012 Free Software Foundation, Inc. +# Copyright 2012,2013 Free Software Foundation, Inc. # # This file is part of GNU Radio # @@ -21,7 +21,7 @@ # from gnuradio import gr, gr_unittest -import blocks_swig +import blocks_swig as blocks class test_multiply_conjugate (gr_unittest.TestCase): @@ -42,10 +42,10 @@ class test_multiply_conjugate (gr_unittest.TestCase): exp_data = (12+0j, 8+0j, 12+0j, 8+0j, 12+0j, 8+0j, 12+0j, 8+0j, 0+0j) - src0 = gr.vector_source_c(src_data0) - src1 = gr.vector_source_c(src_data1) - op = blocks_swig.multiply_conjugate_cc () - dst = gr.vector_sink_c () + src0 = blocks.vector_source_c(src_data0) + src1 = blocks.vector_source_c(src_data1) + op = blocks.multiply_conjugate_cc () + dst = blocks.vector_sink_c () self.tb.connect(src0, (op,0)) self.tb.connect(src1, (op,1)) diff --git a/gr-blocks/python/qa_mute.py b/gr-blocks/python/qa_mute.py index 96c57b2ed1..0c10846333 100755 --- a/gr-blocks/python/qa_mute.py +++ b/gr-blocks/python/qa_mute.py @@ -33,9 +33,9 @@ class test_mute(gr_unittest.TestCase): 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]) + src = blocks.vector_source_i(s[1]) self.tb.connect(src, (op, s[0])) - dst = gr.vector_sink_i() + dst = blocks.vector_sink_i() self.tb.connect(op, dst) self.tb.run() result_data = dst.data() @@ -43,9 +43,9 @@ class test_mute(gr_unittest.TestCase): def help_ff(self, src_data, exp_data, op): for s in zip(range(len(src_data)), src_data): - src = gr.vector_source_f(s[1]) + src = blocks.vector_source_f(s[1]) self.tb.connect(src, (op, s[0])) - dst = gr.vector_sink_f() + dst = blocks.vector_sink_f() self.tb.connect(op, dst) self.tb.run() result_data = dst.data() @@ -53,9 +53,9 @@ class test_mute(gr_unittest.TestCase): def help_cc(self, src_data, exp_data, op): for s in zip(range(len(src_data)), src_data): - src = gr.vector_source_c(s[1]) + src = blocks.vector_source_c(s[1]) self.tb.connect(src, (op, s[0])) - dst = gr.vector_sink_c() + dst = blocks.vector_sink_c() self.tb.connect(op, dst) self.tb.run() result_data = dst.data() diff --git a/gr-blocks/python/qa_nlog10.py b/gr-blocks/python/qa_nlog10.py index cc2a3e8cc5..a61313cacc 100755 --- a/gr-blocks/python/qa_nlog10.py +++ b/gr-blocks/python/qa_nlog10.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# Copyright 2005,2007,2010,2012 Free Software Foundation, Inc. +# Copyright 2005,2007,2010,2012,2013 Free Software Foundation, Inc. # # This file is part of GNU Radio # @@ -21,7 +21,7 @@ # from gnuradio import gr, gr_unittest -import blocks_swig +import blocks_swig as blocks class test_nlog10(gr_unittest.TestCase): @@ -34,9 +34,9 @@ class test_nlog10(gr_unittest.TestCase): def test_001(self): src_data = (-10, 0, 10, 100, 1000, 10000, 100000) expected_result = (-180, -180, 10, 20, 30, 40, 50) - src = gr.vector_source_f(src_data) - op = blocks_swig.nlog10_ff(10) - dst = gr.vector_sink_f() + src = blocks.vector_source_f(src_data) + op = blocks.nlog10_ff(10) + dst = blocks.vector_sink_f() self.tb.connect (src, op, dst) self.tb.run() result_data = dst.data() diff --git a/gr-blocks/python/qa_pack_k_bits.py b/gr-blocks/python/qa_pack_k_bits.py index cd55d2f200..51152889f6 100755 --- a/gr-blocks/python/qa_pack_k_bits.py +++ b/gr-blocks/python/qa_pack_k_bits.py @@ -35,9 +35,9 @@ class test_pack(gr_unittest.TestCase): def test_001(self): src_data = (1,0,1,1,0,1,1,0) expected_results = (1,0,1,1,0,1,1,0) - src = gr.vector_source_b(src_data,False) + src = blocks.vector_source_b(src_data,False) op = blocks.pack_k_bits_bb(1) - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_results, dst.data()) @@ -45,9 +45,9 @@ class test_pack(gr_unittest.TestCase): def test_002(self): src_data = (1,0,1,1,0,0,0,1) expected_results = ( 2, 3, 0, 1) - src = gr.vector_source_b(src_data,False) + src = blocks.vector_source_b(src_data,False) op = blocks.pack_k_bits_bb(2) - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() self.tb.connect(src, op, dst) self.tb.run() #self.assertEqual(expected_results, dst.data()) @@ -55,10 +55,10 @@ class test_pack(gr_unittest.TestCase): def test_003(self): src_data = expected_results = map(lambda x: random.randint(0,3), range(10)); - src = gr.vector_source_b( src_data ); + src = blocks.vector_source_b( src_data ); pack = blocks.pack_k_bits_bb(2); unpack = blocks.unpack_k_bits_bb(2); - snk = gr.vector_sink_b(); + snk = blocks.vector_sink_b(); self.tb.connect(src,unpack,pack,snk); self.tb.run() self.assertEqual(list(expected_results), list(snk.data())); diff --git a/gr-blocks/python/qa_packed_to_unpacked.py b/gr-blocks/python/qa_packed_to_unpacked.py index d84f5dbd37..23745d3859 100755 --- a/gr-blocks/python/qa_packed_to_unpacked.py +++ b/gr-blocks/python/qa_packed_to_unpacked.py @@ -35,9 +35,9 @@ class test_packing(gr_unittest.TestCase): def test_001(self): src_data = (0x80,) expected_results = (1,0,0,0,0,0,0,0) - src = gr.vector_source_b(src_data, False) + src = blocks.vector_source_b(src_data, False) op = blocks.packed_to_unpacked_bb(1, gr.GR_MSB_FIRST) - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() self.tb.connect(src, op) self.tb.connect(op, dst) @@ -48,9 +48,9 @@ class test_packing(gr_unittest.TestCase): def test_002(self): src_data = (0x80,) expected_results = (0,0,0,0,0,0,0,1) - src = gr.vector_source_b(src_data, False) + src = blocks.vector_source_b(src_data, False) op = blocks.packed_to_unpacked_bb(1, gr.GR_LSB_FIRST) - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() self.tb.connect(src, op) self.tb.connect(op, dst) @@ -61,9 +61,9 @@ class test_packing(gr_unittest.TestCase): def test_003(self): src_data = (0x11,) expected_results = (4, 2) - src = gr.vector_source_b(src_data, False) + src = blocks.vector_source_b(src_data, False) op = blocks.packed_to_unpacked_bb(3, gr.GR_LSB_FIRST) - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() self.tb.connect(src, op) self.tb.connect(op, dst) @@ -74,9 +74,9 @@ class test_packing(gr_unittest.TestCase): def test_004(self): src_data = (0x11,) expected_results = (0, 4) - src = gr.vector_source_b(src_data, False) + src = blocks.vector_source_b(src_data, False) op = blocks.packed_to_unpacked_bb(3, gr.GR_MSB_FIRST) - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() self.tb.connect(src, op) self.tb.connect(op, dst) @@ -87,9 +87,9 @@ class test_packing(gr_unittest.TestCase): def test_005(self): src_data = (1,0,0,0,0,0,1,0,0,1,0,1,1,0,1,0) expected_results = (0x82, 0x5a) - src = gr.vector_source_b(src_data, False) + src = blocks.vector_source_b(src_data, False) op = blocks.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST) - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() self.tb.connect(src, op) self.tb.connect(op, dst) @@ -100,9 +100,9 @@ class test_packing(gr_unittest.TestCase): def test_006(self): src_data = (0,1,0,0,0,0,0,1,0,1,0,1,1,0,1,0) expected_results = (0x82, 0x5a) - src = gr.vector_source_b(src_data, False) + src = blocks.vector_source_b(src_data, False) op = blocks.unpacked_to_packed_bb(1, gr.GR_LSB_FIRST) - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() self.tb.connect(src, op) self.tb.connect(op, dst) @@ -113,9 +113,9 @@ class test_packing(gr_unittest.TestCase): def test_007(self): src_data = (4, 2, 0,0,0) expected_results = (0x11,) - src = gr.vector_source_b(src_data, False) + src = blocks.vector_source_b(src_data, False) op = blocks.unpacked_to_packed_bb(3, gr.GR_LSB_FIRST) - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() self.tb.connect(src, op) self.tb.connect(op, dst) @@ -126,9 +126,9 @@ class test_packing(gr_unittest.TestCase): def test_008(self): src_data = (0, 4, 2,0,0) expected_results = (0x11,) - src = gr.vector_source_b(src_data,False) + src = blocks.vector_source_b(src_data,False) op = blocks.unpacked_to_packed_bb(3, gr.GR_MSB_FIRST) - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() self.tb.connect(src, op) self.tb.connect(op, dst) @@ -144,10 +144,10 @@ class test_packing(gr_unittest.TestCase): src_data = tuple(src_data) expected_results = src_data - src = gr.vector_source_b(tuple(src_data), False) + src = blocks.vector_source_b(tuple(src_data), False) op1 = blocks.packed_to_unpacked_bb(3, gr.GR_MSB_FIRST) op2 = blocks.unpacked_to_packed_bb(3, gr.GR_MSB_FIRST) - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() self.tb.connect(src, op1, op2) self.tb.connect(op2, dst) @@ -162,10 +162,10 @@ class test_packing(gr_unittest.TestCase): src_data.append((random.randint(0,255))) src_data = tuple(src_data) expected_results = src_data - src = gr.vector_source_b(tuple(src_data), False) + src = blocks.vector_source_b(tuple(src_data), False) op1 = blocks.packed_to_unpacked_bb(7, gr.GR_MSB_FIRST) op2 = blocks.unpacked_to_packed_bb(7, gr.GR_MSB_FIRST) - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() self.tb.connect(src, op1, op2) self.tb.connect(op2, dst) @@ -180,10 +180,10 @@ class test_packing(gr_unittest.TestCase): src_data.append((random.randint(0,255))) src_data = tuple(src_data) expected_results = src_data - src = gr.vector_source_b(tuple(src_data),False) + src = blocks.vector_source_b(tuple(src_data),False) op1 = blocks.packed_to_unpacked_bb(7, gr.GR_LSB_FIRST) op2 = blocks.unpacked_to_packed_bb(7, gr.GR_LSB_FIRST) - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() self.tb.connect(src, op1, op2) self.tb.connect(op2, dst) @@ -200,10 +200,10 @@ class test_packing(gr_unittest.TestCase): src_data.append((random.randint(-2**15,2**15-1))) src_data = tuple(src_data) expected_results = src_data - src = gr.vector_source_s(tuple(src_data), False) + src = blocks.vector_source_s(tuple(src_data), False) op1 = blocks.packed_to_unpacked_ss(1, gr.GR_MSB_FIRST) op2 = blocks.unpacked_to_packed_ss(1, gr.GR_MSB_FIRST) - dst = gr.vector_sink_s() + dst = blocks.vector_sink_s() self.tb.connect(src, op1, op2) self.tb.connect(op2, dst) @@ -218,10 +218,10 @@ class test_packing(gr_unittest.TestCase): src_data.append((random.randint(-2**15,2**15-1))) src_data = tuple(src_data) expected_results = src_data - src = gr.vector_source_s(tuple(src_data), False) + src = blocks.vector_source_s(tuple(src_data), False) op1 = blocks.packed_to_unpacked_ss(1, gr.GR_LSB_FIRST) op2 = blocks.unpacked_to_packed_ss(1, gr.GR_LSB_FIRST) - dst = gr.vector_sink_s() + dst = blocks.vector_sink_s() self.tb.connect(src, op1, op2) self.tb.connect(op2, dst) @@ -236,10 +236,10 @@ class test_packing(gr_unittest.TestCase): src_data.append((random.randint(-2**15,2**15-1))) src_data = tuple(src_data) expected_results = src_data - src = gr.vector_source_s(tuple(src_data), False) + src = blocks.vector_source_s(tuple(src_data), False) op1 = blocks.packed_to_unpacked_ss(8, gr.GR_MSB_FIRST) op2 = blocks.unpacked_to_packed_ss(8, gr.GR_MSB_FIRST) - dst = gr.vector_sink_s() + dst = blocks.vector_sink_s() self.tb.connect(src, op1, op2) self.tb.connect(op2, dst) @@ -254,10 +254,10 @@ class test_packing(gr_unittest.TestCase): src_data.append((random.randint(-2**15,2**15-1))) src_data = tuple(src_data) expected_results = src_data - src = gr.vector_source_s(tuple(src_data), False) + src = blocks.vector_source_s(tuple(src_data), False) op1 = blocks.packed_to_unpacked_ss(8, gr.GR_LSB_FIRST) op2 = blocks.unpacked_to_packed_ss(8, gr.GR_LSB_FIRST) - dst = gr.vector_sink_s() + dst = blocks.vector_sink_s() self.tb.connect(src, op1, op2) self.tb.connect(op2, dst) @@ -274,10 +274,10 @@ class test_packing(gr_unittest.TestCase): 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) + src = blocks.vector_source_i(tuple(src_data), False) op1 = blocks.packed_to_unpacked_ii(1, gr.GR_MSB_FIRST) op2 = blocks.unpacked_to_packed_ii(1, gr.GR_MSB_FIRST) - dst = gr.vector_sink_i() + dst = blocks.vector_sink_i() self.tb.connect(src, op1, op2) self.tb.connect(op2, dst) @@ -292,10 +292,10 @@ class test_packing(gr_unittest.TestCase): 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) + src = blocks.vector_source_i(tuple(src_data), False) op1 = blocks.packed_to_unpacked_ii(1, gr.GR_LSB_FIRST) op2 = blocks.unpacked_to_packed_ii(1, gr.GR_LSB_FIRST) - dst = gr.vector_sink_i() + dst = blocks.vector_sink_i() self.tb.connect(src, op1, op2) self.tb.connect(op2, dst) @@ -310,10 +310,10 @@ class test_packing(gr_unittest.TestCase): 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) + src = blocks.vector_source_i(tuple(src_data), False) op1 = blocks.packed_to_unpacked_ii(8, gr.GR_MSB_FIRST) op2 = blocks.unpacked_to_packed_ii(8, gr.GR_MSB_FIRST) - dst = gr.vector_sink_i() + dst = blocks.vector_sink_i() self.tb.connect(src, op1, op2) self.tb.connect(op2, dst) @@ -328,10 +328,10 @@ class test_packing(gr_unittest.TestCase): 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) + src = blocks.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() + dst = blocks.vector_sink_i() self.tb.connect(src, op1, op2) self.tb.connect(op2, dst) diff --git a/gr-blocks/python/qa_patterned_interleaver.py b/gr-blocks/python/qa_patterned_interleaver.py index 3cf29c9178..c960ac2e66 100755 --- a/gr-blocks/python/qa_patterned_interleaver.py +++ b/gr-blocks/python/qa_patterned_interleaver.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# Copyright 2008,2010 Free Software Foundation, Inc. +# Copyright 2008,2010,2013 Free Software Foundation, Inc. # # This file is part of GNU Radio # @@ -37,12 +37,12 @@ class test_patterned_interleaver (gr_unittest.TestCase): def test_000(self): dst_data = [0,0,1,2,0,2,1,0]; - src0 = gr.vector_source_f(200*[0]) - src1 = gr.vector_source_f(200*[1]) - src2 = gr.vector_source_f(200*[2]) + src0 = blocks.vector_source_f(200*[0]) + src1 = blocks.vector_source_f(200*[1]) + src2 = blocks.vector_source_f(200*[2]) itg = blocks.patterned_interleaver(gr.sizeof_float, dst_data) - dst = gr.vector_sink_f() - head = gr.head(gr.sizeof_float, 8); + dst = blocks.vector_sink_f() + head = blocks.head(gr.sizeof_float, 8); self.tb.connect( src0, (itg,0) ); self.tb.connect( src1, (itg,1) ); diff --git a/gr-blocks/python/qa_pdu.py b/gr-blocks/python/qa_pdu.py index c8fc0e5a91..a9d8ea86f3 100755 --- a/gr-blocks/python/qa_pdu.py +++ b/gr-blocks/python/qa_pdu.py @@ -39,7 +39,7 @@ class test_pdu(gr_unittest.TestCase): src = blocks.pdu_to_tagged_stream(blocks.byte_t) snk3 = blocks.tagged_stream_to_pdu(blocks.byte_t) - snk2 = gr.vector_sink_b() + snk2 = blocks.vector_sink_b() snk = blocks.tag_debug(1, "test") snk.set_display(False) diff --git a/gr-blocks/python/qa_peak_detector.py b/gr-blocks/python/qa_peak_detector.py index c3ff2548c4..4b28518410 100644 --- a/gr-blocks/python/qa_peak_detector.py +++ b/gr-blocks/python/qa_peak_detector.py @@ -40,9 +40,9 @@ class test_peak_detector(gr_unittest.TestCase): expected_result = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) - src = gr.vector_source_f(data, False) + src = blocks.vector_source_f(data, False) regen = blocks.peak_detector_fb() - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() tb.connect(src, regen) tb.connect(regen, dst) @@ -61,9 +61,9 @@ class test_peak_detector(gr_unittest.TestCase): expected_result = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) - src = gr.vector_source_i(data, False) + src = blocks.vector_source_i(data, False) regen = blocks.peak_detector_ib() - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() tb.connect(src, regen) tb.connect(regen, dst) @@ -82,9 +82,9 @@ class test_peak_detector(gr_unittest.TestCase): expected_result = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) - src = gr.vector_source_s(data, False) + src = blocks.vector_source_s(data, False) regen = blocks.peak_detector_sb() - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() tb.connect(src, regen) tb.connect(regen, dst) diff --git a/gr-blocks/python/qa_peak_detector2.py b/gr-blocks/python/qa_peak_detector2.py index b2d8e318dd..5fcda9be08 100644 --- a/gr-blocks/python/qa_peak_detector2.py +++ b/gr-blocks/python/qa_peak_detector2.py @@ -41,9 +41,9 @@ class test_peak_detector2(gr_unittest.TestCase): 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) - src = gr.vector_source_f(data, False) + src = blocks.vector_source_f(data, False) regen = blocks.peak_detector2_fb() - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() tb.connect(src, regen) tb.connect(regen, dst) diff --git a/gr-blocks/python/qa_pipe_fittings.py b/gr-blocks/python/qa_pipe_fittings.py index 9894a5c211..634638dcdd 100755 --- a/gr-blocks/python/qa_pipe_fittings.py +++ b/gr-blocks/python/qa_pipe_fittings.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# Copyright 2005,2007,2010,2012 Free Software Foundation, Inc. +# Copyright 2005,2007,2010,2012,2013 Free Software Foundation, Inc. # # This file is part of GNU Radio # @@ -50,13 +50,13 @@ class test_pipe_fittings(gr_unittest.TestCase): expected_results = calc_expected_result(src_data, n) #print "expected results: ", expected_results - src = gr.vector_source_i(src_data) + src = blocks.vector_source_i(src_data) op = blocks.stream_to_streams(gr.sizeof_int, n) self.tb.connect(src, op) dsts = [] for i in range(n): - dst = gr.vector_sink_i() + dst = blocks.vector_sink_i() self.tb.connect((op, i), (dst, 0)) dsts.append(dst) @@ -74,10 +74,10 @@ class test_pipe_fittings(gr_unittest.TestCase): src_data = tuple(range(src_len)) expected_results = src_data - src = gr.vector_source_i(src_data) + src = blocks.vector_source_i(src_data) op1 = blocks.stream_to_streams(gr.sizeof_int, n) op2 = blocks.streams_to_stream(gr.sizeof_int, n) - dst = gr.vector_sink_i() + dst = blocks.vector_sink_i() self.tb.connect(src, op1) for i in range(n): @@ -96,11 +96,11 @@ class test_pipe_fittings(gr_unittest.TestCase): src_data = tuple(range(src_len)) expected_results = src_data - src = gr.vector_source_i(src_data) + src = blocks.vector_source_i(src_data) op1 = blocks.stream_to_streams(gr.sizeof_int, n) op2 = blocks.streams_to_vector(gr.sizeof_int, n) op3 = blocks.vector_to_stream(gr.sizeof_int, n) - dst = gr.vector_sink_i() + dst = blocks.vector_sink_i() self.tb.connect(src, op1) for i in range(n): @@ -119,11 +119,11 @@ class test_pipe_fittings(gr_unittest.TestCase): src_data = tuple(range(src_len)) expected_results = src_data - src = gr.vector_source_i(src_data) + src = blocks.vector_source_i(src_data) op1 = blocks.stream_to_vector(gr.sizeof_int, n) op2 = blocks.vector_to_streams(gr.sizeof_int, n) op3 = blocks.streams_to_stream(gr.sizeof_int, n) - dst = gr.vector_sink_i() + dst = blocks.vector_sink_i() self.tb.connect(src, op1, op2) for i in range(n): diff --git a/gr-blocks/python/qa_probe_signal.py b/gr-blocks/python/qa_probe_signal.py index 6d25a25087..1cb151bfc0 100644 --- a/gr-blocks/python/qa_probe_signal.py +++ b/gr-blocks/python/qa_probe_signal.py @@ -36,7 +36,7 @@ class test_probe_signal(gr_unittest.TestCase): repeats = 100 src_data = [value] * repeats - src = gr.vector_source_f(src_data) + src = blocks.vector_source_f(src_data) dst = blocks.probe_signal_f() self.tb.connect(src, dst) @@ -50,7 +50,7 @@ class test_probe_signal(gr_unittest.TestCase): value = [0.5+i for i in range(0, vector_length)] src_data = value * repeats - src = gr.vector_source_f(src_data) + src = blocks.vector_source_f(src_data) s2v = blocks.stream_to_vector(gr.sizeof_float, vector_length) dst = blocks.probe_signal_vf(vector_length) diff --git a/gr-blocks/python/qa_python_message_passing.py b/gr-blocks/python/qa_python_message_passing.py new file mode 100644 index 0000000000..f199d5470f --- /dev/null +++ b/gr-blocks/python/qa_python_message_passing.py @@ -0,0 +1,124 @@ +#!/usr/bin/env python +# +# Copyright 2013 Free Software Foundation, Inc. +# +# This file is part of GNU Radio +# +# GNU Radio is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3, or (at your option) +# any later version. +# +# GNU Radio is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Radio; see the file COPYING. If not, write to +# the Free Software Foundation, Inc., 51 Franklin Street, +# Boston, MA 02110-1301, USA. +# + +from gnuradio import gr, gr_unittest +try: import pmt +except: from gruel import pmt +import numpy +import time +import blocks_swig as blocks + +# Simple block to generate messages +class message_generator(gr.sync_block): + def __init__(self, msg_list, msg_interval): + gr.sync_block.__init__( + self, + name = "message generator", + in_sig = [numpy.float32], + out_sig = None + ) + self.msg_list = msg_list + self.msg_interval = msg_interval + self.msg_ctr = 0 + self.message_port_register_out(pmt.intern('out_port')) + + + def work(self, input_items, output_items): + inLen = len(input_items[0]) + while self.msg_ctr < len(self.msg_list) and \ + (self.msg_ctr * self.msg_interval) < \ + (self.nitems_read(0) + inLen): + self.message_port_pub(pmt.intern('out_port'), + self.msg_list[self.msg_ctr]) + self.msg_ctr += 1 + return inLen + +# Simple block to consume messages +class message_consumer(gr.sync_block): + def __init__(self): + gr.sync_block.__init__( + self, + name = "message consumer", + in_sig = None, + out_sig = None + ) + self.msg_list = [] + self.message_port_register_in(pmt.intern('in_port')) + self.set_msg_handler(pmt.intern('in_port'), + self.handle_msg) + + def handle_msg(self, msg): + # Create a new PMT from long value and put in list + self.msg_list.append(pmt.from_long(pmt.to_long(msg))) + +class test_python_message_passing(gr_unittest.TestCase): + + def setUp(self): + self.tb = gr.top_block() + + def tearDown(self): + self.tb = None + + def test_000(self): + num_msgs = 10 + msg_interval = 1000 + msg_list = [] + for i in range(num_msgs): + msg_list.append(pmt.from_long(i)) + + # Create vector source with dummy data to trigger messages + src_data = [] + for i in range(num_msgs*msg_interval): + src_data.append(float(i)) + src = blocks.vector_source_f(src_data, False) + msg_gen = message_generator(msg_list, msg_interval) + msg_cons = message_consumer() + + # Connect vector source to message gen + self.tb.connect(src, msg_gen) + + # Connect message generator to message consumer + self.tb.msg_connect(msg_gen, 'out_port', msg_cons, 'in_port') + + # Verify that the messgae port query functions work + self.assertEqual(pmt.symbol_to_string(pmt.vector_ref( + msg_gen.message_ports_out(), 0)), 'out_port') + self.assertEqual(pmt.symbol_to_string(pmt.vector_ref( + msg_cons.message_ports_in(), 0)), 'in_port') + + # Run to verify message passing + self.tb.start() + + # Wait for all messages to be sent + while msg_gen.msg_ctr < num_msgs: + time.sleep(0.5) + self.tb.stop() + self.tb.wait() + + # Verify that the message consumer got all the messages + self.assertEqual(num_msgs, len(msg_cons.msg_list)) + for i in range(num_msgs): + self.assertTrue(pmt.equal(msg_list[i], msg_cons.msg_list[i])) + +if __name__ == '__main__': + gr_unittest.run(test_python_message_passing, + 'test_python_message_passing.xml') diff --git a/gr-blocks/python/qa_regenerate.py b/gr-blocks/python/qa_regenerate.py index a57eeba2bb..0be68d001c 100755 --- a/gr-blocks/python/qa_regenerate.py +++ b/gr-blocks/python/qa_regenerate.py @@ -43,9 +43,9 @@ class test_regenerate(gr_unittest.TestCase): 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) - src = gr.vector_source_b(data, False) + src = blocks.vector_source_b(data, False) regen = blocks.regenerate_bb(5, 2) - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() tb.connect(src, regen) tb.connect(regen, dst) @@ -73,9 +73,9 @@ class test_regenerate(gr_unittest.TestCase): expected_result[119] = 1 expected_result[129] = 1 - src = gr.vector_source_b(data, False) + src = blocks.vector_source_b(data, False) regen = blocks.regenerate_bb(10, 3) - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() tb.connect(src, regen) tb.connect(regen, dst) diff --git a/gr-blocks/python/qa_repack_bits_bb.py b/gr-blocks/python/qa_repack_bits_bb.py index 3f88df4a68..9da6cf26c6 100755 --- a/gr-blocks/python/qa_repack_bits_bb.py +++ b/gr-blocks/python/qa_repack_bits_bb.py @@ -39,9 +39,9 @@ class qa_repack_bits_bb (gr_unittest.TestCase): expected_data = (0b1, 0b1, 0b1, 0b0, 0b0, 0b1) k = 2 l = 1 - src = gr.vector_source_b(src_data, False, 1) + src = blocks.vector_source_b(src_data, False, 1) repack = blocks.repack_bits_bb(k, l) - sink = gr.vector_sink_b() + sink = blocks.vector_sink_b() self.tb.connect(src, repack, sink) self.tb.run () self.assertEqual(sink.data(), expected_data) @@ -52,9 +52,9 @@ class qa_repack_bits_bb (gr_unittest.TestCase): expected_data = (0b101,) + (0b111,) * 7 k = 8 l = 3 - src = gr.vector_source_b(src_data, False, 1) + src = blocks.vector_source_b(src_data, False, 1) repack = blocks.repack_bits_bb(k, l) - sink = gr.vector_sink_b() + sink = blocks.vector_sink_b() self.tb.connect(src, repack, sink) self.tb.run () self.assertEqual(sink.data(), expected_data) @@ -62,12 +62,12 @@ class qa_repack_bits_bb (gr_unittest.TestCase): def test_003_lots_of_bytes (self): """ Lots and lots of bytes, multiple packer stages """ src_data = tuple([random.randint(0, 255) for x in range(3*5*7*8 * 10)]) - src = gr.vector_source_b(src_data, False, 1) + src = blocks.vector_source_b(src_data, False, 1) repack1 = blocks.repack_bits_bb(8, 3) repack2 = blocks.repack_bits_bb(3, 5) repack3 = blocks.repack_bits_bb(5, 7) repack4 = blocks.repack_bits_bb(7, 8) - sink = gr.vector_sink_b() + sink = blocks.vector_sink_b() self.tb.connect(src, repack1, repack2, repack3, repack4, sink) self.tb.run () self.assertEqual(sink.data(), src_data) @@ -83,9 +83,9 @@ class qa_repack_bits_bb (gr_unittest.TestCase): tag.offset = 0 tag.key = pmt.string_to_symbol(tag_name) tag.value = pmt.from_long(len(src_data)) - src = gr.vector_source_b(src_data, False, 1, (tag,)) + src = blocks.vector_source_b(src_data, False, 1, (tag,)) repack = blocks.repack_bits_bb(k, l, tag_name) - sink = gr.vector_sink_b() + sink = blocks.vector_sink_b() self.tb.connect(src, repack, sink) self.tb.run () self.assertEqual(sink.data(), expected_data) @@ -108,9 +108,9 @@ class qa_repack_bits_bb (gr_unittest.TestCase): tag.offset = 0 tag.key = pmt.string_to_symbol(tag_name) tag.value = pmt.from_long(len(src_data)) - src = gr.vector_source_b(src_data, False, 1, (tag,)) + src = blocks.vector_source_b(src_data, False, 1, (tag,)) repack = blocks.repack_bits_bb(k, l, tag_name, True) - sink = gr.vector_sink_b() + sink = blocks.vector_sink_b() self.tb.connect(src, repack, sink) self.tb.run () self.assertEqual(sink.data(), expected_data) diff --git a/gr-blocks/python/qa_repeat.py b/gr-blocks/python/qa_repeat.py index 69fb3ef72d..aa1b1f45f1 100755 --- a/gr-blocks/python/qa_repeat.py +++ b/gr-blocks/python/qa_repeat.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# Copyright 2008,2010,2012 Free Software Foundation, Inc. +# Copyright 2008,2010,2012,2013 Free Software Foundation, Inc. # # This file is part of GNU Radio # @@ -21,7 +21,7 @@ # from gnuradio import gr, gr_unittest -import blocks_swig +import blocks_swig as blocks import math class test_repeat (gr_unittest.TestCase): @@ -38,9 +38,9 @@ class test_repeat (gr_unittest.TestCase): for n in range(100): dst_data += [1.0*n, 1.0*n, 1.0*n] - src = gr.vector_source_f(src_data) - rpt = blocks_swig.repeat(gr.sizeof_float, 3) - dst = gr.vector_sink_f() + src = blocks.vector_source_f(src_data) + rpt = blocks.repeat(gr.sizeof_float, 3) + dst = blocks.vector_sink_f() self.tb.connect(src, rpt, dst) self.tb.run() self.assertFloatTuplesAlmostEqual(dst_data, dst.data(), 6) diff --git a/gr-blocks/python/qa_rms.py b/gr-blocks/python/qa_rms.py index f3386668af..3dac70c1ec 100644 --- a/gr-blocks/python/qa_rms.py +++ b/gr-blocks/python/qa_rms.py @@ -50,10 +50,10 @@ class test_rms(gr_unittest.TestCase): expected_data = amp/math.sqrt(2.0) - src = gr.vector_source_f(src_data, True) - head = gr.head(gr.sizeof_float, N) + src = blocks.vector_source_f(src_data, True) + head = blocks.head(gr.sizeof_float, N) op = blocks.rms_ff(0.0001) - dst = gr.vector_sink_f() + dst = blocks.vector_sink_f() self.tb.connect(src, head, op, dst) self.tb.run() @@ -68,10 +68,10 @@ class test_rms(gr_unittest.TestCase): expected_data = amp - src = gr.vector_source_c(src_data, True) - head = gr.head(gr.sizeof_gr_complex, N) + src = blocks.vector_source_c(src_data, True) + head = blocks.head(gr.sizeof_gr_complex, N) op = blocks.rms_cf(0.0001) - dst = gr.vector_sink_f() + dst = blocks.vector_sink_f() self.tb.connect(src, head, op, dst) self.tb.run() diff --git a/gr-blocks/python/qa_sample_and_hold.py b/gr-blocks/python/qa_sample_and_hold.py index 59628090d1..87d472a038 100644 --- a/gr-blocks/python/qa_sample_and_hold.py +++ b/gr-blocks/python/qa_sample_and_hold.py @@ -37,10 +37,10 @@ class test_sample_and_hold(gr_unittest.TestCase): ctrl_data = 10*[1,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0] expected_result = 10*(0,0,0,0,4,5,6,7,8,9,9,9,9,9,9,9,9,9) - src = gr.vector_source_f(src_data) - ctrl = gr.vector_source_b(ctrl_data) + src = blocks.vector_source_f(src_data) + ctrl = blocks.vector_source_b(ctrl_data) op = blocks.sample_and_hold_ff() - dst = gr.vector_sink_f() + dst = blocks.vector_sink_f() self.tb.connect(src, (op,0)) self.tb.connect(ctrl, (op,1)) diff --git a/gr-blocks/python/qa_stream_mux.py b/gr-blocks/python/qa_stream_mux.py index 657bd3d63f..a5004dd8da 100755 --- a/gr-blocks/python/qa_stream_mux.py +++ b/gr-blocks/python/qa_stream_mux.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# Copyright 2004,2005,2007,2010,2012 Free Software Foundation, Inc. +# Copyright 2004,2005,2007,2010,2012,2013 Free Software Foundation, Inc. # # This file is part of GNU Radio # @@ -21,7 +21,7 @@ # from gnuradio import gr, gr_unittest -import blocks_swig +import blocks_swig as blocks import os class test_stream_mux (gr_unittest.TestCase): @@ -34,12 +34,12 @@ class test_stream_mux (gr_unittest.TestCase): self.tb = None def help_stream_2ff(self, N, stream_sizes): - v0 = gr.vector_source_f(N*[1,], False) - v1 = gr.vector_source_f(N*[2,], False) + v0 = blocks.vector_source_f(N*[1,], False) + v1 = blocks.vector_source_f(N*[2,], False) - mux = blocks_swig.stream_mux(gr.sizeof_float, stream_sizes) + mux = blocks.stream_mux(gr.sizeof_float, stream_sizes) - dst = gr.vector_sink_f () + dst = blocks.vector_sink_f () self.tb.connect (v0, (mux,0)) self.tb.connect (v1, (mux,1)) @@ -53,12 +53,12 @@ class test_stream_mux (gr_unittest.TestCase): r2 = range(N) r2.reverse() - v0 = gr.vector_source_f(r1, False) - v1 = gr.vector_source_f(r2, False) + v0 = blocks.vector_source_f(r1, False) + v1 = blocks.vector_source_f(r2, False) - mux = blocks_swig.stream_mux(gr.sizeof_float, stream_sizes) + mux = blocks.stream_mux(gr.sizeof_float, stream_sizes) - dst = gr.vector_sink_f () + dst = blocks.vector_sink_f () self.tb.connect (v0, (mux,0)) self.tb.connect (v1, (mux,1)) diff --git a/gr-blocks/python/qa_stretch.py b/gr-blocks/python/qa_stretch.py index 078b404dbf..94bb6e0353 100755 --- a/gr-blocks/python/qa_stretch.py +++ b/gr-blocks/python/qa_stretch.py @@ -41,13 +41,13 @@ class test_stretch(gr_unittest.TestCase): expected_result0 = 10*[0.05,] expected_result1 = 10*[0.1,] - src0 = gr.vector_source_f(data0, False) - src1 = gr.vector_source_f(data1, False) + 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 = gr.vector_sink_f() - dst1 = gr.vector_sink_f() + dst0 = blocks.vector_sink_f() + dst1 = blocks.vector_sink_f() tb.connect(src0, (inter,0)) tb.connect(src1, (inter,1)) diff --git a/gr-blocks/python/qa_tag_debug.py b/gr-blocks/python/qa_tag_debug.py index ad85daebcc..52864d34fb 100755 --- a/gr-blocks/python/qa_tag_debug.py +++ b/gr-blocks/python/qa_tag_debug.py @@ -34,7 +34,7 @@ class test_tag_debug(gr_unittest.TestCase): 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) + src = blocks.vector_source_i(src_data) op = blocks.tag_debug(gr.sizeof_int, "tag QA") self.tb.connect(src, op) self.tb.run() diff --git a/gr-blocks/python/qa_tag_file_sink.py b/gr-blocks/python/qa_tag_file_sink.py index 80e41a7dd0..e41e6544fd 100644 --- a/gr-blocks/python/qa_tag_file_sink.py +++ b/gr-blocks/python/qa_tag_file_sink.py @@ -35,8 +35,8 @@ class test_tag_file_sink(gr_unittest.TestCase): 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) + src = blocks.vector_source_i(src_data) + trg = blocks.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)) diff --git a/gr-blocks/python/qa_tagged_stream_mux.py b/gr-blocks/python/qa_tagged_stream_mux.py index e39f8cac29..1759c44623 100755 --- a/gr-blocks/python/qa_tagged_stream_mux.py +++ b/gr-blocks/python/qa_tagged_stream_mux.py @@ -82,10 +82,10 @@ class qa_tagged_stream_mux (gr_unittest.TestCase): test_tag_1.offset = 3 # On the first '3' of the 2nd stream test_tag_1.value = pmt.to_pmt(23) - src0 = gr.vector_source_b(datas[0:9], False, 1, len_tags_0 + (test_tag_0,)) - src1 = gr.vector_source_b(datas[9:], False, 1, len_tags_1 + (test_tag_1,)) + src0 = blocks.vector_source_b(datas[0:9], False, 1, len_tags_0 + (test_tag_0,)) + src1 = blocks.vector_source_b(datas[9:], False, 1, len_tags_1 + (test_tag_1,)) tagged_stream_mux = blocks.tagged_stream_mux(gr.sizeof_char, tagname) - snk = gr.vector_sink_b() + snk = blocks.vector_sink_b() self.tb.connect(src0, (tagged_stream_mux, 0)) self.tb.connect(src1, (tagged_stream_mux, 1)) self.tb.connect(tagged_stream_mux, snk) diff --git a/gr-blocks/python/qa_threshold.py b/gr-blocks/python/qa_threshold.py index f91af739ad..352a14da9e 100644 --- a/gr-blocks/python/qa_threshold.py +++ b/gr-blocks/python/qa_threshold.py @@ -38,9 +38,9 @@ class test_threshold(gr_unittest.TestCase): expected_result = (0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1) - src = gr.vector_source_f(data, False) + src = blocks.vector_source_f(data, False) op = blocks.threshold_ff(1, 1) - dst = gr.vector_sink_f() + dst = blocks.vector_sink_f() tb.connect(src, op) tb.connect(op, dst) diff --git a/gr-blocks/python/qa_transcendental.py b/gr-blocks/python/qa_transcendental.py index 8174f79630..b57b0b4430 100644 --- a/gr-blocks/python/qa_transcendental.py +++ b/gr-blocks/python/qa_transcendental.py @@ -38,9 +38,9 @@ class test_transcendental(gr_unittest.TestCase): data = 100*[0,] expected_result = 100*[1,] - src = gr.vector_source_f(data, False) + src = blocks.vector_source_f(data, False) op = blocks.transcendental("cos", "float") - dst = gr.vector_sink_f() + dst = blocks.vector_sink_f() tb.connect(src, op) tb.connect(op, dst) @@ -56,9 +56,9 @@ class test_transcendental(gr_unittest.TestCase): data = 100*[3,] expected_result = 100*[math.log10(3),] - src = gr.vector_source_f(data, False) + src = blocks.vector_source_f(data, False) op = blocks.transcendental("log10", "float") - dst = gr.vector_sink_f() + dst = blocks.vector_sink_f() tb.connect(src, op) tb.connect(op, dst) @@ -74,9 +74,9 @@ class test_transcendental(gr_unittest.TestCase): data = 100*[3,] expected_result = 100*[math.tanh(3),] - src = gr.vector_source_f(data, False) + src = blocks.vector_source_f(data, False) op = blocks.transcendental("tanh", "float") - dst = gr.vector_sink_f() + dst = blocks.vector_sink_f() tb.connect(src, op) tb.connect(op, dst) diff --git a/gr-blocks/python/qa_type_conversions.py b/gr-blocks/python/qa_type_conversions.py index eb1b42b636..548ab33926 100755 --- a/gr-blocks/python/qa_type_conversions.py +++ b/gr-blocks/python/qa_type_conversions.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# Copyright 2012 Free Software Foundation, Inc. +# Copyright 2012,2013 Free Software Foundation, Inc. # # This file is part of GNU Radio # @@ -21,7 +21,7 @@ # from gnuradio import gr, gr_unittest -import blocks_swig +import blocks_swig as blocks from math import sqrt, atan2 class test_type_conversions(gr_unittest.TestCase): @@ -35,9 +35,9 @@ class test_type_conversions(gr_unittest.TestCase): 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 = gr.vector_source_b(src_data) - op = blocks_swig.char_to_float() - dst = gr.vector_sink_f() + 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()) @@ -45,9 +45,9 @@ class test_type_conversions(gr_unittest.TestCase): 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 = gr.vector_source_b(src_data) - op = blocks_swig.char_to_float(scale=2.0) - dst = gr.vector_sink_f() + 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()) @@ -55,9 +55,9 @@ class test_type_conversions(gr_unittest.TestCase): 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() + src = blocks.vector_source_b(src_data) + op = blocks.char_to_short() + dst = blocks.vector_sink_s() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data()) @@ -65,9 +65,9 @@ class test_type_conversions(gr_unittest.TestCase): 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() + src = blocks.vector_source_c(src_data) + op = blocks.complex_to_interleaved_short() + dst = blocks.vector_sink_s() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data()) @@ -75,9 +75,9 @@ class test_type_conversions(gr_unittest.TestCase): def test_complex_to_float_1(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 = gr.vector_source_c(src_data) - op = blocks_swig.complex_to_float() - dst = gr.vector_sink_f() + src = blocks.vector_source_c(src_data) + op = blocks.complex_to_float() + dst = blocks.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() self.assertFloatTuplesAlmostEqual(expected_data, dst.data()) @@ -86,10 +86,10 @@ class test_type_conversions(gr_unittest.TestCase): 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 = gr.vector_source_c(src_data) - op = blocks_swig.complex_to_float() - dst1 = gr.vector_sink_f() - dst2 = gr.vector_sink_f() + 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) @@ -100,9 +100,9 @@ class test_type_conversions(gr_unittest.TestCase): 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 = gr.vector_source_c(src_data) - op = blocks_swig.complex_to_real() - dst = gr.vector_sink_f() + 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()) @@ -110,9 +110,9 @@ class test_type_conversions(gr_unittest.TestCase): def test_complex_to_imag(self): src_data = (1+2j, 3+4j, 5+6j, 7+8j, 9+10j) expected_data = (2.0, 4.0, 6.0, 8.0, 10.0) - src = gr.vector_source_c(src_data) - op = blocks_swig.complex_to_imag() - dst = gr.vector_sink_f() + src = blocks.vector_source_c(src_data) + op = blocks.complex_to_imag() + dst = blocks.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() self.assertFloatTuplesAlmostEqual(expected_data, dst.data()) @@ -120,9 +120,9 @@ class test_type_conversions(gr_unittest.TestCase): 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 = gr.vector_source_c(src_data) - op = blocks_swig.complex_to_mag() - dst = gr.vector_sink_f() + 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) @@ -130,9 +130,9 @@ class test_type_conversions(gr_unittest.TestCase): 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 = gr.vector_source_c(src_data) - op = blocks_swig.complex_to_mag_squared() - dst = gr.vector_sink_f() + 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()) @@ -140,9 +140,9 @@ class test_type_conversions(gr_unittest.TestCase): 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 = gr.vector_source_c(src_data) - op = blocks_swig.complex_to_arg() - dst = gr.vector_sink_f() + 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) @@ -150,9 +150,9 @@ class test_type_conversions(gr_unittest.TestCase): def test_float_to_char_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_char() - dst = gr.vector_sink_b() + src = blocks.vector_source_f(src_data) + op = blocks.float_to_char() + dst = blocks.vector_sink_b() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data()) @@ -160,9 +160,9 @@ class test_type_conversions(gr_unittest.TestCase): def test_float_to_char_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_char(1, 5) - dst = gr.vector_sink_b() + src = blocks.vector_source_f(src_data) + op = blocks.float_to_char(1, 5) + dst = blocks.vector_sink_b() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data()) @@ -170,9 +170,9 @@ class test_type_conversions(gr_unittest.TestCase): def test_float_to_complex_1(self): src_data = (1.0, 3.0, 5.0, 7.0, 9.0) expected_data = (1+0j, 3+0j, 5+0j, 7+0j, 9+0j) - src = gr.vector_source_f(src_data) - op = blocks_swig.float_to_complex() - dst = gr.vector_sink_c() + src = blocks.vector_source_f(src_data) + op = blocks.float_to_complex() + dst = blocks.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() self.assertFloatTuplesAlmostEqual(expected_data, dst.data()) @@ -181,10 +181,10 @@ class test_type_conversions(gr_unittest.TestCase): src1_data = (1.0, 3.0, 5.0, 7.0, 9.0) src2_data = (2.0, 4.0, 6.0, 8.0, 10.0) expected_data = (1+2j, 3+4j, 5+6j, 7+8j, 9+10j) - src1 = gr.vector_source_f(src1_data) - src2 = gr.vector_source_f(src2_data) - op = blocks_swig.float_to_complex() - dst = gr.vector_sink_c() + src1 = blocks.vector_source_f(src1_data) + src2 = blocks.vector_source_f(src2_data) + op = blocks.float_to_complex() + dst = blocks.vector_sink_c() self.tb.connect(src1, (op, 0)) self.tb.connect(src2, (op, 1)) self.tb.connect(op, dst) @@ -194,9 +194,9 @@ class test_type_conversions(gr_unittest.TestCase): def test_float_to_int_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_int() - dst = gr.vector_sink_i() + src = blocks.vector_source_f(src_data) + op = blocks.float_to_int() + dst = blocks.vector_sink_i() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data()) @@ -204,9 +204,9 @@ class test_type_conversions(gr_unittest.TestCase): def test_float_to_int_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_int(1, 5) - dst = gr.vector_sink_i() + src = blocks.vector_source_f(src_data) + op = blocks.float_to_int(1, 5) + dst = blocks.vector_sink_i() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data()) @@ -214,9 +214,9 @@ class test_type_conversions(gr_unittest.TestCase): 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() + src = blocks.vector_source_f(src_data) + op = blocks.float_to_short() + dst = blocks.vector_sink_s() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data()) @@ -224,9 +224,9 @@ class test_type_conversions(gr_unittest.TestCase): 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() + src = blocks.vector_source_f(src_data) + op = blocks.float_to_short(1, 5) + dst = blocks.vector_sink_s() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data()) @@ -234,9 +234,9 @@ class test_type_conversions(gr_unittest.TestCase): def test_float_to_uchar(self): src_data = (1.0, -2.0, 3.0, -4.0, 256.0) expected_data = (1, 0, 3, 0, 255) - src = gr.vector_source_f(src_data) - op = blocks_swig.float_to_uchar() - dst = gr.vector_sink_b() + src = blocks.vector_source_f(src_data) + op = blocks.float_to_uchar() + dst = blocks.vector_sink_b() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data()) @@ -244,9 +244,9 @@ class test_type_conversions(gr_unittest.TestCase): 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() + src = blocks.vector_source_i(src_data) + op = blocks.int_to_float() + dst = blocks.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() self.assertFloatTuplesAlmostEqual(expected_data, dst.data()) @@ -254,9 +254,9 @@ class test_type_conversions(gr_unittest.TestCase): 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() + 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()) @@ -264,9 +264,9 @@ class test_type_conversions(gr_unittest.TestCase): def test_interleaved_short_to_complex(self): src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) expected_data = (1+2j, 3+4j, 5+6j, 7+8j, 9+10j) - src = gr.vector_source_s(src_data) - op = blocks_swig.interleaved_short_to_complex() - dst = gr.vector_sink_c() + src = blocks.vector_source_s(src_data) + op = blocks.interleaved_short_to_complex() + dst = blocks.vector_sink_c() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data()) @@ -274,9 +274,9 @@ class test_type_conversions(gr_unittest.TestCase): def test_short_to_char(self): src_data = (256, 512, 768, 1024, 1280) expected_data = (1, 2, 3, 4, 5) - src = gr.vector_source_s(src_data) - op = blocks_swig.short_to_char() - dst = gr.vector_sink_b() + src = blocks.vector_source_s(src_data) + op = blocks.short_to_char() + dst = blocks.vector_sink_b() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data()) @@ -284,9 +284,9 @@ class test_type_conversions(gr_unittest.TestCase): def test_short_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_s(src_data) - op = blocks_swig.short_to_float() - dst = gr.vector_sink_f() + src = blocks.vector_source_s(src_data) + op = blocks.short_to_float() + dst = blocks.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data()) @@ -294,9 +294,9 @@ class test_type_conversions(gr_unittest.TestCase): def test_short_to_float_scale(self): src_data = (5, 10, 15, 20, 25) expected_data = (1.0, 2.0, 3.0, 4.0, 5.0) - src = gr.vector_source_s(src_data) - op = blocks_swig.short_to_float(1, 5) - dst = gr.vector_sink_f() + 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()) @@ -304,9 +304,9 @@ class test_type_conversions(gr_unittest.TestCase): def test_uchar_to_float(self): src_data = (1, 2, 3, 4, 5) expected_data = (1.0, 2.0, 3.0, 4.0, 5.0) - src = gr.vector_source_b(src_data) - op = blocks_swig.uchar_to_float() - dst = gr.vector_sink_f() + src = blocks.vector_source_b(src_data) + op = blocks.uchar_to_float() + dst = blocks.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_data, dst.data()) diff --git a/gr-blocks/python/qa_udp_source_sink.py b/gr-blocks/python/qa_udp_source_sink.py index 8c5fa28217..ac8a9d0eb1 100644 --- a/gr-blocks/python/qa_udp_source_sink.py +++ b/gr-blocks/python/qa_udp_source_sink.py @@ -45,7 +45,7 @@ class test_udp_sink_source(gr_unittest.TestCase): n_data = 16 src_data = [x for x in range(n_data)] expected_result = tuple(src_data) - src = gr.vector_source_s(src_data, False) + src = blocks.vector_source_s(src_data, False) udp_snd = blocks.udp_sink(gr.sizeof_short, 'localhost', port) self.tb_snd.connect(src, udp_snd) @@ -62,12 +62,12 @@ class test_udp_sink_source(gr_unittest.TestCase): n_data = 100 src_data = [float(x) for x in range(n_data)] expected_result = tuple(src_data) - src = gr.vector_source_f(src_data, False) + 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 = gr.vector_sink_f() + dst = blocks.vector_sink_f() self.tb_rcv.connect(udp_rcv, dst) self.tb_rcv.start() @@ -93,8 +93,8 @@ class test_udp_sink_source(gr_unittest.TestCase): n_data = 16 src_data = [float(x) for x in range(n_data)] expected_result = tuple(src_data) - src = gr.vector_source_f(src_data) - dst = gr.vector_sink_f() + 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) diff --git a/gr-blocks/python/qa_unpack_k_bits.py b/gr-blocks/python/qa_unpack_k_bits.py index e038d5a03a..dd7024f74c 100755 --- a/gr-blocks/python/qa_unpack_k_bits.py +++ b/gr-blocks/python/qa_unpack_k_bits.py @@ -35,9 +35,9 @@ class test_unpack(gr_unittest.TestCase): def test_001(self): src_data = (1,0,1,1,0,1,1,0) expected_results = (1,0,1,1,0,1,1,0) - src = gr.vector_source_b(src_data,False) + src = blocks.vector_source_b(src_data,False) op = blocks.unpack_k_bits_bb(1) - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_results, dst.data()) @@ -45,9 +45,9 @@ class test_unpack(gr_unittest.TestCase): def test_002(self): src_data = ( 2, 3, 0, 1) expected_results = (1,0,1,1,0,0,0,1) - src = gr.vector_source_b(src_data,False) + src = blocks.vector_source_b(src_data,False) op = blocks.unpack_k_bits_bb(2) - dst = gr.vector_sink_b() + dst = blocks.vector_sink_b() self.tb.connect(src, op, dst) self.tb.run() self.assertEqual(expected_results, dst.data()) diff --git a/gr-blocks/python/qa_vco.py b/gr-blocks/python/qa_vco.py index 721eb9471b..23ff636d86 100644 --- a/gr-blocks/python/qa_vco.py +++ b/gr-blocks/python/qa_vco.py @@ -21,7 +21,7 @@ # from gnuradio import gr, gr_unittest -import blocks_swig +import blocks_swig as blocks import math def sig_source_f(samp_rate, freq, amp, N): @@ -43,9 +43,9 @@ class test_vco(gr_unittest.TestCase): sig_source_f(1, 0.125, 1, 200) + \ sig_source_f(1, 0.25, 1, 200) - src = gr.vector_source_f(src_data) - op = blocks_swig.vco_f(1, math.pi/2.0, 1) - dst = gr.vector_sink_f() + src = blocks.vector_source_f(src_data) + op = blocks.vco_f(1, math.pi/2.0, 1) + dst = blocks.vector_sink_f() self.tb.connect(src, op, dst) self.tb.run() diff --git a/gr-blocks/python/qa_vector_insert.py b/gr-blocks/python/qa_vector_insert.py index 428a0031ba..e3c0d3102f 100755 --- a/gr-blocks/python/qa_vector_insert.py +++ b/gr-blocks/python/qa_vector_insert.py @@ -39,8 +39,8 @@ class test_vector_insert(gr_unittest.TestCase): period = 9177; offset = 0; - src = gr.null_source(1) - head = gr.head(1, 10000000); + src = blocks.null_source(1) + head = blocks.head(1, 10000000); ins = blocks.vector_insert_b([1], period, offset); dst = blocks.vector_sink_b() |