def test_002(self):
# Cause 8 bit errors out of 8*N bits
# using test mode
mode = True
N = 1000
data0 = numpy.random.randint(0, 256, N).tolist()
data1 = copy.deepcopy(data0)
data1[0] ^= 0xFF
src0 = blocks.vector_source_b(data0)
src1 = blocks.vector_source_b(data1)
op = fec.ber_bf(mode, 1, -2.0)
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()
data = dst.data()
expected_result = [
numpy.log10(8.0 / (8.0 * N)),
]
self.assertFloatTuplesAlmostEqual(expected_result, data, 5)
def test_003(self):
# Cause a 8 bit errors out of 8*N bits
# using test mode
# Exit if BER < -2.0
mode = True
N = 1000
data0 = numpy.random.randint(0, 256, N).tolist()
data1 = copy.deepcopy(data0)
data1[0] ^= 0xFF
src0 = blocks.vector_source_b(data0)
src1 = blocks.vector_source_b(data1)
op = fec.ber_bf(mode, 10, -2.0)
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()
data = dst.data()
expected_result = [-2.0]
print data
print expected_result
self.assertFloatTuplesAlmostEqual(expected_result, data, 5)
def test_027a_internally_unconnected_input(self):
tb = gr.top_block()
hb = gr.hier_block2("block",
gr.io_signature(1, 1, 1),
gr.io_signature(1, 1, 1))
hsrc = blocks.vector_source_b([1,])
hb.connect(hsrc, hb) # wire output internally
src = blocks.vector_source_b([1, ])
dst = blocks.vector_sink_b()
tb.connect(src, hb, dst) # hb's input is not connected internally
self.assertRaises(RuntimeError,
lambda: tb.run())
def test_1(self):
datas = (
0, 1, 2, 5, 6, 10, 14, 15, 16,
3, 4, 7, 8, 9, 11, 12, 13, 17
)
expected = tuple(range(18))
tagname = "packet_length"
len_tags_0 = (
make_len_tag(0, tagname, 3),
make_len_tag(3, tagname, 2),
make_len_tag(5, tagname, 1),
make_len_tag(6, tagname, 3)
)
len_tags_1 = (
make_len_tag(0, tagname, 2),
make_len_tag(2, tagname, 3),
make_len_tag(5, tagname, 3),
make_len_tag(8, tagname, 1)
)
test_tag_0 = gr.tag_t()
test_tag_0.key = pmt.string_to_symbol('spam')
test_tag_0.offset = 4 # On the second '1'
test_tag_0.value = pmt.to_pmt(42)
test_tag_1 = gr.tag_t()
test_tag_1.key = pmt.string_to_symbol('eggs')
test_tag_1.offset = 3 # On the first '3' of the 2nd stream
test_tag_1.value = pmt.to_pmt(23)
src0 = blocks.vector_source_b(datas[0:9], False, 1, len_tags_0 + (test_tag_0,))
src1 = blocks.vector_source_b(datas[9:], False, 1, len_tags_1 + (test_tag_1,))
tagged_stream_mux = blocks.tagged_stream_mux(gr.sizeof_char, tagname)
snk = blocks.vector_sink_b()
self.tb.connect(src0, (tagged_stream_mux, 0))
self.tb.connect(src1, (tagged_stream_mux, 1))
self.tb.connect(tagged_stream_mux, snk)
self.tb.run()
self.assertEqual(expected, snk.data())
tags = [gr.tag_to_python(x) for x in snk.tags()]
tags = sorted([(x.offset, x.key, x.value) for x in tags])
tags_expected = [
(0, 'packet_length', 5),
(5, 'packet_length', 5),
(6, 'spam', 42),
(8, 'eggs', 23),
(10, 'packet_length', 4),
(14, 'packet_length', 4)
]
self.assertEqual(tags, tags_expected)
def test_027a_internally_unconnected_input(self):
tb = gr.top_block()
hb = gr.hier_block2("block", gr.io_signature(1, 1, 1),
gr.io_signature(1, 1, 1))
hsrc = blocks.vector_source_b([
1,
])
hb.connect(hsrc, hb) # wire output internally
src = blocks.vector_source_b([
1,
])
dst = blocks.vector_sink_b()
tb.connect(src, hb, dst) # hb's input is not connected internally
self.assertRaises(RuntimeError, lambda: tb.run())
def helper(self, v0, v1, fft_length, preamble):
tb = self.tb
src0 = blocks.vector_source_c(v0)
src1 = blocks.vector_source_b(v1)
s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, fft_length)
# print "len(v) = %d" % (len(v))
op = digital.ofdm_insert_preamble(fft_length, preamble)
v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, fft_length)
dst0 = blocks.vector_sink_c()
dst1 = blocks.vector_sink_b()
tb.connect(src0, s2v, (op, 0))
tb.connect(src1, (op, 1))
tb.connect((op, 0), v2s, dst0)
tb.connect((op, 1), dst1)
tb.run()
r0 = dst0.data()
r0v = []
for i in range(len(r0) // fft_length):
r0v.append(r0[i * fft_length:(i + 1) * fft_length])
r1 = dst1.data()
self.assertEqual(len(r0v), len(r1))
return (r1, r0v)
def helper(self, v0, v1, fft_length, preamble):
tb = self.tb
src0 = blocks.vector_source_c(v0)
src1 = blocks.vector_source_b(v1)
s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, fft_length)
# print "len(v) = %d" % (len(v))
op = digital.ofdm_insert_preamble(fft_length, preamble)
v2s = blocks.vector_to_stream(gr.sizeof_gr_complex, fft_length)
dst0 = blocks.vector_sink_c()
dst1 = blocks.vector_sink_b()
tb.connect(src0, s2v, (op, 0))
tb.connect(src1, (op, 1))
tb.connect((op, 0), v2s, dst0)
tb.connect((op, 1), dst1)
tb.run()
r0 = dst0.data()
r0v = []
for i in range(len(r0)//fft_length):
r0v.append(r0[i*fft_length:(i+1)*fft_length])
r1 = dst1.data()
self.assertEqual(len(r0v), len(r1))
return (r1, r0v)
def test_003(self):
# Test scenario 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_b(self.src_data)
op0 = fec.puncture_bb(self.puncsize, self.puncpat0, self.delay)
op1 = fec.puncture_bb(self.puncsize, self.puncpat1, self.delay)
dst0 = blocks.vector_sink_b()
dst1 = blocks.vector_sink_b()
self.tb.connect(src, op0, dst0)
self.tb.connect(src, op1, dst1)
self.tb.run()
dst_data0 = list(dst0.data())
for i in xrange(len(dst_data0)):
dst_data0[i] = int(dst_data0[i])
dst_data1 = list(dst1.data())
for i in xrange(len(dst_data1)):
dst_data1[i] = int(dst_data1[i])
self.assertEqual(dst_data1, dst_data0)
def test_004(self):
# Test normal operation of the depuncture block without
# specifying the fill symbol (defaults to 127).
self.puncsize = 8
self.puncpat = 0xEF
self.delay = 0
self.sym = 127
self.puncholes = 1
self.depuncture_setup()
src = blocks.vector_source_b(self.src_data)
op = fec.depuncture_bb(self.puncsize, self.puncpat,
self.delay)
dst = blocks.vector_sink_b()
self.tb.connect(src, op, dst)
self.tb.run()
dst_data = list(dst.data())
for i in xrange(len(dst_data)):
dst_data[i] = int(dst_data[i])
self.assertEqual(self.expected, dst_data)
def test_002(self):
# Test scenario where we have defined a puncture pattern with
# more bits than the puncsize.
self.puncsize = 4
self.puncpat = 0x5555
self.delay = 0
self.sym = 0
self.puncholes = 2
self.depuncture_setup()
src = blocks.vector_source_b(self.src_data)
op = fec.depuncture_bb(self.puncsize, self.puncpat,
self.delay, self.sym)
dst = blocks.vector_sink_b()
self.tb.connect(src, op, dst)
self.tb.run()
dst_data = list(dst.data())
for i in xrange(len(dst_data)):
dst_data[i] = int(dst_data[i])
self.assertEqual(self.expected, dst_data)
def test_003_12bits_formatter_object (self):
# 3 PDUs: | | | |
data = (1, 2, 3, 4, 1, 2, 1, 2, 3, 4)
tagname = "packet_len"
tag1 = gr.tag_t()
tag1.offset = 0
tag1.key = pmt.string_to_symbol(tagname)
tag1.value = pmt.from_long(4)
tag2 = gr.tag_t()
tag2.offset = 4
tag2.key = pmt.string_to_symbol(tagname)
tag2.value = pmt.from_long(2)
tag3 = gr.tag_t()
tag3.offset = 6
tag3.key = pmt.string_to_symbol(tagname)
tag3.value = pmt.from_long(4)
src = blocks.vector_source_b(data, False, 1, (tag1, tag2, tag3))
formatter_object = digital.packet_header_default(12, tagname)
header = digital.packet_headergenerator_bb(formatter_object.formatter(), tagname)
sink = blocks.vector_sink_b()
self.tb.connect(src, header, sink)
self.tb.run()
expected_data = (
0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0
)
self.assertEqual(sink.data(), expected_data)
def test_002_32bits (self):
# 3 PDUs: | | | |
data = (1, 2, 3, 4, 1, 2, 1, 2, 3, 4)
tagname = "packet_len"
tag1 = gr.tag_t()
tag1.offset = 0
tag1.key = pmt.string_to_symbol(tagname)
tag1.value = pmt.from_long(4)
tag2 = gr.tag_t()
tag2.offset = 4
tag2.key = pmt.string_to_symbol(tagname)
tag2.value = pmt.from_long(2)
tag3 = gr.tag_t()
tag3.offset = 6
tag3.key = pmt.string_to_symbol(tagname)
tag3.value = pmt.from_long(4)
src = blocks.vector_source_b(data, False, 1, (tag1, tag2, tag3))
header = digital.packet_headergenerator_bb(32, tagname)
sink = blocks.vector_sink_b()
self.tb.connect(src, header, sink)
self.tb.run()
expected_data = (
# | Number of symbols | Packet number | Parity
0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
)
self.assertEqual(sink.data(), expected_data)
def test_002(self):
code = tuple(string_to_1_0_list(default_access_code))
access_code = to_1_0_string(code)
header = tuple(
2 * [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]) # len=2
pad = (0, ) * 100
src_data = code + header + (0, 1, 0, 0, 1, 0, 0, 0) + (0, 1, 0, 0, 1,
0, 0, 1) + pad
expected_data = 'HI'
rcvd_pktq = gr.msg_queue()
src = blocks.vector_source_b(src_data)
correlator = digital.correlate_access_code_bb(access_code, 0)
framer_sink = digital.framer_sink_1(rcvd_pktq)
vsnk = blocks.vector_sink_b()
self.tb.connect(src, correlator, framer_sink)
self.tb.connect(correlator, vsnk)
self.tb.run()
result_data = rcvd_pktq.delete_head()
result_data = result_data.to_string()
self.assertEqual(expected_data, result_data)
def test_regen2(self):
tb = self.tb
data = 200*[0,]
data[9] = 1
data[99] = 1
expected_result = 200*[0,]
expected_result[9] = 1
expected_result[19] = 1
expected_result[29] = 1
expected_result[39] = 1
expected_result[99] = 1
expected_result[109] = 1
expected_result[119] = 1
expected_result[129] = 1
src = blocks.vector_source_b(data, False)
regen = blocks.regenerate_bb(10, 3)
dst = blocks.vector_sink_b()
tb.connect(src, regen)
tb.connect(regen, dst)
tb.run ()
dst_data = dst.data()
self.assertEqual(tuple(expected_result), dst_data)
def test_001_t (self):
"""
First header: Packet length 4, packet num 0
Second header: Packet 2, packet num 1
Third header: Invalid (parity bit does not check) (would be len 4, num 2)
"""
encoded_headers = (
# | Number of bytes | Packet number | Parity
0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0
)
packet_len_tagname = "packet_len"
random_tag = gr.tag_t()
random_tag.offset = 5
random_tag.key = pmt.string_to_symbol("foo")
random_tag.value = pmt.from_long(42)
src = blocks.vector_source_b(encoded_headers, tags=(random_tag,))
parser = digital.packet_headerparser_b(32, packet_len_tagname)
sink = blocks.message_debug()
self.tb.connect(src, parser)
self.tb.msg_connect(parser, "header_data", sink, "store")
self.tb.start()
time.sleep(1)
self.tb.stop()
self.tb.wait()
self.assertEqual(sink.num_messages(), 3)
msg1 = pmt.to_python(sink.get_message(0))
msg2 = pmt.to_python(sink.get_message(1))
msg3 = pmt.to_python(sink.get_message(2))
self.assertEqual(msg1, {'packet_len': 4, 'packet_num': 0, 'foo': 42})
self.assertEqual(msg2, {'packet_len': 2, 'packet_num': 1})
self.assertEqual(msg3, False)
def __init__(self, constellation, differential, data_length=None, src_data=None, freq_offset=True):
"""
Args:
constellation: a constellation object
differential: whether differential encoding is used
data_length: the number of bits of data to use
src_data: a list of the bits to use
freq_offset: whether to use a frequency offset in the channel
"""
super(rec_test_tb, self).__init__()
# Transmission Blocks
if src_data is None:
self.src_data = tuple([rndm.randint(0, 1) for i in range(0, data_length)])
else:
self.src_data = src_data
packer = blocks.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST)
src = blocks.vector_source_b(self.src_data)
mod = generic_mod(constellation, differential=differential)
# Channel
if freq_offset:
channel = channel_model(NOISE_VOLTAGE, FREQUENCY_OFFSET, TIMING_OFFSET)
else:
channel = channel_model(NOISE_VOLTAGE, 0, TIMING_OFFSET)
# Receiver Blocks
if freq_offset:
demod = generic_demod(constellation, differential=differential, freq_bw=FREQ_BW, phase_bw=PHASE_BW)
else:
demod = generic_demod(constellation, differential=differential, freq_bw=0, phase_bw=0)
self.dst = blocks.vector_sink_b()
self.connect(src, packer, mod, channel, demod, self.dst)
def test_004_8bits_formatter_ofdm (self):
occupied_carriers = ((1, 2, 3, 5, 6, 7),)
# 3 PDUs: | | | |
data = (1, 2, 3, 4, 1, 2, 1, 2, 3, 4)
tagname = "packet_len"
tag1 = gr.tag_t()
tag1.offset = 0
tag1.key = pmt.string_to_symbol(tagname)
tag1.value = pmt.from_long(4)
tag2 = gr.tag_t()
tag2.offset = 4
tag2.key = pmt.string_to_symbol(tagname)
tag2.value = pmt.from_long(2)
tag3 = gr.tag_t()
tag3.offset = 6
tag3.key = pmt.string_to_symbol(tagname)
tag3.value = pmt.from_long(4)
src = blocks.vector_source_b(data, False, 1, (tag1, tag2, tag3))
formatter_object = digital.packet_header_ofdm(occupied_carriers, 1, tagname)
self.assertEqual(formatter_object.header_len(), 6)
self.assertEqual(pmt.symbol_to_string(formatter_object.len_tag_key()), tagname)
header = digital.packet_headergenerator_bb(formatter_object.formatter(), tagname)
sink = blocks.vector_sink_b()
self.tb.connect(src, header, sink)
self.tb.run()
expected_data = (
0, 0, 1, 0, 0, 0,
0, 1, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0
)
self.assertEqual(sink.data(), expected_data)
def test_002(self):
# Test scenario where we have defined a puncture pattern with
# more bits than the puncsize.
self.puncsize = 4
self.puncpat = 0x5555
self.delay = 0
self.sym = 0
self.puncholes = 2
self.depuncture_setup()
src = blocks.vector_source_b(self.src_data)
op = fec.depuncture_bb(self.puncsize, self.puncpat, self.delay,
self.sym)
dst = blocks.vector_sink_b()
self.tb.connect(src, op, dst)
self.tb.run()
dst_data = list(dst.data())
for i in xrange(len(dst_data)):
dst_data[i] = int(dst_data[i])
self.assertEqual(self.expected, dst_data)
def test_003(self):
# Test scenario 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
self.sym = 0
src = blocks.vector_source_b(self.src_data)
op0 = fec.depuncture_bb(self.puncsize, self.puncpat0, self.delay,
self.sym)
op1 = fec.depuncture_bb(self.puncsize, self.puncpat1, self.delay,
self.sym)
dst0 = blocks.vector_sink_b()
dst1 = blocks.vector_sink_b()
self.tb.connect(src, op0, dst0)
self.tb.connect(src, op1, dst1)
self.tb.run()
dst_data0 = list(dst0.data())
for i in xrange(len(dst_data0)):
dst_data0[i] = int(dst_data0[i])
dst_data1 = list(dst1.data())
for i in xrange(len(dst_data1)):
dst_data1[i] = int(dst_data1[i])
self.assertEqual(dst_data1, dst_data0)
def test_004_ofdm_packets (self):
"""
Send several bursts using ofdm_tx, see if the number of detects is correct.
Burst lengths and content are random.
"""
n_bursts = 42
fft_len = 64
cp_len = 16
# Here, coarse freq offset is allowed
max_freq_offset = 2*numpy.pi/fft_len * 4
freq_offset = ((2 * random.random()) - 1) * max_freq_offset
tx_signal = []
packets = []
tagname = "packet_length"
min_packet_length = 10
max_packet_length = 50
sync_sequence = [random.randint(0, 1)*2-1 for x in range(fft_len/2)]
for i in xrange(n_bursts):
packet_length = random.randint(min_packet_length,
max_packet_length+1)
packet = [random.randint(0, 255) for i in range(packet_length)]
packets.append(packet)
data, tags = tagged_streams.packets_to_vectors(packets, tagname, vlen=1)
total_length = len(data)
src = blocks.vector_source_b(data, False, 1, tags)
mod = ofdm_tx(packet_length_tag_key=tagname)
sync = digital.ofdm_sync_sc_cfb(fft_len, cp_len)
sink_freq = blocks.vector_sink_f()
sink_detect = blocks.vector_sink_b()
noise_level = 0.005
channel = channels.channel_model(noise_level, freq_offset / 2 / numpy.pi)
self.tb.connect(src, mod, channel, sync, sink_freq)
self.tb.connect((sync, 1), sink_detect)
self.tb.run()
self.assertEqual(numpy.sum(sink_detect.data()), n_bursts)
def test_003_12bits_formatter_object(self):
# 3 PDUs: | | | |
data = (1, 2, 3, 4, 1, 2, 1, 2, 3, 4)
tagname = "packet_len"
tag1 = gr.tag_t()
tag1.offset = 0
tag1.key = pmt.string_to_symbol(tagname)
tag1.value = pmt.from_long(4)
tag2 = gr.tag_t()
tag2.offset = 4
tag2.key = pmt.string_to_symbol(tagname)
tag2.value = pmt.from_long(2)
tag3 = gr.tag_t()
tag3.offset = 6
tag3.key = pmt.string_to_symbol(tagname)
tag3.value = pmt.from_long(4)
src = blocks.vector_source_b(data, False, 1, (tag1, tag2, tag3))
formatter_object = digital.packet_header_default(12, tagname)
header = digital.packet_headergenerator_bb(
formatter_object.formatter(), tagname)
sink = blocks.vector_sink_b()
self.tb.connect(src, header, sink)
self.tb.run()
expected_data = (0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0)
self.assertEqual(sink.data(), expected_data)
def test_004_8bits_formatter_ofdm(self):
occupied_carriers = ((1, 2, 3, 5, 6, 7), )
# 3 PDUs: | | | |
data = (1, 2, 3, 4, 1, 2, 1, 2, 3, 4)
tagname = "packet_len"
tag1 = gr.tag_t()
tag1.offset = 0
tag1.key = pmt.string_to_symbol(tagname)
tag1.value = pmt.from_long(4)
tag2 = gr.tag_t()
tag2.offset = 4
tag2.key = pmt.string_to_symbol(tagname)
tag2.value = pmt.from_long(2)
tag3 = gr.tag_t()
tag3.offset = 6
tag3.key = pmt.string_to_symbol(tagname)
tag3.value = pmt.from_long(4)
src = blocks.vector_source_b(data, False, 1, (tag1, tag2, tag3))
formatter_object = digital.packet_header_ofdm(occupied_carriers, 1,
tagname)
self.assertEqual(formatter_object.header_len(), 6)
self.assertEqual(pmt.symbol_to_string(formatter_object.len_tag_key()),
tagname)
header = digital.packet_headergenerator_bb(
formatter_object.formatter(), tagname)
sink = blocks.vector_sink_b()
self.tb.connect(src, header, sink)
self.tb.run()
expected_data = (0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0)
self.assertEqual(sink.data(), expected_data)
def test_00(self):
expected_result = (
0x00, 0x11, 0x22, 0x33,
0x44, 0x55, 0x66, 0x77,
0x88, 0x99, 0xaa, 0xbb,
0xcc, 0xdd, 0xee, 0xff)
# Filter taps to expand the data to oversample by 8
# Just using a RRC for some basic filter shape
taps = filter.firdes.root_raised_cosine(8, 8, 1.0, 0.5, 21)
src = blocks.vector_source_b(expected_result)
frame = digital.simple_framer(4)
unpack = blocks.packed_to_unpacked_bb(1, gr.GR_MSB_FIRST)
expand = filter.interp_fir_filter_fff(8, taps)
b2f = blocks.char_to_float()
mult2 = blocks.multiply_const_ff(2)
sub1 = blocks.add_const_ff(-1)
op = digital.simple_correlator(4)
dst = blocks.vector_sink_b()
self.tb.connect(src, frame, unpack, b2f, mult2, sub1, expand)
self.tb.connect(expand, op, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(expected_result, result_data)
def __init__(self, data, len_tag_key):
gr.top_block.__init__(self, "ofdm_tx")
tx_data, tags = tagged_streams.packets_to_vectors((data,), len_tag_key)
src = blocks.vector_source_b(data, False, 1, tags)
self.tx = ofdm_tx(packet_length_tag_key=len_tag_key, debug_log=LOG_DEBUG_INFO)
self.sink = blocks.vector_sink_c()
self.connect(src, self.tx, self.sink)
def test_300(self):
input_data = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
src = blocks.vector_source_b(input_data)
dst = blocks.vector_sink_b()
tb = gr.top_block()
tb.connect(src, dst)
tb.run()
self.assertEquals(input_data, dst.data())
def test_300(self):
input_data = (0,1,2,3,4,5,6,7,8,9)
src = blocks.vector_source_b(input_data)
dst = blocks.vector_sink_b()
tb = gr.top_block()
tb.connect(src, dst)
tb.run()
self.assertEquals(input_data, dst.data())
def test_char_to_short(self):
src_data = (1, 2, 3, 4, 5)
expected_data = (256, 512, 768, 1024, 1280)
src = blocks.vector_source_b(src_data)
op = blocks.char_to_short()
dst = blocks.vector_sink_s()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(expected_data, dst.data())
def test_char_to_float_scale(self):
src_data = (1, 2, 3, 4, 5)
expected_data = (0.5, 1.0, 1.5, 2.0, 2.5)
src = blocks.vector_source_b(src_data)
op = blocks.char_to_float(scale=2.0)
dst = blocks.vector_sink_f()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
def test_char_to_float_identity(self):
src_data = (1, 2, 3, 4, 5)
expected_data = (1.0, 2.0, 3.0, 4.0, 5.0)
src = blocks.vector_source_b(src_data)
op = blocks.char_to_float()
dst = blocks.vector_sink_f()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
def test_scrambler_descrambler(self):
src_data = (1,)*1000
src = blocks.vector_source_b(src_data, False)
scrambler = digital.scrambler_bb(0x8a, 0x7F, 7) # CCSDS 7-bit scrambler
descrambler = digital.descrambler_bb(0x8a, 0x7F, 7)
dst = blocks.vector_sink_b()
self.tb.connect(src, scrambler, descrambler, dst)
self.tb.run()
self.assertEqual(tuple(src_data[:-8]), dst.data()[8:]) # skip garbage during synchronization
def test_additive_scrambler_reset(self):
src_data = (1,)*1000
src = blocks.vector_source_b(src_data, False)
scrambler = digital.additive_scrambler_bb(0x8a, 0x7f, 7, 100)
descrambler = digital.additive_scrambler_bb(0x8a, 0x7f, 7, 100)
dst = blocks.vector_sink_b()
self.tb.connect(src, scrambler, descrambler, dst)
self.tb.run()
self.assertEqual(src_data, dst.data())
def test_char_to_short(self):
src_data = (1, 2, 3, 4, 5)
expected_data = (256, 512, 768, 1024, 1280)
src = blocks.vector_source_b(src_data)
op = blocks.char_to_short()
dst = blocks.vector_sink_s()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(expected_data, dst.data())
def test_char_to_float_scale(self):
src_data = (1, 2, 3, 4, 5)
expected_data = (0.5, 1.0, 1.5, 2.0, 2.5)
src = blocks.vector_source_b(src_data)
op = blocks.char_to_float(scale=2.0)
dst = blocks.vector_sink_f()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
def test_001(self):
src_data = (1,0,1,1,0,1,1,0)
expected_results = (1,0,1,1,0,1,1,0)
src = blocks.vector_source_b(src_data,False)
op = blocks.pack_k_bits_bb(1)
dst = blocks.vector_sink_b()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(expected_results, dst.data())
def help_bb (self, src_data, exp_data, op):
for s in zip (range (len (src_data)), src_data):
src = blocks.vector_source_b (s[1])
self.tb.connect (src, (op, s[0]))
dst = blocks.vector_sink_b ()
self.tb.connect (op, dst)
self.tb.run ()
result_data = dst.data ()
self.assertEqual (exp_data, result_data)
def test_and_const_bb (self):
src_data = (1, 2, 3, 0x50, 0x11)
expected_result = (0, 2, 2, 0x00, 0x00)
src = blocks.vector_source_b(src_data)
op = blocks.and_const_bb (0xAA)
dst = blocks.vector_sink_b()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(dst.data(), expected_result)
def test_and_const_bb(self):
src_data = (1, 2, 3, 0x50, 0x11)
expected_result = (0, 2, 2, 0x00, 0x00)
src = blocks.vector_source_b(src_data)
op = blocks.and_const_bb(0xAA)
dst = blocks.vector_sink_b()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(dst.data(), expected_result)
def help_bb(self, src_data, exp_data, op):
for s in zip(range(len(src_data)), src_data):
src = blocks.vector_source_b(s[1])
self.tb.connect(src, (op, s[0]))
dst = blocks.vector_sink_b()
self.tb.connect(op, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(exp_data, result_data)
def test_char_to_float_identity(self):
src_data = (1, 2, 3, 4, 5)
expected_data = (1.0, 2.0, 3.0, 4.0, 5.0)
src = blocks.vector_source_b(src_data)
op = blocks.char_to_float()
dst = blocks.vector_sink_f()
self.tb.connect(src, op, dst)
self.tb.run()
self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
def test_003(self):
src_data = expected_results = map(lambda x: random.randint(0,3), range(10));
src = blocks.vector_source_b( src_data );
pack = blocks.pack_k_bits_bb(2);
unpack = blocks.unpack_k_bits_bb(2);
snk = blocks.vector_sink_b();
self.tb.connect(src,unpack,pack,snk);
self.tb.run()
self.assertEqual(list(expected_results), list(snk.data()));
def test_029_singleton_disconnect(self):
tb = gr.top_block()
src = blocks.vector_source_b([1, ])
dst = blocks.vector_sink_b()
tb.connect(src, dst)
tb.disconnect(src) # Singleton disconnect
tb.connect(src, dst)
tb.run()
self.assertEquals(dst.data(), (1,))
def test_002(self):
src_data = [1, 1, 1, 1]
expected_data = 1
src = blocks.vector_source_b(src_data)
op = digital.probe_density_b(0.01)
self.tb.connect(src, op)
self.tb.run()
result_data = op.density()
self.assertEqual(expected_data, result_data)
def test_001(self):
src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
expected_data = (5, 10)
src = blocks.vector_source_b(src_data)
op = blocks.keep_one_in_n(gr.sizeof_char, 5)
dst = blocks.vector_sink_b()
print "HERE"
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(dst.data(), expected_data)
def test_001(self):
src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
expected_data = (5, 10)
src = blocks.vector_source_b(src_data);
op = blocks.keep_one_in_n(gr.sizeof_char, 5)
dst = blocks.vector_sink_b()
print "HERE"
self.tb.connect(src, op, dst)
self.tb.run()
self.assertEqual(dst.data(), expected_data)
def test_copy(self):
src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
expected_result = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
src = blocks.vector_source_b(src_data)
op = blocks.copy(gr.sizeof_char)
dst = blocks.vector_sink_b()
self.tb.connect(src, op, dst)
self.tb.run()
dst_data = dst.data()
self.assertEqual(expected_result, dst_data)
def test_copy(self):
src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
expected_result = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
src = blocks.vector_source_b(src_data)
op = blocks.copy(gr.sizeof_char)
dst = blocks.vector_sink_b()
self.tb.connect(src, op, dst)
self.tb.run()
dst_data = dst.data()
self.assertEqual(expected_result, dst_data)
def test_003(self):
src_data = [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
expected_data = 0.95243
src = blocks.vector_source_b(src_data)
op = digital.probe_density_b(0.01)
self.tb.connect(src, op)
self.tb.run()
result_data = op.density()
print result_data
self.assertAlmostEqual(expected_data, result_data, 5)
def helper(self, symbols):
src_data = [0, 1, 2, 3, 0, 1, 2, 3]
expected_data = map(lambda x: symbols[x], src_data)
src = blocks.vector_source_b(src_data)
op = digital.map_bb(symbols)
dst = blocks.vector_sink_b()
self.tb.connect(src, op, dst)
self.tb.run()
result_data = list(dst.data())
self.assertEqual(expected_data, result_data)
def test_029_singleton_disconnect(self):
tb = gr.top_block()
src = blocks.vector_source_b([
1,
])
dst = blocks.vector_sink_b()
tb.connect(src, dst)
tb.disconnect(src) # Singleton disconnect
tb.connect(src, dst)
tb.run()
self.assertEquals(dst.data(), (1, ))
def test_002_three(self):
""" 8 -> 3 """
src_data = (0b11111101, 0b11111111, 0b11111111)
expected_data = (0b101, ) + (0b111, ) * 7
k = 8
l = 3
src = blocks.vector_source_b(src_data, False, 1)
repack = blocks.repack_bits_bb(k, l)
sink = blocks.vector_sink_b()
self.tb.connect(src, repack, sink)
self.tb.run()
self.assertEqual(sink.data(), expected_data)
def test_006(self):
src_data = (0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0)
expected_results = (0x82, 0x5a)
src = blocks.vector_source_b(src_data, False)
op = blocks.unpacked_to_packed_bb(1, gr.GR_LSB_FIRST)
dst = blocks.vector_sink_b()
self.tb.connect(src, op)
self.tb.connect(op, dst)
self.tb.run()
self.assertEqual(expected_results, dst.data())
def test_004(self):
src_data = (0x11, )
expected_results = (0, 4)
src = blocks.vector_source_b(src_data, False)
op = blocks.packed_to_unpacked_bb(3, gr.GR_MSB_FIRST)
dst = blocks.vector_sink_b()
self.tb.connect(src, op)
self.tb.connect(op, dst)
self.tb.run()
self.assertEqual(expected_results, dst.data())
def test_001_tx (self):
""" Just make sure the Tx works in general """
len_tag_key = 'frame_len'
n_bytes = 52
n_samples_expected = (numpy.ceil(1.0 * (n_bytes + 4) / 6) + 3) * 80
test_data = [random.randint(0, 255) for x in range(n_bytes)]
tx_data, tags = tagged_streams.packets_to_vectors((test_data,), len_tag_key)
src = blocks.vector_source_b(test_data, False, 1, tags)
tx = ofdm_tx(packet_length_tag_key=len_tag_key)
tx_fg = ofdm_tx_fg(test_data, len_tag_key)
tx_fg.run()
self.assertEqual(len(tx_fg.get_tx_samples()), n_samples_expected)
def test_001_simple(self):
""" Very simple test, 2 bits -> 1 """
src_data = (0b11, 0b01, 0b10)
expected_data = (0b1, 0b1, 0b1, 0b0, 0b0, 0b1)
k = 2
l = 1
src = blocks.vector_source_b(src_data, False, 1)
repack = blocks.repack_bits_bb(k, l)
sink = blocks.vector_sink_b()
self.tb.connect(src, repack, sink)
self.tb.run()
self.assertEqual(sink.data(), expected_data)
