def test_003_ff(self):
        N = 10000        # number of samples to use
        fs = 1000        # baseband sampling rate
        rrate = 1.123    # resampling rate

        freq = 10
        data = sig_source_f(fs, freq, 1, N)
        ctrl = const_source_f(rrate, N)
        signal = blocks.vector_source_f(data)
        control = blocks.vector_source_f(ctrl)
        op = filter.fractional_resampler_ff(0, 1)
        snk = blocks.vector_sink_f()

        self.tb.connect(signal, op, snk)
        self.tb.connect(control, (op,1))
        self.tb.run() 

        Ntest = 5000
        L = len(snk.data())
        t = map(lambda x: float(x)/(fs/rrate), xrange(L))

        phase = 0.1884
        expected_data = map(lambda x: math.sin(2.*math.pi*freq*x+phase), t)

        dst_data = snk.data()

        self.assertFloatTuplesAlmostEqual(expected_data[-Ntest:], dst_data[-Ntest:], 3)
Example #2
0
 def test_interleaving(self):
     # Takes 3 streams (a, b and c)
     # Outputs 2 streams.
     # First (d) is interleaving of a and b.
     # Second (e) is interleaving of a and b and c.  c is taken in
     #     chunks of 2 which are reversed.
     A = (1, 2, 3, 4, 5)
     B = (11, 12, 13, 14, 15)
     C = (99, 98, 97, 96, 95, 94, 93, 92, 91, 90)
     expected_D = (1, 11, 2, 12, 3, 13, 4, 14, 5, 15)
     expected_E = (1, 11, 98, 99, 2, 12, 96, 97, 3, 13, 94, 95,
                   4, 14, 92, 93, 5, 15, 90, 91)
     mapping = [[(0, 0), (1, 0)], # mapping to produce D
                [(0, 0), (1, 0), (2, 1), (2, 0)], # mapping to produce E
                ]
     srcA = blocks.vector_source_f(A, False, 1)
     srcB = blocks.vector_source_f(B, False, 1)
     srcC = blocks.vector_source_f(C, False, 2)
     vmap =  blocks.vector_map(gr.sizeof_int, (1, 1, 2), mapping)
     dstD = blocks.vector_sink_f(2)
     dstE = blocks.vector_sink_f(4)
     self.tb.connect(srcA, (vmap, 0))
     self.tb.connect(srcB, (vmap, 1))
     self.tb.connect(srcC, (vmap, 2))
     self.tb.connect((vmap, 0), dstD)
     self.tb.connect((vmap, 1), dstE)
     self.tb.run()
     self.assertEqual(expected_D, dstD.data())
     self.assertEqual(expected_E, dstE.data())
 def test_preserve_tag_head_pos(self):
     """ Test the 'preserve head position' function.
     This will add a 'special' tag to item 0 on stream 1.
     It should be on item 0 of the output stream. """
     special_tag = gr.tag_t()
     special_tag.key = pmt.string_to_symbol('spam')
     special_tag.offset = 0
     special_tag.value = pmt.to_pmt('eggs')
     len_tag_key = "length"
     packet_len_1 = 5
     packet_len_2 = 3
     mux = blocks.tagged_stream_mux(gr.sizeof_float, len_tag_key, 1)
     sink = blocks.vector_sink_f()
     self.tb.connect(
         blocks.vector_source_f(range(packet_len_1)),
         blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len_1, len_tag_key),
         (mux, 0)
     )
     self.tb.connect(
         blocks.vector_source_f(range(packet_len_2), False, 1, (special_tag,)),
         blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len_2, len_tag_key),
         (mux, 1)
     )
     self.tb.connect(mux, sink)
     self.tb.run()
     self.assertEqual(sink.data(), tuple(range(packet_len_1) + range(packet_len_2)))
     tags = [gr.tag_to_python(x) for x in sink.tags()]
     tags = sorted([(x.offset, x.key, x.value) for x in tags])
     tags_expected = [
             (0, 'length', packet_len_1 + packet_len_2),
             (0, 'spam', 'eggs'),
     ]
     self.assertEqual(tags, tags_expected)
    def test_003_filter_delay_two_inputs(self):
        # give two different inputs
        tb = self.tb

        sampling_freq = 100
        ntaps = 51
        N = int(ntaps + sampling_freq * 0.10)

        data1 = sin_source_f(sampling_freq, sampling_freq * 0.10, 1.0, N)
        data2 = cos_source_f(sampling_freq, sampling_freq * 0.10, 1.0, N)
        src1 = blocks.vector_source_f(data1)
        src2 = blocks.vector_source_f(data2)

        taps = filter.firdes.hilbert(ntaps, filter.firdes.WIN_HAMMING)
        hd = filter.filter_delay_fc(taps)

        expected_result = fir_filter2(data1, data2, taps, (ntaps-1)/2)

        dst2 = blocks.vector_sink_c()

        tb.connect(src1, (hd,0))
        tb.connect(src2, (hd,1))
        tb.connect(hd, dst2)

        tb.run()

        # get output
        result_data = dst2.data()

        self.assertComplexTuplesAlmostEqual(expected_result, result_data, 5)
Example #5
0
    def help_stream_tag_propagation(self, N, stream_sizes):
        src_data1           = stream_sizes[0]*N*[1,]
        src_data2           = stream_sizes[1]*N*[2,]
        src_data3           = stream_sizes[2]*N*[3,]
    # stream_mux scheme (3,2,4)
        src1 = blocks.vector_source_f(src_data1)
        src2 = blocks.vector_source_f(src_data2)
        src3 = blocks.vector_source_f(src_data3)
        tag_stream1 = blocks.stream_to_tagged_stream(gr.sizeof_float, 1,
                                                     stream_sizes[0], 'src1')
        tag_stream2 = blocks.stream_to_tagged_stream(gr.sizeof_float, 1,
                                                     stream_sizes[1], 'src2')
        tag_stream3 = blocks.stream_to_tagged_stream(gr.sizeof_float, 1,
                                                     stream_sizes[2], 'src3')

        mux = blocks.stream_mux(gr.sizeof_float, stream_sizes)
        dst = blocks.vector_sink_f()

        self.tb.connect(src1, tag_stream1)
        self.tb.connect(src2, tag_stream2)
        self.tb.connect(src3, tag_stream3)
        self.tb.connect(tag_stream1, (mux,0))
        self.tb.connect(tag_stream2, (mux,1))
        self.tb.connect(tag_stream3, (mux,2))
        self.tb.connect(mux, dst)
        self.tb.run()

        return (dst.data (), dst.tags ())
Example #6
0
    def test_001(self):
        tb = self.tb

        src1_data = (0,0.2,-0.3,0,12,0)
        src2_data = (0,0.0,3.0,0,10,0)
        src3_data = (0,0.0,3.0,0,1,0)

        src1 = blocks.vector_source_f(src1_data)
        s2v1 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data))
        tb.connect(src1, s2v1)

        src2 = blocks.vector_source_f(src2_data)
        s2v2 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data))
        tb.connect(src2, s2v2)

        src3 = blocks.vector_source_f(src3_data)
        s2v3 = blocks.stream_to_vector(gr.sizeof_float, len(src1_data))
        tb.connect(src3, s2v3)

        dst1 = blocks.vector_sink_s()
        dst2 = blocks.vector_sink_s()
        argmax = blocks.argmax_fs(len(src1_data))

        tb.connect(s2v1, (argmax, 0))
        tb.connect(s2v2, (argmax, 1))
        tb.connect(s2v3, (argmax, 2))

        tb.connect((argmax,0), dst1)
        tb.connect((argmax,1), dst2)

        tb.run()
        index = dst1.data()
        source = dst2.data()
        self.assertEqual(index, (4,))
        self.assertEqual(source, (0,))
Example #7
0
    def test_003_square3_ff(self):
        src_data0 = (0, 1, 0, 1, 0)
        src_data1 = (-3.0, 4.0, -5.5, 2.0, 3.0)
        src_data2 = (2.0, 2.0, 2.0, 2.0, 2.0)
        src_data3 = (2.7, 2.7, 2.1, 2.3, 2.5)
        expected_result0 = (-3.0, 2.0, -5.5, 2.0, 3.0)
        expected_result1 = (-3.0, 2.7, -5.5, 2.3, 3.0)
        src0 = blocks.vector_source_f(src_data0)
        src1 = blocks.vector_source_f(src_data1)
        src2 = blocks.vector_source_f(src_data2)
        src3 = blocks.vector_source_f(src_data3)
        sqr = square3_ff()
        dst0 = blocks.vector_sink_f()
        dst1 = blocks.vector_sink_f()
        self.tb.connect(src0, (sqr, 0))
        self.tb.connect(src1, (sqr, 1))
        self.tb.connect(src2, (sqr, 2))
        self.tb.connect(src3, (sqr, 3))
        self.tb.connect((sqr, 0), dst0)
        self.tb.connect((sqr, 1), dst1)
        self.tb.run()
        result_data0 = dst0.data()
        result_data1 = dst1.data()
        from pudb import set_trace

        set_trace()
        self.assertFloatTuplesAlmostEqual(expected_result0, result_data0, 6)
        self.assertFloatTuplesAlmostEqual(expected_result1, result_data1, 6)
Example #8
0
    def test_001_t (self):
        M = 4
        mu = 0.02
        s = [ 0.0, 0.3090170, 0.5877853, 0.8090170, 0.9510565, 1.0, 0.9510565, 0.8090170, 0.5877853,
              0.3090170, 1.225E-16, -0.3090170, -0.5877853, -0.8090170, -0.9510565, -1.0, -0.9510565,
              -0.8090170, -0.5877853, -0.3090170, -2.449E-16 ]
        x = [ 0.1869771, 0.3164567, 0.5817531, 0.7321207, 0.9280425, 0.9442921, 0.7227481, 0.7236329,
              0.4502919, 0.4182683, 0.1211515, -0.3072967, -0.6598651, -0.5849396, -0.8081715, -1.0660516,
              -0.9508943, -0.7868964, -0.4899220, -0.3765086, 0.0794150 ]
        y_expected = [ 0.0, 0.0, 0.0030070, 0.0198613, 0.0684855, 0.1548310, 0.2389200, 0.3069399, 0.3028421,
              0.2665137, 0.1899010, 0.0551109, -0.0944788, -0.2088661, -0.3248339, -0.4673856, -0.5688788,
              -0.6141125, -0.5422770, -0.4194642, -0.2149493 ]

        x_src = blocks.vector_source_f(x, False)
        s_src = blocks.vector_source_f(s, False)
        eq_lms = eq.eq_lms_ff(M, mu, False)
        dst = blocks.vector_sink_f()

        self.tb.connect((x_src, 0), (eq_lms, 0))
        self.tb.connect((s_src, 0), (eq_lms, 1))
        self.tb.connect((eq_lms, 0), (dst, 0))

        self.tb.run ()

        y = dst.data()

        self.assertFloatTuplesAlmostEqual(y_expected, y, 6)
 def test_preserve_tag_head_pos(self):
     """ Test the 'preserve head position' function.
     This will add a 'special' tag to item 0 on stream 1.
     It should be on item 0 of the output stream. """
     packet_len_0 = 5
     data0 = range(packet_len_0)
     packet_len_1 = 3
     data1 = range(packet_len_1)
     mux = blocks.tagged_stream_mux(
             gr.sizeof_float,
             self.tsb_key,
             1 # Mark port 1 as carrying special tags on the head position
     )
     sink = blocks.tsb_vector_sink_f(tsb_key=self.tsb_key)
     self.tb.connect(
         blocks.vector_source_f(data0),
         blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len_0, self.tsb_key),
         (mux, 0)
     )
     self.tb.connect(
         blocks.vector_source_f(range(packet_len_1), tags=(make_tag('spam', 'eggs', 0),)),
         blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len_1, self.tsb_key),
         (mux, 1)
     )
     self.tb.connect(mux, sink)
     self.tb.run()
     self.assertEqual(len(sink.data()), 1)
     self.assertEqual(sink.data()[0], tuple(data0 + data1))
     self.assertEqual(len(sink.tags()), 1)
     tag = gr.tag_to_python(sink.tags()[0])
     tag = (tag.offset, tag.key, tag.value)
     tag_expected = (0, 'spam', 'eggs')
     self.assertEqual(tag, tag_expected)
Example #10
0
    def test_int_002 (self):
        blksize = 4
        lenx = 64
        plusup_big = lambda a: a + (blksize * 4)
        plusup_little = lambda a: a + blksize
        a_vec = range(0,blksize)
        for i in range(0,(lenx/(4 * blksize)) - 1):
            a_vec += map(plusup_big, a_vec[len(a_vec) - blksize:])

        b_vec = map(plusup_little, a_vec)
        c_vec = map(plusup_little, b_vec)
        d_vec = map(plusup_little, c_vec)

        src0 = blocks.vector_source_f (a_vec)
        src1 = blocks.vector_source_f (b_vec)
        src2 = blocks.vector_source_f (c_vec)
        src3 = blocks.vector_source_f (d_vec)
        op = blocks.interleave (gr.sizeof_float, blksize)
        dst = blocks.vector_sink_f ()

        self.tb.connect (src0, (op, 0))
        self.tb.connect (src1, (op, 1))
        self.tb.connect (src2, (op, 2))
        self.tb.connect (src3, (op, 3))
        self.tb.connect (op, dst)
        self.tb.run ()
        expected_result = tuple (range (lenx))
        result_data = dst.data ()

        self.assertFloatTuplesAlmostEqual (expected_result, result_data)
    def __init__(self):
        gr.top_block.__init__(self)

        self.qapp = QtGui.QApplication(sys.argv)

        data0  = 10*[0,] + 40*[1,0] + 10*[0,]
        data0 += 10*[0,] + 40*[0,1] + 10*[0,]
        data1 = 20*[0,] + [0,0,0,1,1,1,0,0,0,0] + 70*[0,]

        # Adjust these to change the layout of the plot.
        # Can be set to fractions.
        ncols = 100.25
        nrows = 100

        fs = 200
        src0 = blocks.vector_source_f(data0, True)
        src1 = blocks.vector_source_f(data1, True)
        thr = blocks.throttle(gr.sizeof_float, 50000)
        hed = blocks.head(gr.sizeof_float, 10000000)
        self.snk1 = qtgui.time_raster_sink_f(fs, nrows, ncols, [], [],
                                             "Float Time Raster Example", 2)

        self.connect(src0, thr, (self.snk1, 0))
        self.connect(src1, (self.snk1, 1))

        # Get the reference pointer to the SpectrumDisplayForm QWidget
        pyQt = self.snk1.pyqwidget()

        # Wrap the pointer as a PyQt SIP object
        # This can now be manipulated as a PyQt4.QtGui.QWidget
        pyWin = sip.wrapinstance(pyQt, QtGui.QWidget)

        self.main_box = dialog_box(pyWin)
        self.main_box.show()
Example #12
0
    def test_stretch_01(self):
        tb = self.tb

        data = 10*[1,]
        data0 = map(lambda x: x/20.0, data)
        data1 = map(lambda x: x/10.0, data)

        expected_result0 = 10*[0.05,]
        expected_result1 = 10*[0.1,]

        src0 = blocks.vector_source_f(data0, False)
        src1 = blocks.vector_source_f(data1, False)
        inter = blocks.streams_to_vector(gr.sizeof_float, 2)
        op = blocks.stretch_ff(0.1, 2)
        deinter = blocks.vector_to_streams(gr.sizeof_float, 2)
        dst0 = blocks.vector_sink_f()
        dst1 = blocks.vector_sink_f()
        
        tb.connect(src0, (inter,0))
        tb.connect(src1, (inter,1))
        tb.connect(inter, op)
        tb.connect(op, deinter)
        tb.connect((deinter,0), dst0)
        tb.connect((deinter,1), dst1)
        tb.run()

        dst0_data = dst0.data()
        dst1_data = dst1.data()

        self.assertFloatTuplesAlmostEqual(expected_result0, dst0_data, 4)
        self.assertFloatTuplesAlmostEqual(expected_result1, dst1_data, 4)
 def test_001_t (self):
     src_data0 = (20,121,210,11,110)
     src_data1 = (-3.0, 4.0, -5.5, 2.0, 3.0)
     src_data2 = (2.0, 2.0, 2.0, 2.0, 2.0)
     src_data3 = (2.7, 2.7, 2.1, 2.3, 2.5)
     expected_result0 = (-3.0, 2.0, 2.0, 2.0, 2.0)
     expected_result1 = (-3.0, 2.7, 2.1, 2.0, 2.5)
     src0 = blocks.vector_source_f (src_data0)
     src1 = blocks.vector_source_f (src_data1)
     src2 = blocks.vector_source_f (src_data2)
     src3 = blocks.vector_source_f (src_data3)
     switch = FM_stereo_mono_switch (75.0)
     dst0 = blocks.vector_sink_f ()
     dst1 = blocks.vector_sink_f ()
     self.tb.connect (src0, (switch,0))
     self.tb.connect (src1,(switch,1))
     self.tb.connect (src2,(switch,2))
     self.tb.connect (src3,(switch,3))
     self.tb.connect ((switch,0), dst0)
     self.tb.connect ((switch,1), dst1)
     self.tb.run ()
     result_data0 = dst0.data ()
     result_data1 = dst1.data ()
     #from pudb import set_trace; set_trace()
     self.assertFloatTuplesAlmostEqual (expected_result0, result_data0, 6)
     self.assertFloatTuplesAlmostEqual (expected_result1, result_data1, 6)
    def test_002_t (self):
        #This tests multiple streams, to make sure it outputs the same input from before
        numstreams=3
        src_data0=(1.0,2.0,3.0)
        src_data1=(4.0,5.0,6.0)
        src_data2=(7.0,8.0,9.0)
        expected_result0=(1.0,2.0,3.0)
        src0 = blocks.vector_source_f(src_data0)
        src1 = blocks.vector_source_f(src_data1)
        src2 = blocks.vector_source_f(src_data2)
        blk = testblocks.streams_to_streams_ff(numstreams)
        dst0 = blocks.vector_sink_f()
        dst1 = blocks.vector_sink_f()
        dst2 = blocks.vector_sink_f()

        self.tb.connect(src0, (blk,0) )
        self.tb.connect(src1, (blk,1) )
        self.tb.connect(src2, (blk,2) )                
        self.tb.connect((blk,0), dst0)
        self.tb.connect((blk,1), dst1)
        self.tb.connect((blk,2), dst2)
        
        self.tb.run()
        result_data0 = dst0.data()
        result_data1 = dst1.data()
        result_data2 = dst2.data()
        # check data
        print result_data0
        self.assertFloatTuplesAlmostEqual(expected_result0, result_data0, 6)
Example #15
0
 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))
Example #16
0
 def test_largeN_ff(self):
     stream_sizes = [3, 8191]
     r1 = (1,) * stream_sizes[0]
     r2 = (2,) * stream_sizes[1]
     v0 = blocks.vector_source_f(r1, repeat=False)
     v1 = blocks.vector_source_f(r2, repeat=False)
     mux = blocks.stream_mux(gr.sizeof_float, stream_sizes)
     dst = blocks.vector_sink_f ()
     self.tb.connect (v0, (mux,0))
     self.tb.connect (v1, (mux,1))
     self.tb.connect (mux, dst)
     self.tb.run ()
     self.assertEqual (r1 + r2, dst.data())
 def test_float_to_complex_2(self):
     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 = 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)
     self.tb.run()
     self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
Example #18
0
    def help_stream_2ff(self, N, stream_sizes):
        v0 = blocks.vector_source_f(N*[1,], False)
        v1 = blocks.vector_source_f(N*[2,], False)

        mux = blocks.stream_mux(gr.sizeof_float, stream_sizes)

        dst = blocks.vector_sink_f ()

        self.tb.connect (v0, (mux,0))
        self.tb.connect (v1, (mux,1))
        self.tb.connect (mux, dst)
        self.tb.run ()

        return dst.data ()
 def setUp (self):
     self.tb = gr.top_block()
     self.dut = prioritizer(False)
     self.src0 = blocks.vector_source_f([0.0], repeat = True)
     self.src1 = blocks.vector_source_f([1.0], repeat = True)
     self.throttle0 = blocks.throttle(gr.sizeof_float, 1e6)
     self.throttle1 = blocks.throttle(gr.sizeof_float, 1e4) ## 1/100 of the 0 rate
     self.head = blocks.head(gr.sizeof_float, int(1e4)) # about one second
     self.sink = blocks.vector_sink_f()
     self.tb.connect(self.src0, self.throttle0)
     self.tb.connect(self.src1, self.throttle1)
     self.tb.connect(self.throttle0, (self.dut,0))
     self.tb.connect(self.throttle1, (self.dut,1))
     self.tb.connect(self.dut, self. head, self.sink)
 def test_001_t (self):
     # set up fg
     src = blocks.vector_source_f([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1])
     src_th = blocks.vector_source_f([0,0,0,1,1,1,1,1,1,1,1,1,1,1,1])
     dut = capture_tools.annotate_every_n_samples_from_trigger_ff(3, 2)
     dst = blocks.vector_sink_f()
     self.tb.connect(src,(dut, 0))
     self.tb.connect(src_th,(dut, 1))
     self.tb.connect(dut, dst)
     self.tb.run ()
     print(dst.data())
     print(dst.tags())
     for t in dst.tags():
         print(t.key)
         print(t.offset)
    def test_001_t (self):
        test = ieee802154g.preamble_detector(8)

        # typical preamble cycle, at 8 samples per symbol.
        num_cycles = 20
        data = num_cycles * [-0.098, -0.064, 0.064, 0.093, 0.081, 0.071, 0.069, 0.065, 0.070, 0.037, -0.087, -0.118, -0.105, -0.101, -0.099, -0.095]
        src = blocks.vector_source_f(data, False)
        snk = blocks.vector_sink_f()

        self.tb.connect(src, test, snk)
        self.tb.run ()

        dst_data = snk.data()
        # check data
        assert len(dst_data) == num_cycles * 2
        cnt = 0
        locked = False
        pos = False
        for n in dst_data:
            if not locked:
                if n > 0.08:    # found peak positive
                    locked = True
                    pos = True
                elif cnt > 24:
                    assert False, "failed to lock"
                    break
            else:
                if pos:
                    assert n < 0
                else:
                    assert n > 0
                pos = not pos
            cnt += 1
    def test_003_stream(self):
        print("test_003_stream")
        nframes = 5
        expo = 8
        block_size = 2 ** expo
        num_info_bits = 2 ** (expo - 1)
        max_list_size = 2 ** (expo - 2)
        num_frozen_bits = block_size - num_info_bits
        frozen_bit_positions = cc.frozen_bit_positions(block_size, num_info_bits, 0.0)
        frozen_bit_values = np.array([0] * num_frozen_bits,)

        encoder = PolarEncoder(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)

        ref = np.array([], dtype=int)
        data = np.array([], dtype=int)
        for i in range(nframes):
            b = np.random.randint(2, size=num_info_bits)
            d = encoder.encode(b)
            data = np.append(data, d)
            ref = np.append(ref, b)
        gr_data = 2.0 * data - 1.0

        polar_decoder = fec.polar_decoder_sc_list.make(max_list_size, block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)
        src = blocks.vector_source_f(gr_data, False)
        dec_block = extended_decoder(polar_decoder, None)
        snk = blocks.vector_sink_b(1)

        self.tb.connect(src, dec_block)
        self.tb.connect(dec_block, snk)
        self.tb.run()

        res = np.array(snk.data()).astype(dtype=int)
        self.assertTupleEqual(tuple(res), tuple(ref))
Example #23
0
    def test_deint_001 (self):
        lenx = 64
        src = blocks.vector_source_f (range (lenx))
        op = blocks.deinterleave (gr.sizeof_float)
        dst0 = blocks.vector_sink_f ()
        dst1 = blocks.vector_sink_f ()
        dst2 = blocks.vector_sink_f ()
        dst3 = blocks.vector_sink_f ()

        self.tb.connect (src, op)
        self.tb.connect ((op, 0), dst0)
        self.tb.connect ((op, 1), dst1)
        self.tb.connect ((op, 2), dst2)
        self.tb.connect ((op, 3), dst3)
        self.tb.run ()

        expected_result0 = tuple (range (0, lenx, 4))
        expected_result1 = tuple (range (1, lenx, 4))
        expected_result2 = tuple (range (2, lenx, 4))
        expected_result3 = tuple (range (3, lenx, 4))

        self.assertFloatTuplesAlmostEqual (expected_result0, dst0.data ())
        self.assertFloatTuplesAlmostEqual (expected_result1, dst1.data ())
        self.assertFloatTuplesAlmostEqual (expected_result2, dst2.data ())
        self.assertFloatTuplesAlmostEqual (expected_result3, dst3.data ())
Example #24
0
    def test02(self):
        # Test float/float version
        omega = 2
        gain_omega = 0.01
        mu = 0.5
        gain_mu = 0.01
        omega_rel_lim = 0.001

        self.test = digital.clock_recovery_mm_ff(omega, gain_omega,
                                                 mu, gain_mu,
                                                 omega_rel_lim)
        
        data = 100*[1,]
        self.src = blocks.vector_source_f(data, False)
        self.snk = blocks.vector_sink_f()

        self.tb.connect(self.src, self.test, self.snk)
        self.tb.run()
        
        expected_result = 100*[0.99972, ] # doesn't quite get to 1.0
        dst_data = self.snk.data()

        # Only compare last Ncmp samples
        Ncmp = 30
        len_e = len(expected_result)
        len_d = len(dst_data)
        expected_result = expected_result[len_e - Ncmp:]
        dst_data = dst_data[len_d - Ncmp:]

        #print expected_result
        #print dst_data
        
        self.assertFloatTuplesAlmostEqual(expected_result, dst_data, 5)
    def test_002_one_vector(self):
        print("test_002_one_vector")
        expo = 6
        block_size = 2 ** expo
        num_info_bits = 2 ** (expo - 1)
        max_list_size = 2 ** (expo - 2)
        num_frozen_bits = block_size - num_info_bits
        frozen_bit_positions = cc.frozen_bit_positions(block_size, num_info_bits, 0.0)
        frozen_bit_values = np.array([0] * num_frozen_bits,)

        bits = np.random.randint(2, size=num_info_bits)
        encoder = PolarEncoder(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)
        data = encoder.encode(bits)
        gr_data = 2.0 * data - 1.0

        polar_decoder = fec.polar_decoder_sc_list.make(max_list_size, block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)
        src = blocks.vector_source_f(gr_data, False)
        dec_block = extended_decoder(polar_decoder, None)
        snk = blocks.vector_sink_b(1)

        self.tb.connect(src, dec_block)
        self.tb.connect(dec_block, snk)
        self.tb.run()

        res = np.array(snk.data()).astype(dtype=int)

        print("\ninput -> result -> bits")
        print(data)
        print(res)
        print(bits)

        self.assertTupleEqual(tuple(res), tuple(bits))
Example #26
0
    def test_fff_000(self):
        N = 500         # number of samples to use
        fs = 5000.0     # baseband sampling rate
        rrate = 2.3421  # resampling rate

        nfilts = 32
        taps = filter.firdes.low_pass_2(nfilts, nfilts*fs, fs/2, fs/10,
                                        attenuation_dB=80,
                                        window=filter.firdes.WIN_BLACKMAN_hARRIS)

        freq = 121.213
        data = sig_source_f(fs, freq, 1, N)
        signal = blocks.vector_source_f(data)
        pfb = filter.pfb_arb_resampler_fff(rrate, taps, nfilts)
        snk = blocks.vector_sink_f()

        self.tb.connect(signal, pfb, snk)
        self.tb.run() 

        Ntest = 50
        L = len(snk.data())

        # Get group delay and estimate of phase offset from the filter itself.
        delay = pfb.group_delay()
        phase = pfb.phase_offset(freq, fs)
        
        # Create a timeline offset by the filter's group delay
        t = map(lambda x: float(x)/(fs*rrate), xrange(delay, L+delay))

        # Data of the sinusoid at frequency freq with the delay and phase offset.
        expected_data = map(lambda x: math.sin(2.*math.pi*freq*x+phase), t)

        dst_data = snk.data()

        self.assertFloatTuplesAlmostEqual(expected_data[-Ntest:], dst_data[-Ntest:], 2)
Example #27
0
    def test_001_t (self):
        count = 2
        interval = 1000
        msg_list = [pmt.string_to_symbol('hello')] * count
        src_data = [1.0] * (count * interval)

        src = blocks.vector_source_f(src_data, False)
        msg_gen = message_generator(msg_list, interval)
        msg_cons = varicode_enc_b()

        dest = blocks.vector_sink_b()

        self.tb.connect(src, msg_gen)
        self.tb.connect(msg_cons, dest)

        self.tb.msg_connect(msg_gen, 'out_port', msg_cons, 'in_port')

        self.tb.run()

        print "Msg Ctr:", msg_gen.msg_ctr
        while msg_gen.msg_ctr < count:
            print "Msg Ctr:", msg_gen.msg_ctr
            time.sleep(0.5)
        print "Msg Ctr:", msg_gen.msg_ctr

        self.tb.stop()
        self.tb.wait()

        print 'Output Data:', dest.data()
Example #28
0
 def test_fir_filter_fff_001(self):
     src_data = 40*[1, 2, 3, 4]
     expected_data = (0.5, 1.5, 3.0, 5.0, 5.5, 6.5, 8.0, 10.0,
                      10.5, 11.5, 13.0, 15.0, 15.5, 16.5, 18.0,
                      20.0, 20.5, 21.5, 23.0, 25.0, 25.5, 26.5,
                      28.0, 30.0, 30.5, 31.5, 33.0, 35.0, 35.5,
                      36.5, 38.0, 40.0, 40.5, 41.5, 43.0, 45.0,
                      45.5, 46.5, 48.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
                      50.0, 50.0, 50.0, 50.0, 50.0)
     src = blocks.vector_source_f(src_data)
     op  = filter.fir_filter_fff(1, 20*[0.5, 0.5])
     dst = blocks.vector_sink_f()
     self.tb.connect(src, op, dst)
     self.tb.run()
     result_data = dst.data()
     self.assertFloatTuplesAlmostEqual(expected_data, result_data, 5)
Example #29
0
    def test_003_t (self):
        vec_len = 3
        my_select = 2
        src_data = (1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,1.0,10.0,100.0)
        expected_result = (3.0,6.0,9.0,100.0)

        src = blocks.vector_source_f(src_data)
        s2v = blocks.stream_to_vector(gr.sizeof_float, vec_len)
        blk = testblocks.vec_select(vec_len, my_select)
        dst = blocks.vector_sink_f()
        
        blk.set_select(3)
        
        self.tb.connect(src, s2v)
        self.tb.connect(s2v, blk)
        self.tb.connect(blk, dst)
        self.tb.run()
        result_data = dst.data()
        print "T3 Source: "
        print str(src_data).strip('[]')
        print "T3 Expected Results: "
        print str(expected_result).strip('[]')
        print "T3 Results: "
        print str(result_data).strip('[]')
        self.assertFloatTuplesAlmostEqual(expected_result, result_data, 6)
    def test_file_descriptor(self):
        src_data = range(1000)
        expected_result = range(1000)

        snk2 = blocks.vector_sink_f()

        with tempfile.NamedTemporaryFile() as temp:
            fhandle0 = open(temp.name, "wb")
            fd0 = fhandle0.fileno()

            src = blocks.vector_source_f(src_data)
            snk = blocks.file_descriptor_sink(gr.sizeof_float, fd0)

            self.tb.connect(src, snk)
            self.tb.run()
            os.fsync(fd0)
            fhandle0.close()

            fhandle1 = open(temp.name, "rb")
            fd1 = fhandle1.fileno()
            src2 = blocks.file_descriptor_source(gr.sizeof_float, fd1, False)

            self.tb.disconnect(src, snk)
            self.tb.connect(src2, snk2)
            self.tb.run()
            os.fsync(fd1)
            fhandle1.close()

        result_data = snk2.data()
        self.assertFloatTuplesAlmostEqual(expected_result, result_data)
        self.assertEqual(len(snk2.tags()), 0)
Example #31
0
    def test_001_t(self):
        # data
        self.vector_length = 10
        self.data = (0, 2, 4, 6, 8, 10, 12, 14, 16, 18)
        self.expected = (2)

        # blocks
        self.src = blocks.vector_source_f(self.data, False, self.vector_length)
        self.slope = xcorr.linearslope_ff(self.vector_length)
        self.snk = blocks.vector_sink_f()

        # connections
        self.tb.connect(self.src, self.slope, self.snk)
        self.tb.run()

        # check data
        self.result = self.snk.data()
        self.assertAlmostEqual(self.expected, self.result[0], 3)
Example #32
0
 def test_001 (self):
     vlen = 10
     self.rx_data = None
     src_data = list(range(vlen))*100
     src = blocks.vector_source_f(src_data, False, vlen)
     zeromq_pub_sink = zeromq.pub_sink(gr.sizeof_float, vlen, "tcp://127.0.0.1:0")
     address = zeromq_pub_sink.last_endpoint()
     self.tb.connect(src, zeromq_pub_sink)
     self.probe_manager = zeromq.probe_manager()
     self.probe_manager.add_socket(address, 'float32', self.recv_data)
     zmq_pull_t = threading.Thread(target=self.probe_manager.watcher)
     zmq_pull_t.daemon = True
     zmq_pull_t.start()
     self.tb.run()
     zmq_pull_t.join(6.0)
     # Check to see if we timed out
     self.assertFalse(zmq_pull_t.is_alive())
     self.assertFloatTuplesAlmostEqual(self.rx_data, src_data)
Example #33
0
    def test_deinterleave(self):
        tb = self.tb

        # set up fg
        cols, rows = 4, 10
        vec = sum((rows * [x,] for x in range(cols)), [])
        expected = rows * list(range(cols))

        src = blocks.vector_source_f(vec, False)
        itlv = matrix_interleaver(gr.sizeof_float, rows=rows, cols=cols, deint=True)
        snk = blocks.vector_sink_f()

        tb.connect(src, itlv, snk)
        tb.run()
        result = snk.data()

        # check data
        self.assertFloatTuplesAlmostEqual(expected, result)
Example #34
0
 def test_largeN_ff(self):
     stream_sizes = [3, 8191]
     r0 = [
         1.0,
     ] * stream_sizes[0]
     r1 = [
         2.0,
     ] * stream_sizes[1]
     v = blocks.vector_source_f(r0 + r1, repeat=False)
     demux = blocks.stream_demux(gr.sizeof_float, stream_sizes)
     dst0 = blocks.vector_sink_f()
     dst1 = blocks.vector_sink_f()
     self.tb.connect(v, demux)
     self.tb.connect((demux, 0), dst0)
     self.tb.connect((demux, 1), dst1)
     self.tb.run()
     self.assertEqual(r0, dst0.data())
     self.assertEqual(r1, dst1.data())
Example #35
0
    def help_stream_2ff(self, N, stream_sizes):
        v = blocks.vector_source_f(N * [
            1,
        ] + N * [
            2,
        ], False)

        demux = blocks.stream_demux(gr.sizeof_float, stream_sizes)

        dst0 = blocks.vector_sink_f()
        dst1 = blocks.vector_sink_f()

        self.tb.connect(v, demux)
        self.tb.connect((demux, 0), dst0)
        self.tb.connect((demux, 1), dst1)
        self.tb.run()

        return (dst0.data(), dst1.data())
    def test_fff(self):
        taps = [1, 10, 100, 1000, 10000]
        src_data = (0, 2, 3, 5, 7, 11, 13, 17)
        interpolation = 3
        xr = (0, 0, 0, 2, 20, 200, 2003, 20030, 300, 3005, 30050, 500, 5007,
              50070, 700, 7011, 70110, 1100, 11013, 110130, 1300, 13017,
              130170)
        expected_result = tuple([float(x) for x in xr])

        src = blocks.vector_source_f(src_data)
        op = filter.interp_fir_filter_fff(interpolation, taps)
        dst = blocks.vector_sink_f()
        self.tb.connect(src, op)
        self.tb.connect(op, dst)
        self.tb.run()
        result_data = dst.data()
        L = min(len(result_data), len(expected_result))
        self.assertEqual(expected_result[0:L], result_data[0:L])
Example #37
0
    def test_001_t(self):
        """
        test 256 bit packet
        """
        # set up fg
        data_in = range(256)  # np.random.randint(0, 2, size=256)
        key = pmt.intern("len_tag")
        val = pmt.from_long(256)
        tag = gr.tag_utils.python_to_tag((0, key, val))
        self.src = blocks.vector_source_f(data_in, False, 1, [tag])
        self.deintlvr = lpwan.dsss_deinterleaver_ff("len_tag")
        self.snk = blocks.vector_sink_f(1)
        self.tb.connect(self.src, self.deintlvr, self.snk)
        self.tb.run()

        # check data
        self.assertFloatTuplesAlmostEqual(dsss_const.intlvr_seq_256,
                                          self.snk.data()[0:256])
Example #38
0
    def test_002(self):
        self.maxDiff = None
        tb = gr.top_block()
        src = blocks.vector_source_f(list(range(0, 100)))

        km = []
        snk = []
        for i in range(5):
            km.append(streamops.keep_m_in_n(3, 5, i))
            snk.append(blocks.vector_sink_f())
            tb.connect((src, km[i], snk[i]))
        tb.run()

        for i in range(5):
            self.assertEqual(
                sorted(
                    list(range(i, 100, 5)) + list(range((i + 1) % 5, 100, 5)) +
                    list(range((i + 2) % 5, 100, 5))), list(snk[i].data()))
Example #39
0
    def test_002_(self):
        src_data = numpy.array(
            [-1.0, -1.0 / 2.0, -1.0 / 3.0, -1.0 / 4.0, -1.0 / 5.0])
        trg_data = copy.deepcopy(src_data)

        src = blocks.vector_source_f(src_data, False, len(src_data))
        st = blocks.stretch_ff(-1.0 / 5.0, len(src_data))
        dst = blocks.vector_sink_f(len(src_data))
        self.tb.connect(src, st)
        self.tb.connect(st, dst)
        self.tb.run()
        rsl_data = dst.data()
        sum = 0
        for (u, v) in zip(trg_data, rsl_data):
            w = u - v
            sum += w * w
        sum /= float(len(trg_data))
        assert sum < 1e-6
 def test_002_t(self):
     # set up fg
     trig_data = (0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1)
     dataforw = (1, 2, 3, 4, 5)
     databack = (5, 4, 3, 2, 1)
     expected_result = (0, 0, -1, -2, -3, -4, -5, 0, 1, 2, 3, 4, 1)
     trig_src = blocks.vector_source_f(trig_data)
     triggeredvecsrc = Maran.triggered_vector_source(databack, -1, 2, 2)
     testdata = triggeredvecsrc.data()
     self.assertFloatTuplesAlmostEqual(databack, testdata, 0)
     triggeredvecsrc.set_data(dataforw)
     testdata = triggeredvecsrc.data()
     self.assertFloatTuplesAlmostEqual(dataforw, testdata, 0)
     dst = blocks.vector_sink_c()
     self.tb.connect(trig_src, triggeredvecsrc, dst)
     self.tb.run()
     result_data = dst.data()
     self.assertFloatTuplesAlmostEqual(expected_result, result_data, 0)
    def test_001_t(self):
        # data
        self.vector_length = 5
        self.data = (1.1, 2.1, 3.1, 4.1, 5.1)
        self.expected = (1.1, 2.1, 3.1, 4.1, 5.1)

        # blocks
        self.src = blocks.vector_source_f(self.data)
        self.hold = doa.hold_ff(False)
        self.snk = blocks.vector_sink_f()

        # connections
        self.tb.connect(self.src, self.hold, self.snk)
        self.tb.run()

        # check data
        self.results = self.snk.data()
        self.assertFloatTuplesAlmostEqual(self.expected, self.results, 3)
    def test_002_t(self):
        # data
        self.vector_length = 5
        self.data = (1.2, 2.2, 3.2, 4.2, 5.2)
        self.expected = (0, 0, 0, 0, 0)

        # blocks
        self.src = blocks.vector_source_f(self.data)
        self.hold = doa.hold_ff(True)
        self.snk = blocks.vector_sink_f()

        # connections
        self.tb.connect(self.src, self.hold, self.snk)
        self.tb.run()

        # check data
        self.results = self.snk.data()
        self.assertFloatTuplesAlmostEqual(self.expected, self.results)
    def test_001_t(self):
        # set up fg
        senal_entrante = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                          16, 17, 18, 19, 20)
        src = blocks.vector_source_f(senal_entrante)
        diez = diezma_ff(4)
        snk = blocks.vector_sink_f()
        self.tb.connect(src, diez)
        self.tb.connect(diez, snk)

        # Aqui va lo que querramos incluir para probar y encontrar fallas, como prints.
        self.tb.run()
        senal_salida = snk.data()
        salida_esperada = (1, 5, 9, 13, 17)
        print("la respuesta; ", senal_salida)
        print("la esperada; ", salida_esperada)

        self.assertFloatTuplesAlmostEqual(salida_esperada, senal_salida, 6)
Example #44
0
    def test_001_t(self):
        # data
        self.data = (3.0000, -3.0000, 1.1000, -1.1000, 0)
        self.expected = (-1.2694, 1.2694, -0.3577, 0.3577, 0)

        # blocks
        self.src = blocks.vector_source_f(self.data)
        self.p2d = xcorr.phase2xcorr_ff(.5)
        self.snk = blocks.vector_sink_f()

        # connections
        self.tb.connect(self.src, self.p2d)
        self.tb.connect(self.p2d, self.snk)
        self.tb.run()

        # check data
        self.results = self.snk.data()
        self.assertFloatTuplesAlmostEqual(self.expected, self.results, 3)
Example #45
0
    def test_001_interp(self):
        taps = [1, 10, 100, 1000, 10000]
        src_data = (0, 2, 3, 5, 7, 11, 13, 17)
        interpolation = 3
        xr = (2, 20, 200, 2003, 20030, 300, 3005, 30050, 500, 5007, 50070, 700,
              7011, 70110, 1100, 11013, 110130, 1300, 13017, 130170, 1700.0,
              17000.0, 170000.0, 0.0)
        expected_result = tuple([float(x) for x in xr])

        tb = gr.top_block()
        src = blocks.vector_source_f(src_data)
        op = filter.rational_resampler_base_fff(interpolation, 1, taps)
        dst = blocks.vector_sink_f()
        tb.connect(src, op)
        tb.connect(op, dst)
        tb.run()
        result_data = dst.data()
        self.assertEqual(expected_result, result_data)
Example #46
0
    def test_f_000(self):
        # Test normal operation of the float puncture block

        self.puncsize = 8
        self.puncpat = 0xEF
        self.delay = 0

        self.puncture_setup()

        src = blocks.vector_source_f(self.src_data)
        op  = fec.puncture_ff(self.puncsize, self.puncpat, self.delay)
        dst = blocks.vector_sink_f()

        self.tb.connect(src, op, dst)
        self.tb.run()

        dst_data = list(dst.data())
        self.assertEqual(self.expected, dst_data)
    def test_001(self):
        src_data = 10 * [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 2, 1]
        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 = blocks.vector_source_f(src_data)
        ctrl = blocks.vector_source_b(ctrl_data)
        op = blocks.sample_and_hold_ff()
        dst = blocks.vector_sink_f()

        self.tb.connect(src, (op, 0))
        self.tb.connect(ctrl, (op, 1))
        self.tb.connect(op, dst)
        self.tb.run()

        result = dst.data()
        self.assertFloatTuplesAlmostEqual(expected_result, result, places=6)
Example #48
0
 def test_001_t(self):
     packet_len = 4
     data = list(range(2 * packet_len))
     tag = gr.tag_t()
     tag.key = pmt.intern("foo")
     tag.offset = 5
     tag.value = pmt.intern("bar")
     src = blocks.vector_source_f(data, tags=(tag, ))
     sink = blocks.tsb_vector_sink_f(tsb_key=self.tsb_key)
     self.tb.connect(
         src,
         blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len,
                                        self.tsb_key), sink)
     self.tb.run()
     self.assertEqual((tuple(data[0:packet_len]), tuple(data[packet_len:])),
                      sink.data())
     self.assertEqual(len(sink.tags()), 1)
     self.assertEqual(sink.tags()[0].offset, tag.offset)
 def test_002_correct_individual_phase_offset_vff(self):
     data = [x * pi / 2 + pi / 4 for x in [1, -2, -1, 0, 1, -2]]
     src_data = map(lambda x, y: x + y, data,
                    [0.1, 0.3, -0.4, 0.2, 0.4, 0.1])
     expected_result = map(lambda x, y: x + y, data,
                           [0.05, 0.15, -0.2, 0.075, 0.125, 0.15])
     src = blocks.vector_source_f(src_data)
     s2v = blocks.stream_to_vector(gr.sizeof_float, 3)
     mut = grdab.correct_individual_phase_offset_vff(3, 0.5)
     v2s = blocks.vector_to_stream(gr.sizeof_float, 3)
     dst = blocks.vector_sink_f()
     self.tb.connect(src, s2v, mut, v2s, dst)
     self.tb.run()
     result_data = dst.data()
     # print src_data
     # print expected_result
     # print result_data
     self.assertFloatTuplesAlmostEqual(expected_result, result_data, 5)
Example #50
0
    def test_003_(self):
        src_grid = (0.0, 1.0, 2.0, 3.0, 4.0)
        trg_grid = copy.deepcopy(src_grid)
        src_data = (0.0, 1.0, 0.0, 1.0, 0.0)

        src = blocks.vector_source_f(src_data, False, len(src_grid))
        sq = wavelet.squash_ff(src_grid, trg_grid)
        dst = blocks.vector_sink_f(len(trg_grid))
        self.tb.connect(src, sq)
        self.tb.connect(sq, dst)
        self.tb.run()
        rsl_data = dst.data()
        sum = 0
        for (u, v) in zip(src_data, rsl_data):
            w = u - v
            sum += w * w
        sum /= float(len(src_data))
        assert sum < 1e-6
Example #51
0
    def test_001(self):
        nsamples = 100000
        input_data = list(range(nsamples))

        src = blocks.vector_source_f(input_data, False)
        hblock = hwrap()
        snk1 = blocks.vector_sink_f()
        snk2 = blocks.vector_sink_f()

        self.tb.connect(src, 0, hblock, 0)
        self.tb.connect(hblock, 0, snk1, 0)
        self.tb.connect(src, 0, hblock, 0)
        self.tb.connect(hblock, 1, snk2, 0)

        self.tb.run()

        self.assertEqual(input_data, snk1.data())
        self.assertEqual(input_data, snk2.data())
Example #52
0
    def test_01(self):
        tb = self.tb

        data = [0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 2, 2, 2]

        expected_result = [0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1]

        src = blocks.vector_source_f(data, False)
        op = blocks.threshold_ff(1, 1)
        dst = blocks.vector_sink_f()

        tb.connect(src, op)
        tb.connect(op, dst)
        tb.run()

        dst_data = dst.data()

        self.assertEqual(expected_result, dst_data)
Example #53
0
    def test_pwr_squelch_004(self):
        alpha = 0.0001
        thr = -25

        src_data = map(lambda x: float(x)/10.0, range(1, 40))
        src = blocks.vector_source_f(src_data)
        op = analog.pwr_squelch_ff(thr, alpha)
        dst = blocks.vector_sink_f()

        self.tb.connect(src, op)
        self.tb.connect(op, dst)
        self.tb.run()

        expected_result = src_data
        expected_result[0:20] = 20*[0,]

        result_data = dst.data()
        self.assertFloatTuplesAlmostEqual(expected_result, result_data, 4)
Example #54
0
 def test_001_t(self):
     src_data = [
         1,
     ] * 50
     packet_len = 10
     len_tag_key = 'packet_len'
     src = blocks.vector_source_f(src_data, False, 1)
     tagger = blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len,
                                             len_tag_key)
     sink = blocks.vector_sink_f()
     self.tb.connect(src, tagger, sink)
     self.tb.run()
     self.assertEqual(sink.data(), src_data)
     tags = [gr.tag_to_python(x) for x in sink.tags()]
     tags = sorted([(x.offset, x.key, x.value) for x in tags])
     expected_tags = [(int(pos), 'packet_len', packet_len)
                      for pos in range(0, 50, 10)]
     self.assertEqual(tags, expected_tags)
    def __init__(self):

        if choice == 1:
            self.num = 0
            self.g = 3
            self.p = 5
            self.x = 4
        if choice == 2:
            self.num = 0
            self.g = 5
            self.p = 7
            self.x = 5
        num = pow(self.g, self.x) % self.p
        print("g^x mod p=%d") % num
        gr.top_block.__init__(self, "Top Block")
        self.vector = blocks.vector_source_f((num, num, num), True, 1, [])
        self.packet = grc_blks2.packet_mod_f(grc_blks2.packet_encoder(
            samples_per_symbol=2,
            bits_per_symbol=1,
            preamble="",
            access_code="",
            pad_for_usrp=True),
                                             payload_length=256)
        self.mod = digital.gmsk_mod(samples_per_symbol=2,
                                    bt=0.35,
                                    verbose=False,
                                    log=False)
        self.sender = osmosdr.sink(args="numchan" + str(1) + "" + "")

        self.sender.set_sample_rate(1e6)
        self.sender.set_center_freq(100e6)
        self.sender.set_freq_corr(0, 0)
        self.sender.set_gain_mode(False, 0)
        self.sender.set_gain(20, 0)
        self.sender.set_if_gain(30, 0)
        self.sender.set_bb_gain(30, 0)
        self.sender.set_antenna("", 0)
        self.sender.set_bandwidth(0, 0)

        #connection

        self.connect((self.vector, 0), (self.packet, 0))
        self.connect((self.packet, 0), (self.mod, 0))
        self.connect((self.mod, 0), (self.sender, 0))
Example #56
0
    def test_002_t(self):
        self.vector_len = 2**12
        self.num_max_vals = 5

        # generate vector from octave
        oc = oct2py.Oct2Py()
        oc.addpath(os.path.dirname(__file__))
        data, expected_pks, expected_t_pks = oc.test002_findpeaks(
            self.num_max_vals, self.vector_len)
        data = data.flatten().tolist()

        ##################################################
        # Blocks
        ##################################################
        self.blocks_vector_source_x_0 = blocks.vector_source_f(
            data, False, self.vector_len, [])
        self.doa_find_local_max_0 = doa.find_local_max(self.num_max_vals,
                                                       self.vector_len, 0.0,
                                                       2 * numpy.pi)
        self.blocks_vector_sink_x_0 = blocks.vector_sink_f(self.num_max_vals)
        self.blocks_vector_sink_x_1 = blocks.vector_sink_f(self.num_max_vals)

        ##################################################
        # Connections
        ##################################################
        self.tb.connect((self.blocks_vector_source_x_0, 0),
                        (self.doa_find_local_max_0, 0))
        self.tb.connect((self.doa_find_local_max_0, 0),
                        (self.blocks_vector_sink_x_0, 0))
        self.tb.connect((self.doa_find_local_max_0, 1),
                        (self.blocks_vector_sink_x_1, 0))

        # set up fg
        self.tb.run()

        # get data from sink
        measured_pks = self.blocks_vector_sink_x_0.data()
        measured_pks_locs = self.blocks_vector_sink_x_1.data()

        # check data
        for i in range(len(measured_pks)):
            self.assertAlmostEqual(expected_pks[i], measured_pks[i],
                                   5) and self.assertAlmostEqual(
                                       expected_t_pks[i], measured_t_pks[i], 5)
Example #57
0
    def test_001_t(self):

        # Setup parameters of the System
        fsm = fsm_args["awgn1o2_16"]
        os = numpy.array(fsm[4], dtype=int)
        data = numpy.array([-5, -5, -5, -5, 5, 5, -5, 5, 5, -5])
        expected_data = numpy.array([0, 0, 0, 0, 1, 1, 0, 1, 1, 0])
        print data

        data_src = blocks.vector_source_f(map(float, data))

        # Set up TX
        src_head = blocks.head(gr.sizeof_float * 1, 10)

        shuffle = numpy.array([
            0,
            1,
            0,
            1,
            0,
            1,
            0,
            1,
            0,
            1,
            0,
            1,
            0,
            1,
            0,
            1,
        ],
                              dtype=int)
        # Setup RX
        max_log_map_cel = celec.max_log_map_f(2, 4, 10, 0, -1, shuffle, os)
        conv = blocks.float_to_char()
        rx_sink = blocks.vector_sink_f(1)

        self.tb.connect(data_src, src_head, max_log_map_cel, rx_sink)

        # set up fg
        self.tb.run()

        print rx_sink.data()
Example #58
0
    def test_peak1(self):
        #print "\n\nTEST 1"
        tb = self.tb

        n = 10
        data = (
            0,
            1,
            2,
            3,
            4,
            5,
            6,
            7,
            8,
            9,
            10,
            9,
            8,
            7,
            6,
            5,
            4,
            3,
            2,
            1,
            0,
        ) + n * (0, )

        expected_result = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
                           0, 0, 0, 0) + n * (0, )

        src = blocks.vector_source_f(data, False)
        regen = blocks.peak_detector2_fb(7.0, 25, 0.001)
        dst = blocks.vector_sink_b()

        tb.connect(src, regen)
        tb.connect(regen, dst)
        tb.run()

        dst_data = dst.data()

        self.assertEqual(expected_result, dst_data)
Example #59
0
 def test_002_t (self):
     # set up fg
     pi=np.pi
     data_in = [0, pi/2, pi, -pi/2, pi/2, -pi/2, -pi/2, 0, 0, pi, pi/2, pi/2]
     data_in = [i + pi/4 for i in data_in]
     self.src = blocks.vector_source_f(data_in)
     self.dqpsk = ie802_15_4.dqpsk_mapper_ff(framelen=6, forward=False)
     self.snk = blocks.vector_sink_f(1)
     self.tb.connect(self.src, self.dqpsk, self.snk)
     self.tb.run ()
     # check data
     data_out = self.snk.data()
     data_out = [np.exp(1j*i) for i in data_out]
     ref = [0, pi/2, pi, -pi/2, pi/2, pi, -pi/2, 0, 0, pi, pi, pi/2]
     ref = [np.exp(1j*i) for i in ref]
     # print "in:", data_in
     # print "out:", data_out
     # print "ref:", ref
     self.assertComplexTuplesAlmostEqual(ref, data_out, 5)       
    def test_002_one_vector(self):
        block_power = 4
        block_size = 2 ** block_power
        num_info_bits = block_size // 2
        frozen_bit_positions = cc.frozen_bit_positions(block_size, num_info_bits, 0.0)

        bits, gr_data = self.generate_test_data(block_size, num_info_bits, frozen_bit_positions, 1, False)

        polar_decoder = fec.polar_decoder_sc_systematic.make(block_size, num_info_bits, frozen_bit_positions)
        src = blocks.vector_source_f(gr_data, False)
        dec_block = extended_decoder(polar_decoder, None)
        snk = blocks.vector_sink_b(1)

        self.tb.connect(src, dec_block)
        self.tb.connect(dec_block, snk)
        self.tb.run()

        res = np.array(snk.data()).astype(dtype=int)
        self.assertTupleEqual(tuple(res), tuple(bits))