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)
signals = list()
add = blocks.add_cc()
freqs = [-200, -100, 0, 100, 200]
for i in xrange(len(freqs)):
f = freqs[i] + (M / 2 - M + i + 1) * fs
data = sig_source_c(ifs, f, 1, N)
signals.append(blocks.vector_source_c(data))
self.tb.connect(signals[i], (add, i))
head = blocks.head(gr.sizeof_gr_complex, N)
s2ss = blocks.stream_to_streams(gr.sizeof_gr_complex, M)
pfb = filter.pfb_decimator_ccf(M, taps, channel)
snk = blocks.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_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)
signals = list()
add = blocks.add_cc()
freqs = [-200, -100, 0, 100, 200]
for i in xrange(len(freqs)):
f = freqs[i] + (M/2-M+i+1)*fs
data = sig_source_c(ifs, f, 1, N)
signals.append(blocks.vector_source_c(data))
self.tb.connect(signals[i], (add,i))
head = blocks.head(gr.sizeof_gr_complex, N)
s2ss = blocks.stream_to_streams(gr.sizeof_gr_complex, M)
pfb = filter.pfb_decimator_ccf(M, taps, channel)
snk = blocks.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(self):
# Test streams_to_stream (using stream_to_streams).
n = 8
src_len = n * 8
src_data = tuple(range(src_len))
expected_results = 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 = blocks.vector_sink_i()
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_002(self):
# Test streams_to_stream (using stream_to_streams).
n = 8
src_len = n * 8
src_data = tuple(range(src_len))
expected_results = 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 = blocks.vector_sink_i()
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(self):
"""
Test stream_to_streams.
"""
n = 8
src_len = n * 8
src_data = range(src_len)
expected_results = calc_expected_result(src_data, n)
#print "expected results: ", expected_results
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 = blocks.vector_sink_i()
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(self):
"""
Test stream_to_streams.
"""
n = 8
src_len = n * 8
src_data = range(src_len)
expected_results = calc_expected_result(src_data, n)
#print "expected results: ", expected_results
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 = blocks.vector_sink_i()
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)
signals = list()
add = blocks.add_cc()
freqs = [-200, -100, 0, 100, 200]
for i in xrange(len(freqs)):
f = freqs[i] + (M/2-M+i+1)*fs
data = sig_source_c(ifs, f, 1, N)
signals.append(blocks.vector_source_c(data))
self.tb.connect(signals[i], (add,i))
s2ss = blocks.stream_to_streams(gr.sizeof_gr_complex, M)
pfb = filter.pfb_channelizer_ccf(M, taps, 1)
self.tb.connect(add, s2ss)
snks = list()
for i in xrange(M):
snks.append(blocks.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)