示例#1
0
    def test_000(self):
        N = 1000         # number of samples to use
        M = 5            # Number of channels
        fs = 1000        # baseband sampling rate
        ifs = M*fs       # input samp rate to decimator
        channel = 0      # Extract channel 0

        #taps = filter.firdes.low_pass_2(1, ifs, fs/2, fs/10,
        #                                attenuation_dB=80,
        #                                window=filter.firdes.WIN_BLACKMAN_hARRIS)
        from pfb_decimator_taps import taps

        signals = list()
        add = gr.add_cc(inputs=5)
        freqs = [-200, -100, 0, 100, 200]
        for i in xrange(len(freqs)):
            f = freqs[i] + (M/2-M+i+1)*fs
            signals.append(gr.sig_source_c(ifs, gr.GR_SIN_WAVE, f, 1))
            self.tb.connect(signals[i], (add,i))

        head = gr.head(gr.sizeof_gr_complex, N)
        s2ss = gr.stream_to_streams_comp(gr.sizeof_gr_complex, M)
        pfb = filter.pfb_decimator_ccf(M, taps, channel)
        snk = gr.vector_sink_c()

        self.tb.connect(add, head, s2ss)
        for i in xrange(M):
            self.tb.connect((s2ss,i), (pfb,i))
        self.tb.connect(pfb, snk)

        self.tb.run() 

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

        # Create known data as complex sinusoids for the baseband freq
        # of the extracted channel is due to decimator output order.
        phase = 0
        expected_data = map(lambda x: math.cos(2.*math.pi*freqs[2]*x+phase) + \
                                1j*math.sin(2.*math.pi*freqs[2]*x+phase), t)

        dst_data = snk.data()

        self.assertComplexTuplesAlmostEqual(expected_data[-Ntest:], dst_data[-Ntest:], 4)
    def test_002_s_4(self):

        #Test streams_to_stream (using stream_to_streams).

        n = 4
        src_len = n * 8
        src_data = tuple(range(src_len))
        expected_results = src_data

        src = gr.vector_source_s(src_data)
        op1 = gr.stream_to_streams_comp(gr.sizeof_short, n)
        op2 = gr.streams_to_stream_comp(gr.sizeof_short, n)
        dst = gr.vector_sink_s()

        self.tb.connect(src, op1)
        for i in range(n):
            self.tb.connect((op1, i), (op2, i))
        self.tb.connect(op2, dst)

        self.tb.run()
        self.assertEqual(expected_results, dst.data())
    def test_003_f_1(self):
        #Test streams_to_vector (using stream_to_streams & vector_to_stream).

        n = 1
        src_len = n * 8
        src_data = tuple(range(src_len))
        expected_results = src_data

        src = gr.vector_source_f(src_data)
        op1 = gr.stream_to_streams_comp(gr.sizeof_float, n)
        op2 = gr.streams_to_vector_comp(gr.sizeof_float, n)
        op3 = gr.vector_to_stream_comp(gr.sizeof_float, n)
        dst = gr.vector_sink_f()

        self.tb.connect(src, op1)
        for i in range(n):
            self.tb.connect((op1, i), (op2, i))
        self.tb.connect(op2, op3, dst)

        self.tb.run()
        self.assertEqual(expected_results, dst.data())
    def test_003_f_1(self):
        #Test streams_to_vector (using stream_to_streams & vector_to_stream).
        
        n = 1
        src_len = n * 8
        src_data = tuple(range(src_len))
        expected_results = src_data

        src = gr.vector_source_f(src_data)
        op1 = gr.stream_to_streams_comp(gr.sizeof_float, n)
        op2 = gr.streams_to_vector_comp(gr.sizeof_float, n)
        op3 = gr.vector_to_stream_comp(gr.sizeof_float, n)
        dst = gr.vector_sink_f()

        self.tb.connect(src, op1)
        for i in range(n):
            self.tb.connect((op1, i), (op2, i))
        self.tb.connect(op2, op3, dst)

        self.tb.run()
        self.assertEqual(expected_results, dst.data())
    def test_002_s_4(self):
        
        #Test streams_to_stream (using stream_to_streams).
        
        n = 4
        src_len = n * 8
        src_data = tuple(range(src_len))
        expected_results = src_data

        src = gr.vector_source_s(src_data)
        op1 = gr.stream_to_streams_comp(gr.sizeof_short, n)
        op2 = gr.streams_to_stream_comp(gr.sizeof_short, n)
        dst = gr.vector_sink_s()

        self.tb.connect(src, op1)
        for i in range(n):
            self.tb.connect((op1, i), (op2, i))
        self.tb.connect(op2, dst)

        self.tb.run()
        self.assertEqual(expected_results, dst.data())
    def test_001_f(self):

        #Test stream_to_streams.

        n = 4
        src_len = n * 8
        src_data = range(src_len)

        expected_results = calc_expected_result(src_data, n)
        src = gr.vector_source_f(src_data)
        op = gr.stream_to_streams_comp(gr.sizeof_float, n)
        self.tb.connect(src, op)

        dsts = []
        for i in range(n):
            dst = gr.vector_sink_f()
            self.tb.connect((op, i), (dst, 0))
            dsts.append(dst)

        self.tb.run()

        for d in range(n):
            self.assertEqual(expected_results[d], dsts[d].data())
    def test_001_f(self):
        
        #Test stream_to_streams.
        
        n = 4
        src_len = n * 8
        src_data = range(src_len)

        expected_results = calc_expected_result(src_data, n)
        src = gr.vector_source_f(src_data)
        op = gr.stream_to_streams_comp(gr.sizeof_float, n)
        self.tb.connect(src, op)

        dsts = []
        for i in range(n):
            dst = gr.vector_sink_f()
            self.tb.connect((op, i), (dst, 0))
            dsts.append(dst)

        self.tb.run()

        for d in range(n):
            self.assertEqual(expected_results[d], dsts[d].data())
示例#8
0
    def test_000(self):
        N = 1000         # number of samples to use
        M = 5            # Number of channels to channelize
        fs = 1000        # baseband sampling rate
        ifs = M*fs       # input samp rate to channelizer

        #taps = filter.firdes.low_pass_2(1, ifs, 500, 50,
        #                                attenuation_dB=80,
        #                                window=filter.firdes.WIN_BLACKMAN_hARRIS)
        from pfb_channelizer_taps import taps

        signals = list()
        add = gr.add_cc(inputs=5)
        freqs = [-200, -100, 0, 100, 200]
        for i in xrange(len(freqs)):
            f = freqs[i] + (M/2-M+i+1)*fs
            signals.append(gr.sig_source_c(ifs, gr.GR_SIN_WAVE, f, 1))
            self.tb.connect(signals[i], (add,i))

        head = gr.head(gr.sizeof_gr_complex, N)
        s2ss = gr.stream_to_streams_comp(gr.sizeof_gr_complex, M)
        pfb = filter.pfb_channelizer_ccf(M, taps, 1)

        self.tb.connect(add, head, s2ss)

        snks = list()
        for i in xrange(M):
            snks.append(gr.vector_sink_c())
            self.tb.connect((s2ss,i), (pfb,i))
            self.tb.connect((pfb, i), snks[i])

        self.tb.run() 

        Ntest = 50
        L = len(snks[0].data())
        t = map(lambda x: float(x)/fs, xrange(L))

        # Adjusted phase rotations for data
        p0 = 0
        p1 =  math.pi*0.51998885
        p2 = -math.pi*0.96002233
        p3 =  math.pi*0.96002233
        p4 = -math.pi*0.51998885

        # Create known data as complex sinusoids at the different baseband freqs
        # the different channel numbering is due to channelizer output order.
        expected0_data = map(lambda x: math.cos(2.*math.pi*freqs[2]*x+p0) + \
                                       1j*math.sin(2.*math.pi*freqs[2]*x+p0), t)
        expected1_data = map(lambda x: math.cos(2.*math.pi*freqs[3]*x+p1) + \
                                       1j*math.sin(2.*math.pi*freqs[3]*x+p1), t)
        expected2_data = map(lambda x: math.cos(2.*math.pi*freqs[4]*x+p2) + \
                                       1j*math.sin(2.*math.pi*freqs[4]*x+p2), t)
        expected3_data = map(lambda x: math.cos(2.*math.pi*freqs[0]*x+p3) + \
                                       1j*math.sin(2.*math.pi*freqs[0]*x+p3), t)
        expected4_data = map(lambda x: math.cos(2.*math.pi*freqs[1]*x+p4) + \
                                       1j*math.sin(2.*math.pi*freqs[1]*x+p4), t)

        dst0_data = snks[0].data()
        dst1_data = snks[1].data()
        dst2_data = snks[2].data()
        dst3_data = snks[3].data()
        dst4_data = snks[4].data()

        self.assertComplexTuplesAlmostEqual(expected0_data[-Ntest:], dst0_data[-Ntest:], 3)
        self.assertComplexTuplesAlmostEqual(expected1_data[-Ntest:], dst1_data[-Ntest:], 3)
        self.assertComplexTuplesAlmostEqual(expected2_data[-Ntest:], dst2_data[-Ntest:], 3)
        self.assertComplexTuplesAlmostEqual(expected3_data[-Ntest:], dst3_data[-Ntest:], 3)
        self.assertComplexTuplesAlmostEqual(expected4_data[-Ntest:], dst4_data[-Ntest:], 3)