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