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_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)
def test_002_t (self):
vlen=16
skip=4
dc_null=2
ofdm_sym=2
expected_snr = ((1-0.01)/(0.01), (1-0.01)/(0.01))
expected_noise = (0.01, 0.01)
# define the blocks
src_data = [0.1]*(skip/2) + [skip] + [0.1]*(skip/2-1)
src_data = src_data * (vlen/skip)
src_data = [0]*(dc_null/2) + src_data[:(vlen/2-dc_null/2)] + src_data[(vlen/2+dc_null/2):] + [0]*(dc_null/2)
src_data = src_data * (ofdm_sym)
src = blocks.vector_source_c(src_data,False,vlen)
snr_estim = ofdm.snr_estimator_dc_null(vlen,skip,dc_null)
dst = blocks.vector_sink_f()
dst_noise = blocks.vector_sink_f()
# construct the flowgraph
self.tb.connect(src,snr_estim)
self.tb.connect((snr_estim,0),dst)
self.tb.connect((snr_estim,1),dst_noise)
# set up fg
self.tb.run ()
print "snr", dst.data()
print "noise", dst_noise.data()
# Compare with reference data from above
self.assertFloatTuplesAlmostEqual(dst.data(),expected_snr)
self.assertFloatTuplesAlmostEqual(dst_noise.data(),expected_noise)
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)
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_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_f_003(self):
# Test scenariou where we have defined a puncture pattern with
# more bits than the puncsize with a delay. The python code
# doesn't account for this when creating self.expected, but
# this should be equivalent to a puncpat of the correct size.
self.puncsize = 4
self.puncpat0 = 0x5555 # too many bits set
self.puncpat1 = 0x55 # num bits = puncsize
self.delay = 1
src = blocks.vector_source_f(self.src_data)
op0 = fec.puncture_ff(self.puncsize, self.puncpat0, self.delay)
op1 = fec.puncture_ff(self.puncsize, self.puncpat1, self.delay)
dst0 = blocks.vector_sink_f()
dst1 = blocks.vector_sink_f()
self.tb.connect(src, op0, dst0)
self.tb.connect(src, op1, dst1)
self.tb.run()
dst_data0 = list(dst0.data())
dst_data1 = list(dst1.data())
self.assertEqual(dst_data1, dst_data0)
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 ())
def __init__(self, N, sps, rolloff, ntaps, bw, noise, foffset, toffset, poffset):
gr.top_block.__init__(self)
rrc_taps = filter.firdes.root_raised_cosine(
sps, sps, 1.0, rolloff, ntaps)
data = 2.0*scipy.random.randint(0, 2, N) - 1.0
data = scipy.exp(1j*poffset) * data
self.src = blocks.vector_source_c(data.tolist(), False)
self.rrc = filter.interp_fir_filter_ccf(sps, rrc_taps)
self.chn = channels.channel_model(noise, foffset, toffset)
self.fll = digital.fll_band_edge_cc(sps, rolloff, ntaps, bw)
self.vsnk_src = blocks.vector_sink_c()
self.vsnk_fll = blocks.vector_sink_c()
self.vsnk_frq = blocks.vector_sink_f()
self.vsnk_phs = blocks.vector_sink_f()
self.vsnk_err = blocks.vector_sink_f()
self.connect(self.src, self.rrc, self.chn, self.fll, self.vsnk_fll)
self.connect(self.rrc, self.vsnk_src)
self.connect((self.fll,1), self.vsnk_frq)
self.connect((self.fll,2), self.vsnk_phs)
self.connect((self.fll,3), self.vsnk_err)
def test_001_t (self):
""" Simplest possible test: put in zeros, then header,
then payload, trigger signal, try to demux.
The return signal from the header parser is faked via _post()
Add in some tags for fun.
"""
n_zeros = 1
header = (1, 2, 3)
payload = tuple(range(5, 20))
data_signal = (0,) * n_zeros + header + payload
trigger_signal = [0,] * len(data_signal)
trigger_signal[n_zeros] = 1
# This is dropped:
testtag1 = make_tag('tag1', 0, 0)
# This goes on output 0, item 0:
testtag2 = make_tag('tag2', 23, n_zeros)
# This goes on output 0, item 2:
testtag3 = make_tag('tag3', 42, n_zeros + len(header) - 1)
# This goes on output 1, item 3:
testtag4 = make_tag('tag4', 314, n_zeros + len(header) + 3)
data_src = blocks.vector_source_f(
data_signal,
False,
tags=(testtag1, testtag2, testtag3, testtag4)
)
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(
len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float
)
mock_header_demod = HeaderToMessageBlock(
numpy.float32,
len(header),
[len(payload)]
)
self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you
payload_sink = blocks.vector_sink_f()
header_sink = blocks.vector_sink_f()
self.connect_all_blocks(data_src, trigger_src, hpd, mock_header_demod, payload_sink, header_sink)
self.run_tb(payload_sink, len(payload), header_sink, len(header))
self.assertEqual(header_sink.data(), header)
self.assertEqual(payload_sink.data(), payload)
ptags_header = []
for tag in header_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_header.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_header = [
{'key': 'tag2', 'offset': 0},
{'key': 'tag3', 'offset': 2},
]
self.assertEqual(expected_tags_header, ptags_header)
ptags_payload = []
for tag in payload_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_payload.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_payload = [
{'key': 'frame_len', 'offset': 0},
{'key': 'tag4', 'offset': 3},
]
self.assertEqual(expected_tags_payload, ptags_payload)
def test_001_t_tags (self):
""" Like the previous test, but use a trigger tag instead of
a trigger signal.
"""
n_zeros = 1
header = (1, 2, 3)
payload = tuple(range(5, 20))
data_signal = (0,) * n_zeros + header + payload
# Trigger tag
trigger_tag = make_tag('detect', True, n_zeros)
# This is dropped:
testtag1 = make_tag('tag1', 0, 0)
# This goes on output 0, item 0:
testtag2 = make_tag('tag2', 23, n_zeros)
# This goes on output 0, item 2:
testtag3 = make_tag('tag3', 42, n_zeros + len(header) - 1)
# This goes on output 1, item 3:
testtag4 = make_tag('tag4', 314, n_zeros + len(header) + 3)
data_src = blocks.vector_source_f(
data_signal,
False,
tags=(trigger_tag, testtag1, testtag2, testtag3, testtag4)
)
hpd = digital.header_payload_demux(
len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float
)
self.assertEqual(pmt.length(hpd.message_ports_in()), 2) #extra system port defined for you
header_sink = blocks.vector_sink_f()
payload_sink = blocks.vector_sink_f()
mock_header_demod = HeaderToMessageBlock(
numpy.float32,
len(header),
[len(payload)]
)
self.connect_all_blocks(data_src, None, hpd, mock_header_demod, payload_sink, header_sink)
self.run_tb(payload_sink, len(payload), header_sink, len(header))
# Check results
self.assertEqual(header_sink.data(), header)
self.assertEqual(payload_sink.data(), payload)
ptags_header = []
for tag in header_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_header.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_header = [
{'key': 'tag2', 'offset': 0},
{'key': 'tag3', 'offset': 2},
]
self.assertEqual(expected_tags_header, ptags_header)
ptags_payload = []
for tag in payload_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_payload.append({'key': ptag.key, 'offset': ptag.offset})
expected_tags_payload = [
{'key': 'frame_len', 'offset': 0},
{'key': 'tag4', 'offset': 3},
]
self.assertEqual(expected_tags_payload, ptags_payload)
def __init__(self, N, sps, rolloff, ntaps, bw, noise,
foffset, toffset, poffset, mode=0):
gr.top_block.__init__(self)
rrc_taps = filter.firdes.root_raised_cosine(
sps, sps, 1.0, rolloff, ntaps)
gain = bw
nfilts = 32
rrc_taps_rx = filter.firdes.root_raised_cosine(
nfilts, sps*nfilts, 1.0, rolloff, ntaps*nfilts)
data = 2.0*scipy.random.randint(0, 2, N) - 1.0
data = scipy.exp(1j*poffset) * data
self.src = blocks.vector_source_c(data.tolist(), False)
self.rrc = filter.interp_fir_filter_ccf(sps, rrc_taps)
self.chn = channels.channel_model(noise, foffset, toffset)
self.off = filter.fractional_resampler_cc(0.20, 1.0)
if mode == 0:
self.clk = digital.pfb_clock_sync_ccf(sps, gain, rrc_taps_rx,
nfilts, nfilts//2, 1)
self.taps = self.clk.taps()
self.dtaps = self.clk.diff_taps()
self.delay = int(scipy.ceil(((len(rrc_taps)-1)/2 +
(len(self.taps[0])-1)/2)/float(sps))) + 1
self.vsnk_err = blocks.vector_sink_f()
self.vsnk_rat = blocks.vector_sink_f()
self.vsnk_phs = blocks.vector_sink_f()
self.connect((self.clk,1), self.vsnk_err)
self.connect((self.clk,2), self.vsnk_rat)
self.connect((self.clk,3), self.vsnk_phs)
else: # mode == 1
mu = 0.5
gain_mu = bw
gain_omega = 0.25*gain_mu*gain_mu
omega_rel_lim = 0.02
self.clk = digital.clock_recovery_mm_cc(sps, gain_omega,
mu, gain_mu,
omega_rel_lim)
self.vsnk_err = blocks.vector_sink_f()
self.connect((self.clk,1), self.vsnk_err)
self.vsnk_src = blocks.vector_sink_c()
self.vsnk_clk = blocks.vector_sink_c()
self.connect(self.src, self.rrc, self.chn, self.off, self.clk, self.vsnk_clk)
self.connect(self.src, self.vsnk_src)
def test_non_sync_block(self):
tb = gr.top_block ()
src = blocks.vector_source_f(range(1000000))
sinks = [blocks.vector_sink_f(), blocks.vector_sink_f()]
dut = non_sync_block()
tb.connect(src, dut)
tb.connect((dut,0), sinks[0])
tb.connect((dut,1), sinks[1])
tb.run ()
self.assertEqual(len(sinks[0].data()), 2*len(sinks[1].data()))
def test_001_t (self):
d_vlen=4
d_skip=2
d_dc_null=2
sum_load=0
sum_null=0
#noise
noise=np.random.normal(0,1,1000)
src_data=[2,1]*10
# src_data=[sum(x) for x in zip(data,noise)]
src=blocks.vector_source_c(src_data,vlen=4)
snr=ofdm.snr_estimator(d_vlen,d_skip)
snr_dc_null=ofdm.snr_estimator_dc_null(d_vlen,d_skip,d_dc_null)
dst=blocks.vector_sink_f()
dst_noise=blocks.vector_sink_f()
dst_dc_null=blocks.vector_sink_f()
dst_dc_null_noise=blocks.vector_sink_f()
#construct the flowgraph
self.tb.connect(src,snr_dc_null)
self.tb.connect(src,snr)
self.tb.connect((snr_dc_null,0),dst_dc_null)
self.tb.connect((snr_dc_null,1),dst_dc_null_noise)
self.tb.connect((snr,0),dst)
self.tb.connect((snr,1),dst_noise)
# set up fg
self.tb.run ()
print "output", dst.data()
print "output dc_null", dst_dc_null.data()
# calculate reference data
dc_null_noise=dst_dc_null.data()
if not d_dc_null:
for index,number in enumerate(src_data):
square=number*number.conjugate()
if not index%d_skip:
sum_load+=square
else:
sum_null+=square
estim =(1./d_skip)*((d_skip-1)*sum_load/sum_null-1)
estim_noise = sum_null*d_skip/(d_skip-1)/d_vlen
else:
results=[0]*80
estim_noise=results
estim=results
#Compare with snr_estimator_block
self.assertEqual(dst_dc_null.data(),dst.data())
self.assertEqual(dst_dc_null_noise.data(),dst_noise.data())
def test_003_t (self):
"""
Like test 1, but twice, plus one fail
"""
n_zeros = 5
header = (1, 2, 3)
header_fail = (-1, -2, -4) # Contents don't really matter
payload1 = tuple(range(5, 20))
payload2 = (42,)
data_signal = (0,) * n_zeros + header + payload1
trigger_signal = [0,] * len(data_signal) * 2
trigger_signal[n_zeros] = 1
trigger_signal[len(data_signal)] = 1
trigger_signal[len(data_signal)+len(header_fail)+n_zeros] = 1
tx_signal = data_signal + header_fail + (0,) * n_zeros + header + payload2 + (0,) * 1000
data_src = blocks.vector_source_f(tx_signal, False)
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(
len(header), 1, 0, "frame_len", "detect", False, gr.sizeof_float
)
self.assertEqual(pmt.length(hpd.message_ports_in()), 1)
header_sink = blocks.vector_sink_f()
payload_sink = blocks.vector_sink_f()
self.tb.connect(data_src, (hpd, 0))
self.tb.connect(trigger_src, (hpd, 1))
self.tb.connect((hpd, 0), header_sink)
self.tb.connect((hpd, 1), payload_sink)
self.tb.start()
time.sleep(.2) # Need this, otherwise, the next message is ignored
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.from_long(len(payload1))
)
while len(payload_sink.data()) < len(payload1):
time.sleep(.2)
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.PMT_F
)
# This next command is a bit of a showstopper, but there's no condition to check upon
# to see if the previous msg handling is finished
time.sleep(.7)
hpd.to_basic_block()._post(
pmt.intern('header_data'),
pmt.from_long(len(payload2))
)
while len(payload_sink.data()) < len(payload1) + len(payload2):
time.sleep(.2)
self.tb.stop()
self.tb.wait()
self.assertEqual(header_sink.data(), header + header_fail + header)
self.assertEqual(payload_sink.data(), payload1 + payload2)
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.assertEqual(expected, actual1)
self.assertEqual(expected, actual2)
def test_complex_to_float_2(self):
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 = 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)
self.tb.run()
self.assertFloatTuplesAlmostEqual(expected_data1, dst1.data())
self.assertFloatTuplesAlmostEqual(expected_data2, dst2.data())
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_quad_demod_001(self):
f = 1000.0
fs = 8000.0
src_data = []
for i in xrange(200):
ti = i/fs
src_data.append(cmath.exp(2j*cmath.pi*f*ti))
# f/fs is a quarter turn per sample.
# Set the gain based on this to get 1 out.
gain = 1.0/(cmath.pi/4)
expected_result = [0,] + 199*[1.0]
src = blocks.vector_source_c(src_data)
op = analog.quadrature_demod_cf(gain)
dst = blocks.vector_sink_f()
self.tb.connect(src, op)
self.tb.connect(op, dst)
self.tb.run()
result_data = dst.data()
self.assertComplexTuplesAlmostEqual(expected_result, result_data, 5)
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 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)
def test_004_es_source_pdus(self):
print "test_004_es_source_pdus"
msg = pmt.cons( pmt.to_pmt( {"somekey":"val2", "somekey2":"someval2" } ),
pmt.to_pmt( numpy.array( [0,1,2,3,4,5,6,7,8,9] , dtype=numpy.float32) ) );
src = es.source([gr.sizeof_float], 8, 2);
stb = blocks.message_strobe( msg, 100.0 );
tb = gr.top_block();
tb.msg_connect(stb, "strobe", src, "schedule_event");
th = blocks.throttle(gr.sizeof_float, 1000*100);
hd = blocks.head(gr.sizeof_float, 1000*100);
snk = blocks.vector_sink_f();
tb.connect(src,th,hd,snk);
# TODO: this can not use run because it is
# subject to GNU Radio's shutdown msg block bug
# for remaining upstream msg blocks ...
#tb.run();
# workaround
tb.start();
time.sleep(1);
tb.stop();
tb.wait();
self.assertEqual( sum(snk.data())>0, True );
def run_once(self, X_in, A, tpp=gr.TPP_DONT, A2=None, tags=None, msg_A=None):
""" Run the test for given input-, output- and matrix values.
Every row from X_in is considered an input signal on a port. """
X_in = numpy.matrix(X_in)
A_matrix = numpy.matrix(A)
(N, M) = A_matrix.shape
self.assertTrue(N == X_in.shape[0])
# Calc expected
Y_out_exp = numpy.matrix(numpy.zeros((M, X_in.shape[1])))
self.multiplier = blocks.multiply_matrix_ff(A, tpp)
if A2 is not None:
self.multiplier.set_A(A2)
A = A2
A_matrix = numpy.matrix(A)
for i in xrange(N):
if tags is None:
these_tags = ()
else:
these_tags = (tags[i],)
self.tb.connect(blocks.vector_source_f(X_in[i].tolist()[0], tags=these_tags), (self.multiplier, i))
sinks = []
for i in xrange(M):
sinks.append(blocks.vector_sink_f())
self.tb.connect((self.multiplier, i), sinks[i])
# Run and check
self.tb.run()
for i in xrange(X_in.shape[1]):
Y_out_exp[:,i] = A_matrix * X_in[:,i]
Y_out = [list(x.data()) for x in sinks]
if tags is not None:
self.the_tags = []
for i in xrange(M):
self.the_tags.append(sinks[i].tags())
self.assertEqual(list(Y_out), Y_out_exp.tolist())
def test_001(self):
""" Run test:
- No overlap
- Hamming window from Python
- Constant input signal of amplitude 1
The given input signal has a known power of 1. Therefore, the integral of the
PSD estimation result should be pretty close to 1."""
fft_len = 256
overlap = 0
alpha = 0.1
window = hamming(fft_len)
src_data = (1,) * (100 * fft_len)
src = blocks.vector_source_c(src_data, False)
welch = specest.welchsp(fft_len, overlap, alpha, False, window)
sink = blocks.vector_sink_f(fft_len)
self.tb.connect(src, welch, sink)
self.tb.run()
dst_data = sink.data()
dst_data = array(dst_data[-fft_len:])
power_est = sum(dst_data) * 2 * pi / fft_len
print power_est
self.assertAlmostEqual(power_est, 1, 3)
def test_sf_tag(self):
constA = [-3.0, -1.0, 1.0, 3]
constB = [12.0, -12.0, 6.0, -6]
src_data = (0, 1, 2, 3, 3, 2, 1, 0)
expected_result = (-3, -1, 1, 3,
-6, 6, -12, 12)
first_tag = gr.tag_t()
first_tag.key = pmt.intern("set_symbol_table")
first_tag.value = pmt.init_f32vector(len(constA), constA)
first_tag.offset = 0
second_tag = gr.tag_t()
second_tag.key = pmt.intern("set_symbol_table")
second_tag.value = pmt.init_f32vector(len(constB), constB)
second_tag.offset = 4
src = blocks.vector_source_s(src_data, False, 1, [first_tag, second_tag])
op = digital.chunks_to_symbols_sf(constB)
dst = blocks.vector_sink_f()
self.tb.connect(src, op)
self.tb.connect(op, dst)
self.tb.run()
actual_result = dst.data()
self.assertEqual(expected_result, actual_result)
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_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)
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)
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_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)
def test_vector_to_streams(self):
# Split an input vector into N streams.
N = 5
M = 20
src_data = list(range(0, M))
expected_results = []
for n in range(0, N):
expected_results.append(list(range(n, M, N)))
mapping = [[(0, n)] for n in range(0, N)]
src = blocks.vector_source_f(src_data, False, N)
vmap = blocks.vector_map(gr.sizeof_float, (N, ), mapping)
dsts = [blocks.vector_sink_f(1) for n in range(0, N)]
self.tb.connect(src, vmap)
for n in range(0, N):
self.tb.connect((vmap, n), dsts[n])
self.tb.run()
for n in range(0, N):
result_data = list(dsts[n].data())
self.assertEqual(expected_results[n], result_data)
def test_002(self):
payload = "test packet" # payload length is 11 bytes
header = "\x00\xd0\x00\xd0" # header contains packet length, twice (bit-swapped)
packet = header + payload
pad = (0,) * 64
src_data = (0, 0, 1, 1, 1, 1, 0, 1, 1) + tuple(string_to_1_0_list(packet)) + pad
src_floats = tuple(2*b-1 for b in src_data) # convert to binary antipodal symbols (-1,1)
expected = src_floats[9+32:-len(pad)]
src = blocks.vector_source_f(src_floats)
op = digital.correlate_access_code_ff_ts("1011", 0, "sync")
dst = blocks.vector_sink_f()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = dst.data()
result_tags = dst.tags()
self.assertEqual(len(result_data), len(payload)*8)
self.assertEqual(result_tags[0].offset, 0)
self.assertEqual(pmt.to_long(result_tags[0].value), len(payload)*8)
self.assertFloatTuplesAlmostEqual(result_data, expected, 5)
def test_001(self):
vlen = 10
src_data = list(range(vlen)) * 100
src = blocks.vector_source_f(src_data, False, vlen)
zeromq_rep_sink = zeromq.rep_sink("tcp://127.0.0.1:0", 0)
address = zeromq_rep_sink.last_endpoint()
zeromq_req_source = zeromq.req_source(address, 0)
sink = blocks.vector_sink_f(vlen)
self.send_tb.connect(src, zeromq_rep_sink)
self.recv_tb.connect(zeromq_req_source, sink)
self.recv_tb.start()
time.sleep(0.5)
self.send_tb.start()
time.sleep(0.5)
self.recv_tb.stop()
self.send_tb.stop()
self.recv_tb.wait()
self.send_tb.wait()
self.assertFloatTuplesAlmostEqual(sink.data(), src_data)
def test_f_002(self):
# Test scenariou where we have defined a puncture pattern with
# more bits than the puncsize.
self.puncsize = 4
self.puncpat = 0x5555
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 get_data(self):
'''
Returns the contents of the Vector Sink
'''
t = gr.top_block()
fsource = blocks.file_source(gr.sizeof_float,"fsink.dat")
self.vsink = blocks.vector_sink_f()
'''if __name__!="__main__":
print "in if condition"
fsource.seek(-250,2)'''
t.connect(fsource,self.vsink)
t.run()
samples=scipy.array(self.vsink.data())
self.vsink.reset()
self.fsink.close()
open("SineData.dat",'w').close()
#sleep(0.05)
self.fsink.open("fsink.dat")
return samples
def stest_003(self):
src_data0 = [0, 2, -3, 0, 12, 0]
src_data1 = [1, 1, 1, 1, 1, 1]
expected_result = [
float(min(x, y)) for x, y in zip(src_data0, src_data1)
]
src0 = blocks.vector_source_f(src_data0)
src1 = blocks.vector_source_f(src_data1)
op = blocks.min_ff(1)
dst = blocks.vector_sink_f()
self.tb.connect(src0, (op, 0))
self.tb.connect(src1, (op, 1))
self.tb.connect(op, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(expected_result, result_data)
def test_iir_direct_006(self):
src_data = (1, 2, 3, 4, 5, 6, 7, 8)
expected_result = (2, 13, 21, 59, 58, 186, 68, 583)
fftaps = (2, 1)
fbtaps = (0, -1)
src = blocks.vector_source_f(src_data)
op = filter.iir_filter_ffd(fftaps, fbtaps)
fftaps = (2, 11, 0)
fbtaps = (0, -1, 3)
# FIXME: implement set_taps as generalized callback
# op.set_taps(fftaps, fbtaps)
op.set_fftaps(fftaps)
op.set_fbtaps(fbtaps)
dst = blocks.vector_sink_f()
self.tb.connect(src, op)
self.tb.connect(op, dst)
self.tb.run()
result_data = dst.data()
self.assertFloatTuplesAlmostEqual(expected_result, result_data)
def test_001_t (self):
# data
self.default = 1.5
self.data = (-0.5, 3, -0.2, -0.8, 1, 1, 0, 1.12, -0.12, 0)
self.expected = (1, 4, 3.8, 3, 4, 5, 5, 6.12, 6, 6)
# blocks
self.src = blocks.vector_source_f(self.data)
self.sum = doa.cumulative_ff(self.default)
self.snk = blocks.vector_sink_f()
# connections
self.tb.connect(self.src, self.sum, self.snk)
self.tb.run ()
# check data
self.results = self.snk.data()
print (self.results)
self.assertComplexTuplesAlmostEqual(self.expected,self.results,5)
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 = blocks.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)
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_003_t(self):
# data
self.vector_length = 33
self.data = (0.292036732051034, -0.707963267948966, -1.70796326794897,
-2.70796326794897, 2.57522203923062, 1.57522203923062,
0.575222039230621, -0.424777960769379, -1.42477796076938,
-2.42477796076938, 2.85840734641021, 1.85840734641021,
0.858407346410207, -0.141592653589793, -1.14159265358979,
-2.14159265358979, -3.14159265358979, 2.14159265358979,
1.14159265358979, 0.141592653589793, -0.858407346410207,
-1.85840734641021, -2.85840734641021, 2.42477796076938,
1.42477796076938, 0.424777960769379, -0.575222039230621,
-1.57522203923062, -2.57522203923062, 2.70796326794897,
1.70796326794897, 0.707963267948966, -0.292036732051034)
self.expected = (
0.292036732051034, -0.707963267948966, -1.70796326794897,
-2.70796326794897, -3.70796326794897, -4.70796326794897,
-5.70796326794897, -6.70796326794897, -7.70796326794897,
-8.70796326794897, -9.70796326794897, -10.7079632679490,
-11.7079632679490, -12.7079632679490, -13.7079632679490,
-14.7079632679490, -15.7079632679490, -16.7079632679490,
-17.7079632679490, -18.7079632679490, -19.7079632679490,
-20.7079632679490, -21.7079632679490, -22.7079632679490,
-23.7079632679490, -24.7079632679490, -25.7079632679490,
-26.7079632679490, -27.7079632679490, -28.7079632679490,
-29.7079632679490, -30.7079632679490, -31.7079632679490)
self.min = -3.14159
self.max = 3.14159
# blocks
self.src = blocks.vector_source_f(self.data, False, self.vector_length)
self.unwrap = doa.unwrap_ff(self.vector_length, self.min, self.max)
self.snk = blocks.vector_sink_f(self.vector_length)
# connections
self.tb.connect(self.src, self.unwrap, self.snk)
self.tb.run()
# check data
self.result = self.snk.data()
print(self.result)
self.assertFloatTuplesAlmostEqual(self.expected, self.result, 3)
def run_once(self,
X_in,
A,
tpp=gr.TPP_DONT,
A2=None,
tags=None,
msg_A=None):
""" Run the test for given input-, output- and matrix values.
Every row from X_in is considered an input signal on a port. """
X_in = numpy.matrix(X_in)
A_matrix = numpy.matrix(A)
(N, M) = A_matrix.shape
self.assertTrue(N == X_in.shape[0])
# Calc expected
Y_out_exp = numpy.matrix(numpy.zeros((M, X_in.shape[1])))
self.multiplier = blocks.multiply_matrix_ff(A, tpp)
if A2 is not None:
self.multiplier.set_A(A2)
A = A2
A_matrix = numpy.matrix(A)
for i in xrange(N):
if tags is None:
these_tags = ()
else:
these_tags = (tags[i], )
self.tb.connect(
blocks.vector_source_f(X_in[i].tolist()[0], tags=these_tags),
(self.multiplier, i))
sinks = []
for i in xrange(M):
sinks.append(blocks.vector_sink_f())
self.tb.connect((self.multiplier, i), sinks[i])
# Run and check
self.tb.run()
for i in xrange(X_in.shape[1]):
Y_out_exp[:, i] = A_matrix * X_in[:, i]
Y_out = [list(x.data()) for x in sinks]
if tags is not None:
self.the_tags = []
for i in xrange(M):
self.the_tags.append(sinks[i].tags())
self.assertEqual(list(Y_out), Y_out_exp.tolist())
def test_pwr_squelch_004(self):
alpha = 0.0001
thr = -25
src_data = [float(x) / 10.0 for x in 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)
def test_001_t(self):
# test parameters
output_pow = 1e-3
wavelen = 850e-9
ext_ratio = 20
src_data = (0, 1, 1, 0, 1)
# calculate laser output pattern
expected_result = self.LaserOut(src_data, output_pow, ext_ratio)
# create blocks and connect flowgraph
src = blocks.vector_source_f(src_data)
sqr = FSO_Comm.Laser_ff(output_pow, wavelen, ext_ratio)
dst = blocks.vector_sink_f()
self.tb.connect(src, sqr)
self.tb.connect(sqr, dst)
# set up fg
self.tb.run()
# check data
result_data = dst.data()
# check accuracy of calculated values from blocks
self.assertFloatTuplesAlmostEqual(expected_result, result_data, 6)
def test_f_001(self):
# Test normal operation of the puncture block with a delay
self.puncsize = 8
self.puncpat = 0xEE
self.delay = 1
self.src_data = list(range(16))
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_t(self):
# set up fg
senal_entrante = (1., 2., 3., 4., 5., 6, 7, 8, 9, 10)
paso = 4
Delay1 = 0
src = blocks.vector_source_f(senal_entrante)
prom = diezmoppenh3_ff(paso, Delay1)
snk = blocks.vector_sink_f()
self.tb.connect(src, prom)
self.tb.connect(prom, snk)
# check data
self.tb.run()
senal_salida = snk.data()
print("entrada: ", senal_entrante)
salida_esperada = (1., 0., 0., 0., 5., 0, 0, 0, 9, 0)
print("salida esperada: ", salida_esperada)
print("salida obtenida: ", senal_salida)
self.assertFloatTuplesAlmostEqual(salida_esperada, senal_salida, 6)
def test_002_interp(self):
taps = random_floats(31)
src_data = random_floats(10000)
interpolation = 3
expected_result = reference_interp_filter(src_data, interpolation,
taps)
tb = gr.top_block()
src = blocks.vector_source_f(src_data)
op = filter.rational_resampler_fff(interpolation, 1, taps)
dst = blocks.vector_sink_f()
tb.connect(src, op)
tb.connect(op, dst)
tb.run()
result_data = dst.data()
N = 1000
offset = len(taps) - 1
self.assertEqual(expected_result[offset:offset + N], result_data[0:N])
def test_002_freq(self):
""" Add a fine frequency offset and see if that gets detected properly """
fft_len = 32
cp_len = 4
# This frequency offset is normalized to rads, i.e. \pi == f_s/2
max_freq_offset = 2 * numpy.pi / fft_len # Otherwise, it's coarse
freq_offset = ((2 * random.random()) - 1) * max_freq_offset
sig_len = (fft_len + cp_len) * 10
tx_signal = make_bpsk_burst(fft_len, cp_len, sig_len)
sync = digital.ofdm_sync_sc_cfb(fft_len, cp_len, True)
sink_freq = blocks.vector_sink_f()
sink_detect = blocks.vector_sink_b()
channel = channels.channel_model(0.005, freq_offset / 2.0 / numpy.pi)
self.tb.connect(blocks.vector_source_c(tx_signal), channel, sync)
self.tb.connect((sync, 0), sink_freq)
self.tb.connect((sync, 1), sink_detect)
self.tb.run()
phi_hat = sink_freq.data()[sink_detect.data().index(1)]
est_freq_offset = 2 * phi_hat / fft_len
self.assertAlmostEqual(est_freq_offset, freq_offset, places=2)
def test_004_t (self):
tags = []
tags.append(gr.tag_t())
tags[0].key = pmt.string_to_symbol('key')
tags[0].value = pmt.from_long(42)
tags[0].offset = 0
tags.append(gr.tag_t())
tags[1].key = pmt.string_to_symbol('key')
tags[1].value = pmt.from_long(42)
tags[1].offset = 5
tags.append(gr.tag_t())
tags[2].key = pmt.string_to_symbol('secondkey')
tags[2].value = pmt.from_long(42)
tags[2].offset = 6
src = blocks.vector_source_f(range(20), False, 1, tags)
gate = blocks.tag_gate(gr.sizeof_float, True)
sink = blocks.vector_sink_f()
self.tb.connect(src, gate, sink)
self.tb.run ()
self.assertEqual(len(sink.tags()), 3)
def test_nrlz(self, param):
"""this function run the defined test, for easier understanding"""
tb = self.tb
src = blocks.vector_source_b(param.data_src, True, 1, [])
dst = blocks.vector_sink_f()
head = blocks.head(gr.sizeof_char, len(param.data_src))
nrzl = ecss.nrzl_encoder_subcarrier(param.sine, param.freq_sub, param.bit_rate, param.samp_rate)
tb.connect(src, head)
tb.connect(head, nrzl)
tb.connect(nrzl, dst)
self.tb.run()
out = dst.data()
return out
def test_001(self):
#Test the overflow buffer in pdu_to_tagged_stream
src_data = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]
src = blocks.pdu_to_tagged_stream(blocks.float_t)
snk = blocks.vector_sink_f()
self.tb.connect(src, snk)
port = pmt.intern("pdus")
msg = pmt.cons( pmt.PMT_NIL, pmt.init_f32vector(10, src_data))
src.to_basic_block()._post(port, msg)
src.set_max_noutput_items(5)
self.tb.start()
#ideally, would wait until we get ten samples
time.sleep(0.2)
self.tb.stop()
self.assertEqual(src_data, list(snk.data()) )
def test_window_overlapping(self):
M = 8
R = M / 2
src_data = np.ones(M)
op = self.make(M, R, [])
window = op.window()
expected_result = np.concatenate((np.concatenate(
(np.zeros(R), src_data[:R])) * window, src_data * window))
src = blocks.vector_source_f(src_data)
dst = blocks.vector_sink_f()
self.tb.connect(src, op)
self.tb.connect(op, dst)
self.tb.run()
# check data
result_data = dst.data()[:]
# print result_data,expected_result
self.assertFloatTuplesAlmostEqual(result_data, expected_result, 4)
def __init__(self, EbN0):
gr.top_block.__init__(self)
self.const = digital.qpsk_constellation()
# Source is N_BITS bits, non-repeated
data = map(
int,
numpy.random.randint(0, self.const.arity(),
N_BITS / self.const.bits_per_symbol()))
src = blocks.vector_source_b(data, False)
mod = digital.chunks_to_symbols_bc((self.const.points()), 1)
add = blocks.add_vcc()
noise = analog.noise_source_c(analog.GR_GAUSSIAN,
self.EbN0_to_noise_voltage(EbN0),
RAND_SEED)
demod = digital.constellation_decoder_cb(self.const.base())
ber = BitErrors(self.const.bits_per_symbol())
self.sink = blocks.vector_sink_f()
self.connect(src, mod, add, demod, ber, self.sink)
self.connect(noise, (add, 1))
self.connect(src, (ber, 1))
def xtest_003_interp(self):
taps = random_floats(9)
src_data = random_floats(10000)
decimation = 3
expected_result = reference_dec_filter(src_data, decimation, taps)
tb = gr.top_block()
src = blocks.vector_source_f(src_data)
op = filter.rational_resampler_base_fff(1, decimation, taps)
dst = blocks.vector_sink_f()
tb.connect(src, op)
tb.connect(op, dst)
tb.run()
result_data = dst.data()
N = 10
offset = 10#len(taps)-1
print(expected_result[100+offset:100+offset+N])
print(result_data[100:100+N])
def test_006_interp_decim(self):
taps = random_floats(31)
src_data = random_floats(10000)
interp = 3
decimation = 2
expected_result = reference_interp_dec_filter(src_data, interp, decimation, taps)
tb = gr.top_block()
src = blocks.vector_source_f(src_data)
op = filter.rational_resampler_base_fff(interp, decimation, taps)
dst = blocks.vector_sink_f()
tb.connect(src, op)
tb.connect(op, dst)
tb.run()
result_data = dst.data()
N = 1000
offset = len(taps) // 2
self.assertFloatTuplesAlmostEqual(expected_result[offset:offset+N], result_data[0:N], 5)
def test_001(self):
vlen = 10
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:5556", 0)
zeromq_sub_source = zeromq.sub_source(gr.sizeof_float, vlen,
"tcp://127.0.0.1:5556", 0)
sink = blocks.vector_sink_f(vlen)
self.send_tb.connect(src, zeromq_pub_sink)
self.recv_tb.connect(zeromq_sub_source, sink)
self.recv_tb.start()
time.sleep(0.5)
self.send_tb.start()
time.sleep(0.5)
self.recv_tb.stop()
self.send_tb.stop()
self.recv_tb.wait()
self.send_tb.wait()
self.assertFloatTuplesAlmostEqual(sink.data(), src_data)
def xtest_fff_006(self):
random.seed(0)
for i in xrange(25):
sys.stderr.write("\n>>> Loop = %d\n" % (i,))
dec = i + 1
src_len = 4*1024
src_data = make_random_float_tuple(src_len)
ntaps = int(random.uniform(2, 100))
taps = make_random_float_tuple(ntaps)
expected_result = reference_filter_fff(dec, taps, src_data)
src = blocks.vector_source_f(src_data)
op = filter.fft_filter_fff(dec, taps)
dst = blocks.vector_sink_f()
tb = gr.top_block()
tb.connect(src, op, dst)
tb.run()
result_data = dst.data()
self.assert_fft_float_ok2(expected_result, result_data)
def test_004(self):
''' Test impulse response - short form, ff '''
src_data = [
1,
] + 100 * [
0,
]
expected_result = ((-0.029296875), (-0.0302734375), (0.96875),
(-0.0302734375), (-0.029296875))
src = blocks.vector_source_f(src_data)
op = filter.dc_blocker_ff(32, False)
dst = blocks.vector_sink_f()
self.tb.connect(src, op, dst)
self.tb.run()
# only test samples around D-1
result_data = dst.data()[29:34]
self.assertFloatTuplesAlmostEqual(expected_result, result_data)
def test_003_t(self):
my_phi = 30
my_psi = 15
my_dist = 1
g_tx = 0.86602540378 / math.pi
g_rx = 0.96592582628
G = g_tx * g_rx / (my_dist * my_dist)
src_data = (1, 2, 3, 4, 5, 2.5, 5.234, 9.999)
expected_result = (1 * G, 2 * G, 3 * G, 4 * G, 5 * G, 2.5 * G,
5.234 * G, 9.999 * G)
src = blocks.vector_source_f(src_data)
my_chan = vlc.channel_static(my_phi, my_psi, my_dist)
dst = blocks.vector_sink_f()
self.tb.connect(src, my_chan)
self.tb.connect(my_chan, dst)
self.tb.run()
result_data = dst.data()
self.assertFloatTuplesAlmostEqual(expected_result, result_data, 6)
def test_002_select_vectors(self):
vlen_in = 2
vlen_out = 10
total_size = 10
address = 3
src_data = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
14, 15, 16, 17, 18, 19, 0)
expected_data = (6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15)
src = blocks.vector_source_f(src_data)
s2v = blocks.stream_to_vector(gr.sizeof_float, vlen_in)
select_subch = dab.select_subch_vfvf_make(vlen_in, vlen_out, address,
total_size)
v2s = blocks.vector_to_stream(gr.sizeof_float, vlen_out)
dst = blocks.vector_sink_f()
self.tb.connect(src, s2v, select_subch, v2s, dst)
self.tb.run()
result_data = dst.data()
self.assertFloatTuplesAlmostEqual2(result_data, expected_data)
