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 (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 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 general_work(self, input_items, output_items):
n_windows = len(output_items[0])
# Fetch all window tags
tags = [
gr.tag_to_python(x)
for x in self.get_tags_in_window(0, 0, len(input_items[0]))
] # self.get_tags_in_window(0, 0, len(input_items[0]))#
win_tags = list(filter(lambda t: t.key == 'new_window', tags))
out_S1 = output_items[0]
out_S2 = output_items[1]
out_SNR = output_items[2]
n_syms_u1, n_syms_u2, n_snrs = 0, 0, 0
for i in range(n_windows):
L = [input_items[k * 3 + 0][i] for k in range(self.Ku)]
Mi1 = [input_items[k * 3 + 1][i] for k in range(self.Ku)]
Mi2 = [input_items[k * 3 + 2][i] for k in range(self.Ku)]
demod_tags = []
for k in range(self.Ku):
tags = [
gr.tag_to_python(x)
for x in self.get_tags_in_window(k * 3, i, i + 1)
]
demod_tags += filter(lambda t: t.key == 'partial_ml', tags)
window = win_tags[i].value
syms, SNR_u1 = self.process_window(window, demod_tags, L, Mi1, Mi2)
S1, S2 = syms
if S1 is not None:
out_S1[n_syms_u1] = S1
n_syms_u1 += 1
if S2 is not None:
out_S2[n_syms_u2] = S2
n_syms_u2 += 1
if SNR_u1:
out_SNR[n_snrs] = SNR_u1
n_snrs += 1
for k in range(self.Ku):
self.consume(3 * k + 0, n_windows)
self.consume(3 * k + 1, n_windows)
self.consume(3 * k + 2, n_windows)
self.produce(0, n_syms_u1)
self.produce(1, n_syms_u2)
self.produce(2, n_snrs)
return -2 #gr.WORK_CALLED_PRODUCE
def transmitter_work(self, input_items, output_items):
in0 = input_items[0]
in0_items_no = len(in0)
first_item_offset = self.nitems_read(0)
consumed_items = 0
# Start by looking for the start tag of the packet
if self.transmitter_status == self.TransmitterStatus.IDLE:
tags = self.get_tags_in_window(0, 0, in0_items_no,
pmt.intern(f'Packet start'))
if tags:
self.start_tag = gr.tag_to_python(tags[0])
print(
f'Tag key: {self.start_tag.key} tag Value: {self.start_tag.value}\
tag offset: {self.start_tag.offset}')
self.current_packet = numpy.frombuffer(
in0[self.start_tag.offset - first_item_offset:],
dtype=numpy.uint8)
self.transmitter_status = self.TransmitterStatus.LOOK_FOR_END
consumed_items = self.current_packet.size + self.start_tag.offset - first_item_offset
# If we found the start of the packet, look for the ending tag
if self.transmitter_status == self.TransmitterStatus.LOOK_FOR_END:
tags = self.get_tags_in_window(0, 0, in0_items_no,
pmt.intern(f'Packet end'))
# Append all the data that we received to the current packet
self.current_packet = numpy.append(
self.current_packet,
numpy.frombuffer(in0[consumed_items:], dtype=numpy.uint8))
if tags:
# If we find the ending tag then we can trim the array to the packet size and prepare for the next phase
self.end_tag = gr.tag_to_python(tags[0])
print(
f'Tag key: {self.end_tag.key} tag Value: {self.end_tag.value}\
tag offset: {self.end_tag.offset}')
self.transmitter_status = self.TransmitterStatus.PREPARE
self.current_packet = self.current_packet[:(
self.end_tag.offset - self.start_tag.offset)]
print(f'Releasing semaphore')
self.ready_packets.release()
# print(f'Board interface: consumed {in0_items_no} items')
self.consume(0, in0_items_no)
return 0
def test_001_t(self):
packet_len = 96
pad_zeros = 4
len_tag_key = 'packet_len'
src = blocks.vector_source_f(range(packet_len), False)
sink = blocks.vector_sink_f()
self.tb.connect(
src,
blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len,
len_tag_key),
fosdem.burst_marker(gr.sizeof_float, len_tag_key, pad_zeros),
sink,
)
self.tb.run()
self.assertFloatTuplesAlmostEqual(
sink.data(),
range(packet_len) + [
0.0,
] * pad_zeros)
tags = [gr.tag_to_python(x) for x in sink.tags()]
tags = sorted([(x.offset, x.key, x.value) for x in tags])
tags_expected = [
(0, len_tag_key, packet_len +
pad_zeros), # Hard coded time value :( Is n_zeros/sampling_rate
(0, 'tx_sob', True),
(packet_len + pad_zeros - 1, 'tx_eob', True),
]
self.assertEqual(tags, tags_expected)
print tags
def test_001_t(self):
# set up fg
qa_seed = 0.8
qa_seq_len = 50
qa_constell_tab = (-1 + 0j, 1 + 0j)
qa_para_tab_chebyshev = (1.4, 1.8)
expected_data = [-1 + 0j, 1 + 0j, -1 + 0j, 1 + 0j]
src = blocks.file_source(
gr.sizeof_float,
'/home/edwin/Documents/GNURadio/gr-chaos/python/inputdata_CPM_demod',
False)
tagged_stream = blocks.stream_to_tagged_stream(gr.sizeof_float, 1, 100,
'len_streamtag')
dst = blocks.vector_sink_c()
CPDM = chaos.CPM_demod_fc(qa_seq_len, qa_constell_tab,
qa_para_tab_chebyshev, 'len_streamtag')
expected_tags = [('len_streamtag', 2L, 0L), ('len_streamtag', 2L, 2L)]
self.tb.connect(src, tagged_stream, CPDM, dst)
self.tb.run()
result_data = dst.data()
result_tags = dst.tags()
result_tags = [gr.tag_to_python(x) for x in result_tags]
result_tags = sorted([(x.key, x.value, x.offset) for x in result_tags])
# check data
#print(result_data)
#print(result_tags)
self.assertFloatTuplesAlmostEqual(expected_data, result_data, 4)
self.assertEqual(result_tags, expected_tags)
def work(self, input_items, output_items):
if not self.sock_connected:
print('Connecting to {}'.format(self.sock_addr))
self.sock.connect(self.sock_addr)
self.sock_connected = True
current_time = datetime.datetime.now()
if ((current_time - self.last_msg_time) >
datetime.timedelta(seconds=10)):
return -1
tags = self.get_tags_in_window(0, 0, self.nsamples)
for tag in tags:
tag = gr.tag_to_python(tag)
if tag.key == 'rx_freq':
self.rx_freq = tag.value
if tag.key == 'rx_rate':
self.rx_rate = tag.value
# if (self.last_msg_time + self.msg_interval) > current_time:
if self.done:
self.done = False
return len(input_items[0])
if input_items[0].shape[0] == self.nsamples:
self.send_message(input_items[0])
self.last_msg_time = datetime.datetime.now()
self.done = True
return self.nsamples
return 0
def test_001_t(self):
# set up fg
qa_seed = 0.8
qa_seq_len = 2
qa_constell_tab = (-1 + 0j, 1 + 0j)
#qa_para_tab=(3.98,3.6)
qa_para_tab_chebyshev = (1.4, 1.8)
data = [-1 + 0j, 1 + 0j, -1 + 0j, 1 + 0j]
src = blocks.vector_source_c(data)
tagged_stream = blocks.stream_to_tagged_stream(gr.sizeof_gr_complex, 1,
2, 'len_streamtag')
dst = blocks.vector_sink_f()
CPM = chaos.CPM_cf(qa_seed, qa_seq_len, qa_constell_tab,
qa_para_tab_chebyshev)
#expected_data=(0.6368, 0.9205173254013062,0.5760, 0.8792,
#0.6368, 0.9205173254013062,0.5760, 0.8792)
expected_data_chebyshev = (0.6209, 0.3046, 0.4009, -0.4918, 0.6209,
0.3046, 0.4009, -0.4918)
expected_tags = [('len_streamtag', 4, 0L), ('len_streamtag', 4, 4L)]
self.tb.connect(src, tagged_stream, CPM, dst)
self.tb.run()
result_data = dst.data()
result_tags = dst.tags()
#print('data tags='+str(len(result_tags)))
result_tags = [gr.tag_to_python(x) for x in result_tags]
result_tags = sorted([(x.key, x.value, x.offset) for x in result_tags])
# check data
#self.assertFloatTuplesAlmostEqual(expected_data_chebyshev, result_data,4)
self.assertEqual(result_tags, expected_tags)
def test_002_t(self):
nsubcarrier = 16
ntimeslots = 64
sync_data = np.array([
np.complex(np.random.choice([-1, 1]), np.random.choice([-1, 1]))
for i in xrange(nsubcarrier)
])
src_data = np.array([
np.complex(np.random.choice([-1, 1]), np.random.choice([-1, 1]))
for i in xrange(nsubcarrier * ntimeslots)
])
src = blocks.vector_source_c(src_data, vlen=1)
stts = blocks.stream_to_tagged_stream(gr.sizeof_gr_complex,
vlen=1,
packet_len=nsubcarrier *
ntimeslots,
len_tag_key="frame_len")
fr = gfdms.framer_cc(nsubcarrier, ntimeslots, True, sync_data,
"frame_len")
dst = blocks.vector_sink_c(vlen=1)
expected_result = np.concatenate(
(mod.reshape_input(np.tile(sync_data, 2), 2, nsubcarrier),
mod.reshape_input(src_data, ntimeslots, nsubcarrier)))
self.tb.connect(src, stts)
self.tb.connect(stts, fr)
self.tb.connect(fr, dst)
self.tb.run()
result_data = dst.data()
tags = dst.tags()
for tag in tags:
ptag = gr.tag_to_python(tag)
pprint(vars(ptag))
self.assertComplexTuplesAlmostEqual(
expected_result,
result_data[0:nsubcarrier * ntimeslots + 2 * nsubcarrier], 6)
def test_with_tags_2s_rolloff(self):
" With tags and a 2-sample rolloff "
fft_len = 8
cp_len = 2
tag_name = "length"
expected_result = (7.0/2, 8, 1, 2, 3, 4, 5, 6, 7, 8, # 1.0/2
7.0/2+1.0/2, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1.0/2)
tag = gr.tag_t()
tag.offset = 0
tag.key = pmt.string_to_symbol(tag_name)
tag.value = pmt.from_long(2)
tag2 = gr.tag_t()
tag2.offset = 1
tag2.key = pmt.string_to_symbol("random_tag")
tag2.value = pmt.from_long(42)
src = blocks.vector_source_c(range(1, fft_len+1) * 2, False, fft_len, (tag, tag2))
cp = digital.ofdm_cyclic_prefixer(fft_len, fft_len + cp_len, 2, tag_name)
sink = blocks.vector_sink_c()
self.tb.connect(src, cp, sink)
self.tb.run()
self.assertEqual(sink.data(), expected_result)
tags = [gr.tag_to_python(x) for x in sink.tags()]
tags = sorted([(x.offset, x.key, x.value) for x in tags])
expected_tags = [
(0, tag_name, len(expected_result)),
(fft_len+cp_len, "random_tag", 42)
]
self.assertEqual(tags, expected_tags)
def test_001_tx(self):
""" Just make sure the Tx works in general """
# This tag gets put onto the first item of the transmit data,
# it should be transmitted first, too
timing_tag = gr.tag_t()
timing_tag.offset = 0
timing_tag.key = pmt.string_to_symbol('tx_timing')
timing_tag.value = pmt.to_pmt('now')
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_fg = ofdm_tx_fg(test_data,
len_tag_key,
additional_tags=[
timing_tag,
])
tx_fg.run()
self.assertEqual(len(tx_fg.get_tx_samples()), n_samples_expected)
tags_rx = [gr.tag_to_python(x) for x in tx_fg.sink.tags()]
tags_rx = sorted([(x.offset, x.key, x.value) for x in tags_rx])
tags_expected = [
(0, 'frame_len', n_samples_expected),
(0, 'tx_timing', 'now'),
]
self.assertEqual(tags_rx, tags_expected)
def test_preserve_tag_head_pos(self):
""" Test the 'preserve head position' function.
This will add a 'special' tag to item 0 on stream 1.
It should be on item 0 of the output stream. """
packet_len_0 = 5
data0 = range(packet_len_0)
packet_len_1 = 3
data1 = range(packet_len_1)
mux = blocks.tagged_stream_mux(
gr.sizeof_float,
self.tsb_key,
1 # Mark port 1 as carrying special tags on the head position
)
sink = blocks.tsb_vector_sink_f(tsb_key=self.tsb_key)
self.tb.connect(
blocks.vector_source_f(data0),
blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len_0, self.tsb_key),
(mux, 0)
)
self.tb.connect(
blocks.vector_source_f(range(packet_len_1), tags=(make_tag('spam', 'eggs', 0),)),
blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len_1, self.tsb_key),
(mux, 1)
)
self.tb.connect(mux, sink)
self.tb.run()
self.assertEqual(len(sink.data()), 1)
self.assertEqual(sink.data()[0], tuple(data0 + data1))
self.assertEqual(len(sink.tags()), 1)
tag = gr.tag_to_python(sink.tags()[0])
tag = (tag.offset, tag.key, tag.value)
tag_expected = (0, 'spam', 'eggs')
self.assertEqual(tag, tag_expected)
def test_1(self):
packets0 = (
(0, 1, 2), (5, 6), (10,), (14, 15, 16,)
)
packets1 = (
(3, 4), (7, 8, 9), (11, 12, 13), (17,)
)
expected = ((0, 1, 2, 3, 4), (5, 6, 7, 8, 9), (10, 11, 12, 13), (14, 15, 16, 17))
data0, tags0 = self.setup_data_tags(packets0)
data1, tags1 = self.setup_data_tags(packets1)
tags0.append(make_tag('spam', 42, 4))
tags1.append(make_tag('eggs', 23, 3))
src0 = blocks.vector_source_b(data0, tags=tags0)
src1 = blocks.vector_source_b(data1, tags=tags1)
tagged_stream_mux = blocks.tagged_stream_mux(gr.sizeof_char, self.tsb_key)
snk = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
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()
# Check
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 = [
(6, 'spam', 42),
(8, 'eggs', 23),
]
self.assertEqual(tags, tags_expected)
def test_preserve_tag_head_pos(self):
""" Test the 'preserve head position' function.
This will add a 'special' tag to item 0 on stream 1.
It should be on item 0 of the output stream. """
packet_len_0 = 5
data0 = list(range(packet_len_0))
packet_len_1 = 3
data1 = list(range(packet_len_1))
mux = blocks.tagged_stream_mux(
gr.sizeof_float,
self.tsb_key,
1 # Mark port 1 as carrying special tags on the head position
)
sink = blocks.tsb_vector_sink_f(tsb_key=self.tsb_key)
self.tb.connect(
blocks.vector_source_f(data0),
blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len_0,
self.tsb_key), (mux, 0))
self.tb.connect(
blocks.vector_source_f(list(range(packet_len_1)),
tags=(make_tag('spam', 'eggs', 0), )),
blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len_1,
self.tsb_key), (mux, 1))
self.tb.connect(mux, sink)
self.tb.run()
self.assertEqual(len(sink.data()), 1)
self.assertEqual(sink.data()[0], tuple(data0 + data1))
self.assertEqual(len(sink.tags()), 1)
tag = gr.tag_to_python(sink.tags()[0])
tag = (tag.offset, tag.key, tag.value)
tag_expected = (0, 'spam', 'eggs')
self.assertEqual(tag, tag_expected)
def test_1(self):
packets0 = ((0, 1, 2), (5, 6), (10, ), (
14,
15,
16,
))
packets1 = ((3, 4), (7, 8, 9), (11, 12, 13), (17, ))
expected = ((0, 1, 2, 3, 4), (5, 6, 7, 8, 9), (10, 11, 12, 13),
(14, 15, 16, 17))
data0, tags0 = self.setup_data_tags(packets0)
data1, tags1 = self.setup_data_tags(packets1)
tags0.append(make_tag('spam', 42, 4))
tags1.append(make_tag('eggs', 23, 3))
src0 = blocks.vector_source_b(data0, tags=tags0)
src1 = blocks.vector_source_b(data1, tags=tags1)
tagged_stream_mux = blocks.tagged_stream_mux(gr.sizeof_char,
self.tsb_key)
snk = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
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()
# Check
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 = [
(6, 'spam', 42),
(8, 'eggs', 23),
]
self.assertEqual(tags, tags_expected)
def test_preserve_tag_head_pos(self):
""" Test the 'preserve head position' function.
This will add a 'special' tag to item 0 on stream 1.
It should be on item 0 of the output stream. """
special_tag = gr.tag_t()
special_tag.key = pmt.string_to_symbol('spam')
special_tag.offset = 0
special_tag.value = pmt.to_pmt('eggs')
len_tag_key = "length"
packet_len_1 = 5
packet_len_2 = 3
mux = blocks.tagged_stream_mux(gr.sizeof_float, len_tag_key, 1)
sink = blocks.vector_sink_f()
self.tb.connect(
blocks.vector_source_f(range(packet_len_1)),
blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len_1, len_tag_key),
(mux, 0)
)
self.tb.connect(
blocks.vector_source_f(range(packet_len_2), False, 1, (special_tag,)),
blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len_2, len_tag_key),
(mux, 1)
)
self.tb.connect(mux, sink)
self.tb.run()
self.assertEqual(sink.data(), tuple(range(packet_len_1) + range(packet_len_2)))
tags = [gr.tag_to_python(x) for x in sink.tags()]
tags = sorted([(x.offset, x.key, x.value) for x in tags])
tags_expected = [
(0, 'length', packet_len_1 + packet_len_2),
(0, 'spam', 'eggs'),
]
self.assertEqual(tags, tags_expected)
def test_001_t(self):
len_tag_key = "header_len"
debug_tag_key = "test"
payload_key = "packet_size"
own_id = 4
maxS = 3
header_one = [20]
header_two = [17]
header_three = [132]
header_four = [20, 20]
header_five = [20]
header_six = [20]
src_data = header_one + header_two + header_three + header_four
src_data = src_data + header_five + header_six
src_tags = make_tags(len_tag_key, debug_tag_key, payload_key)
#blocks
src = blocks.vector_source_b(src_data, repeat=False, tags=src_tags)
parser = ownHeader.parse_short_bb(len_tag_key, payload_key, own_id,
maxS)
dest = blocks.tsb_vector_sink_b(1, len_tag_key)
#connection
self.tb.connect(src, parser, dest)
self.tb.run()
# retrieve data
dest_data = dest.data()
dest_tags = dest.tags()
#testing
#receiver data
self.assertEqual(len(dest_data), 6)
self.assertEqual(dest_data, ((1, ), (0, ), (0, ), (0, ), (1, ), (1, )))
#tags
tags = [gr.tag_to_python(x) for x in dest_tags]
self.assertEqual(len(tags), 4)
zero = []
four = []
five = []
rest = []
for tag in tags:
if tag.offset == 0:
zero.append(tag)
elif tag.offset == 4:
four.append(tag)
elif tag.offset == 5:
five.append(tag)
else:
rest.appned(tag)
self.assertEqual(len(rest), 0)
self.assertEqual(len(zero), 1)
self.assertEqual(len(four), 2)
self.assertEqual(len(five), 1)
self.assertEqual(zero[0].value, 1)
for tag in four:
if tag.key == debug_tag_key:
self.assertEqual(tag.value, 400)
elif tag.key == payload_key:
self.assertEqual(tag.value, 1)
else:
self.assertEqual(False, True)
self.assertEqual(five[0].value, 1)
def test_with_tags_2s_rolloff_multiples_cps(self):
"Two CP lengths, 2-sample rolloff and tags."
fft_len = 8
cp_lengths = (3, 2, 2)
rolloff = 2
tag_name = "ts_last"
expected_result = [
6.0 / 2,
7,
8,
1,
2,
3,
4,
5,
6,
7,
8, # 1
7.0 / 2 + 1.0 / 2,
8,
1,
2,
3,
4,
5,
6,
7,
8,
1.0 / 2 # Last tail
]
# First test tag
tag0 = gr.tag_t()
tag0.offset = 0
tag0.key = pmt.string_to_symbol("first_tag")
tag0.value = pmt.from_long(24)
# Second test tag
tag1 = gr.tag_t()
tag1.offset = 1
tag1.key = pmt.string_to_symbol("second_tag")
tag1.value = pmt.from_long(42)
src = blocks.vector_source_c(
list(range(1, fft_len + 1)) * 2, False, fft_len, (tag0, tag1))
cp = digital.ofdm_cyclic_prefixer(fft_len, cp_lengths, rolloff,
tag_name)
sink = blocks.tsb_vector_sink_c(tsb_key=tag_name)
self.tb.connect(
src,
blocks.stream_to_tagged_stream(gr.sizeof_gr_complex, fft_len, 2,
tag_name), cp, sink)
self.tb.run()
self.assertEqual(sink.data()[0], expected_result)
tags = [gr.tag_to_python(x) for x in sink.tags()]
tags = sorted([(x.offset, x.key, x.value) for x in tags])
expected_tags = [(0, "first_tag", 24),
(fft_len + cp_lengths[0], "second_tag", 42)]
self.assertEqual(tags, expected_tags)
def test_001(self):
t = gr.tag_t()
t.offset = 10
t.key = pmt.string_to_symbol('key')
t.value = pmt.from_long(23)
t.srcid = pmt.from_bool(False)
pt = gr.tag_to_python(t)
self.assertEqual(pt.key, 'key')
self.assertEqual(pt.value, 23)
self.assertEqual(pt.offset, 10)
def test_001(self):
t = gr.tag_t()
t.offset = 10
t.key = pmt.string_to_symbol("key")
t.value = pmt.from_long(23)
t.srcid = pmt.from_bool(False)
pt = gr.tag_to_python(t)
self.assertEqual(pt.key, "key")
self.assertEqual(pt.value, 23)
self.assertEqual(pt.offset, 10)
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_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_001_t (self):
src_data = (1, ) * 50
packet_len = 10
len_tag_key = 'packet_len'
src = blocks.vector_source_f(src_data, False, 1)
tagger = blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len, len_tag_key)
sink = blocks.vector_sink_f()
self.tb.connect(src, tagger, sink)
self.tb.run ()
self.assertEqual(sink.data(), src_data)
tags = [gr.tag_to_python(x) for x in sink.tags()]
tags = sorted([(x.offset, x.key, x.value) for x in tags])
expected_tags = [(int(pos), 'packet_len', packet_len) for pos in range(0, 50, 10) ]
self.assertEqual(tags, expected_tags)
def test_with_tags_2s_rolloff(self):
" With tags and a 2-sample rolloff "
fft_len = 8
cp_len = 2
tag_name = "length"
expected_result = (
7.0 / 2,
8,
1,
2,
3,
4,
5,
6,
7,
8, # 1.0/2
7.0 / 2 + 1.0 / 2,
8,
1,
2,
3,
4,
5,
6,
7,
8,
1.0 / 2)
tag = gr.gr_tag_t()
tag.offset = 0
tag.key = pmt.pmt_string_to_symbol(tag_name)
tag.value = pmt.pmt_from_long(2)
tag2 = gr.gr_tag_t()
tag2.offset = 1
tag2.key = pmt.pmt_string_to_symbol("random_tag")
tag2.value = pmt.pmt_from_long(42)
src = gr.vector_source_c(
range(1, fft_len + 1) * 2, False, fft_len, (tag, tag2))
cp = digital.ofdm_cyclic_prefixer(fft_len, fft_len + cp_len, 2,
tag_name)
sink = gr.vector_sink_c()
self.tb.connect(src, cp, sink)
self.tb.run()
self.assertEqual(sink.data(), expected_result)
tags = [gr.tag_to_python(x) for x in sink.tags()]
tags = sorted([(x.offset, x.key, x.value) for x in tags])
expected_tags = [(0, tag_name, len(expected_result)),
(fft_len + cp_len, "random_tag", 42)]
self.assertEqual(tags, expected_tags)
def test_001_t(self):
src_data = (1, ) * 50
packet_len = 10L
len_tag_key = 'packet_len'
src = blocks.vector_source_f(src_data, False, 1)
tagger = blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len,
len_tag_key)
sink = blocks.vector_sink_f()
self.tb.connect(src, tagger, sink)
self.tb.run()
self.assertEqual(sink.data(), src_data)
tags = [gr.tag_to_python(x) for x in sink.tags()]
tags = sorted([(x.offset, x.key, x.value) for x in tags])
expected_tags = [(long(pos), 'packet_len', packet_len)
for pos in range(0, 50, 10)]
self.assertEqual(tags, expected_tags)
def test_002_static_wo_tags (self):
""" Same as before, but the input stream has no tag.
We specify the frame size in the constructor.
We also specify a tag key, so the output stream *should* have
a length tag.
"""
fft_len = 8
n_syms = 4
# 4 5 6 7 0 1 2 3
tx_data = [-1, -1, 1, 2, -1, 3, 0, -1, # 0
-1, -1, 0, 2, -1, 2, 0, -1, # 8
-1, -1, 3, 0, -1, 1, 0, -1, # 16 (Pilot symbols)
-1, -1, 1, 1, -1, 0, 2, -1] # 24
cnst = digital.constellation_qpsk()
tx_signal = [cnst.map_to_points_v(x)[0] if x != -1 else 0 for x in tx_data]
occupied_carriers = ((1, 2, 6, 7),)
pilot_carriers = ((), (), (1, 2, 6, 7), ())
pilot_symbols = (
[], [], [cnst.map_to_points_v(x)[0] for x in (1, 0, 3, 0)], []
)
equalizer = digital.ofdm_equalizer_static(fft_len, occupied_carriers, pilot_carriers, pilot_symbols)
channel = [
0, 0, 1, 1, 0, 1, 1, 0,
0, 0, 1, 1, 0, 1, 1, 0, # These coefficients will be rotated slightly (below)...
0, 0, 1j, 1j, 0, 1j, 1j, 0, # Go crazy here!
0, 0, 1j, 1j, 0, 1j, 1j, 0 # ...and again here.
]
for idx in range(fft_len, 2*fft_len):
channel[idx] = channel[idx-fft_len] * numpy.exp(1j * .1 * numpy.pi * (numpy.random.rand()-.5))
idx2 = idx+2*fft_len
channel[idx2] = channel[idx2] * numpy.exp(1j * 0 * numpy.pi * (numpy.random.rand()-.5))
src = gr.vector_source_c(numpy.multiply(tx_signal, channel), False, fft_len)
# We do specify a length tag, it should then appear at the output
eq = digital.ofdm_frame_equalizer_vcvc(equalizer.base(), 0, "frame_len", False, n_syms)
sink = gr.vector_sink_c(fft_len)
self.tb.connect(src, eq, sink)
self.tb.run ()
rx_data = [cnst.decision_maker_v((x,)) if x != 0 else -1 for x in sink.data()]
self.assertEqual(tx_data, rx_data)
# Check len tag
tags = sink.tags()
len_tag = dict()
for tag in tags:
ptag = gr.tag_to_python(tag)
if ptag.key == 'frame_len':
len_tag[ptag.key] = ptag.value
self.assertEqual(len_tag, {'frame_len': 4})
def test_with_tags_2s_rolloff(self):
" With tags and a 2-sample rolloff "
fft_len = 8
cp_len = 2
tag_name = "ts_last"
expected_result = [
7.0 / 2,
8,
1,
2,
3,
4,
5,
6,
7,
8, # 1.0/2
7.0 / 2 + 1.0 / 2,
8,
1,
2,
3,
4,
5,
6,
7,
8,
1.0 / 2
]
tag2 = gr.tag_t()
tag2.offset = 1
tag2.key = pmt.string_to_symbol("random_tag")
tag2.value = pmt.from_long(42)
src = blocks.vector_source_c(
list(range(1, fft_len + 1)) * 2, False, fft_len, (tag2, ))
cp = digital.ofdm_cyclic_prefixer(fft_len, fft_len + cp_len, 2,
tag_name)
sink = blocks.tsb_vector_sink_c(tsb_key=tag_name)
self.tb.connect(
src,
blocks.stream_to_tagged_stream(gr.sizeof_gr_complex, fft_len, 2,
tag_name), cp, sink)
self.tb.run()
self.assertEqual(sink.data()[0], expected_result)
tags = [gr.tag_to_python(x) for x in sink.tags()]
tags = sorted([(x.offset, x.key, x.value) for x in tags])
expected_tags = [(fft_len + cp_len, "random_tag", 42)]
self.assertEqual(tags, expected_tags)
def test_002_static_wo_tags (self):
""" Same as before, but the input stream has no tag.
We specify the frame size in the constructor.
We also specify a tag key, so the output stream *should* have
a length tag.
"""
fft_len = 8
n_syms = 4
# 4 5 6 7 0 1 2 3
tx_data = [-1, -1, 1, 2, -1, 3, 0, -1, # 0
-1, -1, 0, 2, -1, 2, 0, -1, # 8
-1, -1, 3, 0, -1, 1, 0, -1, # 16 (Pilot symbols)
-1, -1, 1, 1, -1, 0, 2, -1] # 24
cnst = digital.constellation_qpsk()
tx_signal = [cnst.map_to_points_v(x)[0] if x != -1 else 0 for x in tx_data]
occupied_carriers = ((1, 2, 6, 7),)
pilot_carriers = ((), (), (1, 2, 6, 7), ())
pilot_symbols = (
[], [], [cnst.map_to_points_v(x)[0] for x in (1, 0, 3, 0)], []
)
equalizer = digital.ofdm_equalizer_static(fft_len, occupied_carriers, pilot_carriers, pilot_symbols)
channel = [
0, 0, 1, 1, 0, 1, 1, 0,
0, 0, 1, 1, 0, 1, 1, 0, # These coefficients will be rotated slightly (below)...
0, 0, 1j, 1j, 0, 1j, 1j, 0, # Go crazy here!
0, 0, 1j, 1j, 0, 1j, 1j, 0 # ...and again here.
]
for idx in range(fft_len, 2*fft_len):
channel[idx] = channel[idx-fft_len] * numpy.exp(1j * .1 * numpy.pi * (numpy.random.rand()-.5))
idx2 = idx+2*fft_len
channel[idx2] = channel[idx2] * numpy.exp(1j * 0 * numpy.pi * (numpy.random.rand()-.5))
src = gr.vector_source_c(numpy.multiply(tx_signal, channel), False, fft_len)
# We do specify a length tag, it should then appear at the output
eq = digital.ofdm_frame_equalizer_vcvc(equalizer.base(), 0, "frame_len", False, n_syms)
sink = blocks.vector_sink_c(fft_len)
self.tb.connect(src, eq, sink)
self.tb.run ()
rx_data = [cnst.decision_maker_v((x,)) if x != 0 else -1 for x in sink.data()]
self.assertEqual(tx_data, rx_data)
# Check len tag
tags = sink.tags()
len_tag = dict()
for tag in tags:
ptag = gr.tag_to_python(tag)
if ptag.key == 'frame_len':
len_tag[ptag.key] = ptag.value
self.assertEqual(len_tag, {'frame_len': 4})
def test_002_t(self):
"""
once again, but this time add a sync word
"""
fft_len = 6
sync_word = (0, ) * fft_len
tx_symbols = (1, 2, 3, 4, 5, 6)
pilot_symbols = ((1j, ), )
occupied_carriers = ((-1, 1, 2), )
pilot_carriers = ((3, ), )
expected_result = sync_word + (1j, 0, 1, 0, 2, 3) + (1j, 0, 4, 0, 5, 6)
tag_name = "len"
tag = gr.tag_t()
tag.offset = 0
tag.key = pmt.string_to_symbol(tag_name)
tag.value = pmt.from_long(len(tx_symbols))
special_tag1 = gr.tag_t()
special_tag1.offset = 0
special_tag1.key = pmt.string_to_symbol("spam")
special_tag1.value = pmt.to_pmt(23)
special_tag2 = gr.tag_t()
special_tag2.offset = 4
special_tag2.key = pmt.string_to_symbol("eggs")
special_tag2.value = pmt.to_pmt(42)
src = blocks.vector_source_c(tx_symbols, False, 1,
(tag, special_tag1, special_tag2))
alloc = digital.ofdm_carrier_allocator_cvc(fft_len,
occupied_carriers,
pilot_carriers,
pilot_symbols,
sync_words=(sync_word, ),
len_tag_key=tag_name)
sink = blocks.vector_sink_c(fft_len)
self.tb.connect(src, alloc, sink)
self.tb.run()
self.assertEqual(sink.data(), expected_result)
tags = [gr.tag_to_python(x) for x in sink.tags()]
tags = sorted([(x.offset, x.key, x.value) for x in tags])
tags_expected = [
(0, 'len', 3),
(0, 'spam', 23),
(2, 'eggs', 42),
]
self.assertEqual(tags, tags_expected)
def test_001_simple (self):
""" Very simple functionality testing:
- static equalizer
- init channel state with all ones
- transmit all ones
- make sure we rx all ones
- Tag check: put in frame length tag and one other random tag,
make sure they're propagated
"""
fft_len = 8
equalizer = digital.ofdm_equalizer_static(fft_len)
n_syms = 3
len_tag_key = "frame_len"
tx_data = (1,) * fft_len * n_syms
len_tag = gr.tag_t()
len_tag.offset = 0
len_tag.key = pmt.string_to_symbol(len_tag_key)
len_tag.value = pmt.from_long(n_syms)
chan_tag = gr.tag_t()
chan_tag.offset = 0
chan_tag.key = pmt.string_to_symbol("ofdm_sync_chan_taps")
chan_tag.value = pmt.init_c32vector(fft_len, (1,) * fft_len)
random_tag = gr.tag_t()
random_tag.offset = 1
random_tag.key = pmt.string_to_symbol("foo")
random_tag.value = pmt.from_long(42)
src = blocks.vector_source_c(tx_data, False, fft_len, (len_tag, chan_tag, random_tag))
eq = digital.ofdm_frame_equalizer_vcvc(equalizer.base(), 0, len_tag_key)
sink = blocks.vector_sink_c(fft_len)
self.tb.connect(src, eq, sink)
self.tb.run ()
# Check data
self.assertEqual(tx_data, sink.data())
# Check tags
tag_dict = dict()
for tag in sink.tags():
ptag = gr.tag_to_python(tag)
tag_dict[ptag.key] = ptag.value
expected_dict = {
'frame_len': n_syms,
'foo': 42
}
self.assertEqual(tag_dict, expected_dict)
def test_001_simple (self):
""" Very simple functionality testing:
- static equalizer
- init channel state with all ones
- transmit all ones
- make sure we rx all ones
- Tag check: put in frame length tag and one other random tag,
make sure they're propagated
"""
fft_len = 8
equalizer = digital.ofdm_equalizer_static(fft_len)
n_syms = 3
len_tag_key = "frame_len"
tx_data = (1,) * fft_len * n_syms
len_tag = gr.gr_tag_t()
len_tag.offset = 0
len_tag.key = pmt.pmt_string_to_symbol(len_tag_key)
len_tag.value = pmt.pmt_from_long(n_syms)
chan_tag = gr.gr_tag_t()
chan_tag.offset = 0
chan_tag.key = pmt.pmt_string_to_symbol("ofdm_sync_chan_taps")
chan_tag.value = pmt.pmt_init_c32vector(fft_len, (1,) * fft_len)
random_tag = gr.gr_tag_t()
random_tag.offset = 1
random_tag.key = pmt.pmt_string_to_symbol("foo")
random_tag.value = pmt.pmt_from_long(42)
src = gr.vector_source_c(tx_data, False, fft_len, (len_tag, chan_tag, random_tag))
eq = digital.ofdm_frame_equalizer_vcvc(equalizer.base(), 0, len_tag_key)
sink = gr.vector_sink_c(fft_len)
self.tb.connect(src, eq, sink)
self.tb.run ()
# Check data
self.assertEqual(tx_data, sink.data())
# Check tags
tag_dict = dict()
for tag in sink.tags():
ptag = gr.tag_to_python(tag)
tag_dict[ptag.key] = ptag.value
expected_dict = {
'frame_len': n_syms,
'foo': 42
}
self.assertEqual(tag_dict, expected_dict)
def test_002_t (self):
"""
once again, but this time add a sync word
"""
fft_len = 6
sync_word = (0,) * fft_len
tx_symbols = (1, 2, 3, 4, 5, 6)
pilot_symbols = ((1j,),)
occupied_carriers = ((-1, 1, 2),)
pilot_carriers = ((3,),)
expected_result = sync_word + (1j, 0, 1, 0, 2, 3) + (1j, 0, 4, 0, 5, 6)
special_tag1 = gr.tag_t()
special_tag1.offset = 0
special_tag1.key = pmt.string_to_symbol("spam")
special_tag1.value = pmt.to_pmt(23)
special_tag2 = gr.tag_t()
special_tag2.offset = 4
special_tag2.key = pmt.string_to_symbol("eggs")
special_tag2.value = pmt.to_pmt(42)
src = blocks.vector_source_c(
tx_symbols, False, 1,
(special_tag1, special_tag2)
)
alloc = digital.ofdm_carrier_allocator_cvc(
fft_len,
occupied_carriers,
pilot_carriers,
pilot_symbols,
sync_words=(sync_word,),
len_tag_key=self.tsb_key
)
sink = blocks.tsb_vector_sink_c(fft_len)
self.tb.connect(src, blocks.stream_to_tagged_stream(gr.sizeof_gr_complex, 1, len(tx_symbols), self.tsb_key), alloc, sink)
self.tb.run ()
self.assertEqual(sink.data()[0], expected_result)
tags = [gr.tag_to_python(x) for x in sink.tags()]
tags = sorted([(x.offset, x.key, x.value) for x in tags])
tags_expected = [
(0, 'spam', 23),
(2, 'eggs', 42),
]
self.assertEqual(tags, tags_expected)
def test_001_t (self):
nsubcarrier = 64
ntimeslots = 16
src_data = np.array([np.complex(np.random.choice([-1,1]),np.random.choice([-1,1])) for i in xrange(nsubcarrier*ntimeslots)])
src = blocks.vector_source_c(src_data,vlen=1)
stts = blocks.stream_to_tagged_stream(
gr.sizeof_gr_complex,vlen=1,
packet_len=nsubcarrier*ntimeslots,len_tag_key="frame_len")
fr = gfdms.framer_cc(nsubcarrier,ntimeslots,False,[],"frame_len")
dst = blocks.vector_sink_c(vlen=1)
expected_result = mod.reshape_input(src_data, ntimeslots, nsubcarrier)
self.tb.connect(src,stts)
self.tb.connect(stts,fr)
self.tb.connect(fr,dst)
self.tb.run()
result_data = dst.data()
tags = dst.tags()
for tag in tags:
ptag = gr.tag_to_python(tag)
pprint(vars(ptag))
self.assertComplexTuplesAlmostEqual(expected_result,result_data, 6)
def test_001_offset_2sym (self):
""" Add a frequency offset, check if it's correctly detected.
Also add some random tags and see if they come out at the correct
position. """
fft_len = 16
carr_offset = -2
sync_symbol1 = (0, 0, 0, 1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, 0)
sync_symbol2 = (0, 0, 0, 1, -1, 1, -1, 1, 0, 1, -1, -1, -1, 1, 0, 0)
data_symbol = (0, 0, 0, 1, -1, 1, -1, 1, 0, 1, -1, -1, -1, 1, 0, 0)
tx_data = shift_tuple(sync_symbol1, carr_offset) + \
shift_tuple(sync_symbol2, carr_offset) + \
shift_tuple(data_symbol, carr_offset)
tag1 = gr.tag_t()
tag1.offset = 0
tag1.key = pmt.string_to_symbol("test_tag_1")
tag1.value = pmt.from_long(23)
tag2 = gr.tag_t()
tag2.offset = 2
tag2.key = pmt.string_to_symbol("test_tag_2")
tag2.value = pmt.from_long(42)
src = blocks.vector_source_c(tx_data, False, fft_len, (tag1, tag2))
chanest = digital.ofdm_chanest_vcvc(sync_symbol1, sync_symbol2, 1)
sink = blocks.vector_sink_c(fft_len)
self.tb.connect(src, chanest, sink)
self.tb.run()
self.assertEqual(shift_tuple(sink.data(), -carr_offset), data_symbol)
tags = sink.tags()
ptags = {}
for tag in tags:
ptag = gr.tag_to_python(tag)
ptags[ptag.key] = (ptag.value, ptag.offset)
if ptag.key == 'ofdm_sync_chan_taps':
ptags[ptag.key] = (None, ptag.offset)
expected_tags = {
'ofdm_sync_carr_offset': (-2, 0),
'ofdm_sync_chan_taps': (None, 0),
'test_tag_1': (23, 0),
'test_tag_2': (42, 0),
}
self.assertEqual(ptags, expected_tags)
def test_001_offset_2sym (self):
""" Add a frequency offset, check if it's correctly detected.
Also add some random tags and see if they come out at the correct
position. """
fft_len = 16
carr_offset = -2
sync_symbol1 = (0, 0, 0, 1, 0, 1, 0, -1, 0, 1, 0, -1, 0, 1, 0, 0)
sync_symbol2 = (0, 0, 0, 1, -1, 1, -1, 1, 0, 1, -1, -1, -1, 1, 0, 0)
data_symbol = (0, 0, 0, 1, -1, 1, -1, 1, 0, 1, -1, -1, -1, 1, 0, 0)
tx_data = shift_tuple(sync_symbol1, carr_offset) + \
shift_tuple(sync_symbol2, carr_offset) + \
shift_tuple(data_symbol, carr_offset)
tag1 = gr.tag_t()
tag1.offset = 0
tag1.key = pmt.string_to_symbol("test_tag_1")
tag1.value = pmt.from_long(23)
tag2 = gr.tag_t()
tag2.offset = 2
tag2.key = pmt.string_to_symbol("test_tag_2")
tag2.value = pmt.from_long(42)
src = blocks.vector_source_c(tx_data, False, fft_len, (tag1, tag2))
chanest = digital.ofdm_chanest_vcvc(sync_symbol1, sync_symbol2, 1)
sink = blocks.vector_sink_c(fft_len)
self.tb.connect(src, chanest, sink)
self.tb.run()
self.assertEqual(shift_tuple(sink.data(), -carr_offset), data_symbol)
tags = sink.tags()
ptags = {}
for tag in tags:
ptag = gr.tag_to_python(tag)
ptags[ptag.key] = (ptag.value, ptag.offset)
if ptag.key == 'ofdm_sync_chan_taps':
ptags[ptag.key] = (None, ptag.offset)
expected_tags = {
'ofdm_sync_carr_offset': (-2, 0),
'ofdm_sync_chan_taps': (None, 0),
'test_tag_1': (23, 0),
'test_tag_2': (42, 0),
}
self.assertEqual(ptags, expected_tags)
def work(self, input_items, output_items): nread = self.nitems_read(0) items = len(input_items[0]) #print nread, items tags = self.get_tags_in_range(0, nread, nread + items) for t in tags: tag = gr.tag_to_python(t) #print t, tag #print dir(tag) #'key', 'offset', 'srcid', 'value' #print tag.offset, tag.srcid, tag.key, tag.value if tag.key == 'rx_time': whole_sec = tag.value[0] frac_sec = tag.value[1] self.time = whole_sec + frac_sec #print "[%s] %s: %f" % (tag.offset, tag.value, self.time) return -1 self.consume_each(items) return 0
def work(self, input_items, output_items):
nread = self.nitems_read(0)
items = len(input_items[0])
#print nread, items
tags = self.get_tags_in_range(0, nread, nread + items)
for t in tags:
tag = gr.tag_to_python(t)
#print t, tag
#print dir(tag)
#'key', 'offset', 'srcid', 'value'
#print tag.offset, tag.srcid, tag.key, tag.value
if tag.key == 'rx_time':
whole_sec = tag.value[0]
frac_sec = tag.value[1]
self.time = whole_sec + frac_sec
#print "[%s] %s: %f" % (tag.offset, tag.value, self.time)
return -1
self.consume_each(items)
return 0
def test_001_tx (self):
""" Just make sure the Tx works in general """
# This tag gets put onto the first item of the transmit data,
# it should be transmitted first, too
timing_tag = gr.tag_t()
timing_tag.offset = 0
timing_tag.key = pmt.string_to_symbol('tx_timing')
timing_tag.value = pmt.to_pmt('now')
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_fg = ofdm_tx_fg(test_data, len_tag_key, additional_tags=[timing_tag,])
tx_fg.run()
self.assertEqual(len(tx_fg.get_tx_samples()), n_samples_expected)
tags_rx = [gr.tag_to_python(x) for x in tx_fg.sink.tags()]
tags_rx = sorted([(x.offset, x.key, x.value) for x in tags_rx])
tags_expected = [
(0, 'frame_len', n_samples_expected),
(0, 'tx_timing', 'now'),
]
self.assertEqual(tags_rx, tags_expected)
def work(self, input_items, output_items):
"""example: multiply with constant"""
if self.worker.is_alive():
return len(input_items[0])
if self.drop:
self.drop = False
self.message_port_pub(
pmt.intern('drop'),
pmt.from_bool(False),
)
if input_items[0].shape[0] == self.nsamples:
print(datetime.now())
tags = self.get_tags_in_window(0, 0, self.nsamples)
for tag in tags:
tag = gr.tag_to_python(tag)
if tag.key == 'rx_freq':
self.rx_freq = tag.value
if tag.key == 'rx_rate':
self.rx_rate = tag.value
self.worker = Process(target=gen_spectrogram,
args=(
input_items[0].copy(),
self.rx_freq,
self.rx_rate,
))
# self.worker.setDaemon(True)
self.worker.start()
self.message_port_pub(pmt.intern('drop'), pmt.from_bool(True))
self.drop = True
return self.nsamples
return 0
def test_001_t (self):
len_tag_key = "packet_len"
len_frame_tag_key = "frame_length"
maxS = 3
ownID = 2
maxPad = 1
header_one = [2,0,1,2,0,0]
header_two = [100,1,1,2,0,0] #too long
header_three = [1,2,1,3,0,0] #wrong receiver
header_four = [1,0,1,2,10,0] #too much padding
src_data = header_one + header_two + header_three + header_four
src_tags = make_tags(len_tag_key, len_frame_tag_key)
src = blocks.vector_source_b(src_data, repeat = False, tags = src_tags)
parser = ownHeader.parse_header_bb(len_tag_key,len_frame_tag_key, maxS, ownID, maxPad)
dest = blocks.tsb_vector_sink_b(1,len_tag_key)
self.tb.connect(src,parser,dest)
self.tb.run ()
dest_data = dest.data()
dest_tags = dest.tags()
self.assertEqual(len(dest_data),4)
self.assertEqual(dest_data, ((1,),(0,),(0,),(0,),))
tags = [gr.tag_to_python(x) for x in dest_tags]
self.assertEqual(len(tags),6)
zero = []
one = []
two = []
three = []
for tag in tags:
if tag.offset ==0:
zero.append(tag)
elif tag.offset ==1:
one.append(tag)
elif tag.offset == 2:
two.append(tag)
else :
three.append(tag)
self.assertEqual(len(zero),6)
def test_with_tags_2s_rolloff(self):
" With tags and a 2-sample rolloff "
fft_len = 8
cp_len = 2
tag_name = "ts_last"
expected_result = (7.0 / 2, 8, 1, 2, 3, 4, 5, 6, 7, 8, # 1.0/2
7.0 / 2+1.0 / 2, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1.0 / 2)
tag2 = gr.tag_t()
tag2.offset = 1
tag2.key = pmt.string_to_symbol("random_tag")
tag2.value = pmt.from_long(42)
src = blocks.vector_source_c(list(range(1, fft_len+1)) * 2, False, fft_len, (tag2,))
cp = digital.ofdm_cyclic_prefixer(fft_len, fft_len + cp_len, 2, tag_name)
sink = blocks.tsb_vector_sink_c(tsb_key=tag_name)
self.tb.connect(src, blocks.stream_to_tagged_stream(gr.sizeof_gr_complex, fft_len, 2, tag_name), cp, sink)
self.tb.run()
self.assertEqual(sink.data()[0], expected_result)
tags = [gr.tag_to_python(x) for x in sink.tags()]
tags = sorted([(x.offset, x.key, x.value) for x in tags])
expected_tags = [
(fft_len+cp_len, "random_tag", 42)
]
self.assertEqual(tags, expected_tags)
def test_001_t (self):
packet_len = 96;
pad_zeros = 4;
len_tag_key = 'packet_len'
src = blocks.vector_source_f(range(packet_len), False)
sink = blocks.vector_sink_f()
self.tb.connect(
src,
blocks.stream_to_tagged_stream(gr.sizeof_float, 1, packet_len, len_tag_key),
fosdem.burst_marker(gr.sizeof_float, len_tag_key, pad_zeros),
sink,
)
self.tb.run ()
self.assertFloatTuplesAlmostEqual(sink.data(), range(packet_len) + [0.0,] * pad_zeros)
tags = [gr.tag_to_python(x) for x in sink.tags()]
tags = sorted([(x.offset, x.key, x.value) for x in tags])
tags_expected = [
(0, len_tag_key, packet_len + pad_zeros), # Hard coded time value :( Is n_zeros/sampling_rate
(0, 'tx_sob', True),
(packet_len + pad_zeros - 1, 'tx_eob', True),
]
self.assertEqual(tags, tags_expected)
print tags
def test_002_symbols (self):
"""
Same as before, but operate on symbols
"""
n_zeros = 1
items_per_symbol = 3
gi = 1
n_symbols = 4
header = (1, 2, 3)
payload = (1, 2, 3)
data_signal = (0,) * n_zeros + (0,) + header + ((0,) + payload) * n_symbols
trigger_signal = [0,] * len(data_signal)
trigger_signal[n_zeros] = 1
# This is dropped:
testtag1 = gr.tag_t()
testtag1.offset = 0
testtag1.key = pmt.string_to_symbol('tag1')
testtag1.value = pmt.from_long(0)
# This goes on output 0, item 0 (from the GI)
testtag2 = gr.tag_t()
testtag2.offset = n_zeros
testtag2.key = pmt.string_to_symbol('tag2')
testtag2.value = pmt.from_long(23)
# This goes on output 0, item 0 (middle of the header symbol)
testtag3 = gr.tag_t()
testtag3.offset = n_zeros + gi + 1
testtag3.key = pmt.string_to_symbol('tag3')
testtag3.value = pmt.from_long(42)
# This goes on output 1, item 1 (middle of the first payload symbol)
testtag4 = gr.tag_t()
testtag4.offset = n_zeros + (gi + items_per_symbol) * 2 + 1
testtag4.key = pmt.string_to_symbol('tag4')
testtag4.value = pmt.from_long(314)
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) / items_per_symbol, # Header length (in symbols)
items_per_symbol, # Items per symbols
gi, # Items per guard time
"frame_len", # Frame length tag key
"detect", # Trigger tag key
True, # Output symbols (not items)
gr.sizeof_float # Bytes per item
)
self.assertEqual(pmt.length(hpd.message_ports_in()), 1)
header_sink = blocks.vector_sink_f(items_per_symbol)
payload_sink = blocks.vector_sink_f(items_per_symbol)
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(n_symbols)
)
while len(payload_sink.data()) < len(payload) * n_symbols:
time.sleep(.2)
self.tb.stop()
self.tb.wait()
self.assertEqual(header_sink.data(), header)
self.assertEqual(payload_sink.data(), payload * n_symbols)
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': 0},
]
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': 1},
]
self.assertEqual(expected_tags_payload, ptags_payload)
def compare_tags(a, b):
a = gr.tag_to_python(a)
b = gr.tag_to_python(b)
return a.key == b.key and a.offset == b.offset and \
a.value == b.value
def test_003_t (self):
"""
Like test 1, but twice, plus one fail
"""
### Tx Data
n_zeros = 5
header = (1, 2, 3)
header_fail = (-1, -2, -4) # Contents don't really matter
payload1 = tuple(range(5, 20))
payload2 = (42,)
sampling_rate = 2
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
print("Triggers at: {0} {1} {2}".format(
n_zeros,
len(data_signal),
len(data_signal)+len(header_fail)+n_zeros)
)
tx_signal = data_signal + \
header_fail + (0,) * n_zeros + \
header + payload2 + (0,) * 1000
# Timing tag: This is preserved and updated:
timing_tag = make_tag('rx_time', (0, 0), 0)
# Rx freq tags:
rx_freq_tag1 = make_tag('rx_freq', 1.0, 0)
rx_freq_tag2 = make_tag('rx_freq', 1.5, 29)
rx_freq_tag3 = make_tag('rx_freq', 2.0, 30)
### Flow graph
data_src = blocks.vector_source_f(
tx_signal, False,
tags=(timing_tag, rx_freq_tag1, rx_freq_tag2, rx_freq_tag3)
)
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(
header_len=len(header),
items_per_symbol=1,
guard_interval=0,
length_tag_key="frame_len",
trigger_tag_key="detect",
output_symbols=False,
itemsize=gr.sizeof_float,
timing_tag_key='rx_time',
samp_rate=sampling_rate,
special_tags=('rx_freq',),
)
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()
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()
# Signal description:
# 0: 5 zeros
# 5: header 1
# 8: payload 1 (length: 15)
# 23: header 2 (fail)
# 26: 5 zeros
# 31: header 3
# 34: payload 2 (length 1)
# 35: 1000 zeros
self.assertEqual(header_sink.data(), header + header_fail + header)
self.assertEqual(payload_sink.data(), payload1 + payload2)
tags_payload = [gr.tag_to_python(x) for x in payload_sink.tags()]
tags_payload = sorted([(x.offset, x.key, x.value) for x in tags_payload])
tags_expected_payload = [
(0, 'frame_len', len(payload1)),
(len(payload1), 'frame_len', len(payload2)),
]
tags_header = [gr.tag_to_python(x) for x in header_sink.tags()]
tags_header = sorted([(x.offset, x.key, x.value) for x in tags_header])
tags_expected_header = [
(0, 'rx_freq', 1.0),
(0, 'rx_time', (2, 0.5)), # Hard coded time value :( Is n_zeros/sampling_rate
(len(header), 'rx_freq', 1.0),
(len(header), 'rx_time', (11, .5)), # Hard coded time value :(. See above.
(2*len(header), 'rx_freq', 2.0),
(2*len(header), 'rx_time', (15, .5)), # Hard coded time value :(. See above.
]
self.assertEqual(tags_header, tags_expected_header)
self.assertEqual(tags_payload, tags_expected_payload)
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 = gr.tag_t()
testtag1.offset = 0
testtag1.key = pmt.string_to_symbol('tag1')
testtag1.value = pmt.from_long(0)
# This goes on output 0, item 0:
testtag2 = gr.tag_t()
testtag2.offset = n_zeros
testtag2.key = pmt.string_to_symbol('tag2')
testtag2.value = pmt.from_long(23)
# This goes on output 0, item 2:
testtag3 = gr.tag_t()
testtag3.offset = n_zeros + len(header) - 1
testtag3.key = pmt.string_to_symbol('tag3')
testtag3.value = pmt.from_long(42)
# This goes on output 1, item 3:
testtag4 = gr.tag_t()
testtag4.offset = n_zeros + len(header) + 3
testtag4.key = pmt.string_to_symbol('tag4')
testtag4.value = pmt.from_long(314)
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)
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()
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(payload)))
while len(payload_sink.data()) < len(payload):
time.sleep(.2)
self.tb.stop()
self.tb.wait()
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_003_t(self):
"""
Like test 1, but twice, plus one fail
"""
### Tx Data
n_zeros = 5
header = (1, 2, 3)
header_fail = (-1, -2, -4) # Contents don't really matter
payload1 = tuple(range(5, 20))
payload2 = (42, )
sampling_rate = 2
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
# Timing tag: This is preserved and updated:
timing_tag = gr.tag_t()
timing_tag.offset = 0
timing_tag.key = pmt.string_to_symbol('rx_time')
timing_tag.value = pmt.to_pmt((0, 0))
# Rx freq tags:
rx_freq_tag1 = gr.tag_t()
rx_freq_tag1.offset = 0
rx_freq_tag1.key = pmt.string_to_symbol('rx_freq')
rx_freq_tag1.value = pmt.from_double(1.0)
rx_freq_tag2 = gr.tag_t()
rx_freq_tag2.offset = 29
rx_freq_tag2.key = pmt.string_to_symbol('rx_freq')
rx_freq_tag2.value = pmt.from_double(1.5)
rx_freq_tag3 = gr.tag_t()
rx_freq_tag3.offset = 30
rx_freq_tag3.key = pmt.string_to_symbol('rx_freq')
rx_freq_tag3.value = pmt.from_double(2.0)
### Flow graph
data_src = blocks.vector_source_f(tx_signal,
False,
tags=(timing_tag, rx_freq_tag1,
rx_freq_tag2, rx_freq_tag3))
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(
header_len=len(header),
items_per_symbol=1,
guard_interval=0,
length_tag_key="frame_len",
trigger_tag_key="detect",
output_symbols=False,
itemsize=gr.sizeof_float,
timing_tag_key='rx_time',
samp_rate=sampling_rate,
special_tags=('rx_freq', ),
)
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()
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()
# Signal description:
# 0: 5 zeros
# 5: header 1
# 8: payload 1 (length: 15)
# 23: header 2 (fail)
# 26: 5 zeros
# 31: header 3
# 34: payload 2 (length 1)
# 35: 1000 zeros
self.assertEqual(header_sink.data(), header + header_fail + header)
self.assertEqual(payload_sink.data(), payload1 + payload2)
tags_payload = [gr.tag_to_python(x) for x in payload_sink.tags()]
tags_payload = sorted([(x.offset, x.key, x.value)
for x in tags_payload])
tags_expected_payload = [
(0, 'frame_len', len(payload1)),
(len(payload1), 'frame_len', len(payload2)),
]
tags_header = [gr.tag_to_python(x) for x in header_sink.tags()]
tags_header = sorted([(x.offset, x.key, x.value) for x in tags_header])
tags_expected_header = [
(0, 'rx_freq', 1.0),
(0, 'rx_time',
(2, 0.5)), # Hard coded time value :( Is n_zeros/sampling_rate
(len(header), 'rx_freq', 1.0),
(len(header), 'rx_time',
(11, .5)), # Hard coded time value :(. See above.
(2 * len(header), 'rx_freq', 2.0),
(2 * len(header), 'rx_time',
(15, .5)), # Hard coded time value :(. See above.
]
self.assertEqual(tags_header, tags_expected_header)
self.assertEqual(tags_payload, tags_expected_payload)
def test_002_symbols(self):
"""
Same as before, but operate on symbols
"""
n_zeros = 1
items_per_symbol = 3
gi = 1
n_symbols = 4
header = (1, 2, 3)
payload = (1, 2, 3)
data_signal = (0, ) * n_zeros + (0, ) + header + (
(0, ) + payload) * n_symbols
trigger_signal = [
0,
] * len(data_signal)
trigger_signal[n_zeros] = 1
# This is dropped:
testtag1 = gr.tag_t()
testtag1.offset = 0
testtag1.key = pmt.string_to_symbol('tag1')
testtag1.value = pmt.from_long(0)
# This goes on output 0, item 0 (from the GI)
testtag2 = gr.tag_t()
testtag2.offset = n_zeros
testtag2.key = pmt.string_to_symbol('tag2')
testtag2.value = pmt.from_long(23)
# This goes on output 0, item 0 (middle of the header symbol)
testtag3 = gr.tag_t()
testtag3.offset = n_zeros + gi + 1
testtag3.key = pmt.string_to_symbol('tag3')
testtag3.value = pmt.from_long(42)
# This goes on output 1, item 1 (middle of the first payload symbol)
testtag4 = gr.tag_t()
testtag4.offset = n_zeros + (gi + items_per_symbol) * 2 + 1
testtag4.key = pmt.string_to_symbol('tag4')
testtag4.value = pmt.from_long(314)
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) / items_per_symbol, # Header length (in symbols)
items_per_symbol, # Items per symbols
gi, # Items per guard time
"frame_len", # Frame length tag key
"detect", # Trigger tag key
True, # Output symbols (not items)
gr.sizeof_float # Bytes per item
)
self.assertEqual(pmt.length(hpd.message_ports_in()),
2) #extra system port defined for you
header_sink = blocks.vector_sink_f(items_per_symbol)
payload_sink = blocks.vector_sink_f(items_per_symbol)
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(n_symbols))
while len(payload_sink.data()) < len(payload) * n_symbols:
time.sleep(.2)
self.tb.stop()
self.tb.wait()
self.assertEqual(header_sink.data(), header)
self.assertEqual(payload_sink.data(), payload * n_symbols)
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': 0
},
]
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': 1
},
]
self.assertEqual(expected_tags_payload, ptags_payload)
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 = gr.tag_t()
testtag1.offset = 0
testtag1.key = pmt.string_to_symbol('tag1')
testtag1.value = pmt.from_long(0)
# This goes on output 0, item 0:
testtag2 = gr.tag_t()
testtag2.offset = n_zeros
testtag2.key = pmt.string_to_symbol('tag2')
testtag2.value = pmt.from_long(23)
# This goes on output 0, item 2:
testtag3 = gr.tag_t()
testtag3.offset = n_zeros + len(header) - 1
testtag3.key = pmt.string_to_symbol('tag3')
testtag3.value = pmt.from_long(42)
# This goes on output 1, item 3:
testtag4 = gr.tag_t()
testtag4.offset = n_zeros + len(header) + 3
testtag4.key = pmt.string_to_symbol('tag4')
testtag4.value = pmt.from_long(314)
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
)
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(payload))
)
while len(payload_sink.data()) < len(payload):
time.sleep(.2)
self.tb.stop()
self.tb.wait()
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 = gr.tag_t()
trigger_tag.offset = n_zeros
trigger_tag.key = pmt.string_to_symbol('detect')
trigger_tag.value = pmt.PMT_T
# This is dropped:
testtag1 = gr.tag_t()
testtag1.offset = 0
testtag1.key = pmt.string_to_symbol('tag1')
testtag1.value = pmt.from_long(0)
# This goes on output 0, item 0:
testtag2 = gr.tag_t()
testtag2.offset = n_zeros
testtag2.key = pmt.string_to_symbol('tag2')
testtag2.value = pmt.from_long(23)
# This goes on output 0, item 2:
testtag3 = gr.tag_t()
testtag3.offset = n_zeros + len(header) - 1
testtag3.key = pmt.string_to_symbol('tag3')
testtag3.value = pmt.from_long(42)
# This goes on output 1, item 3:
testtag4 = gr.tag_t()
testtag4.offset = n_zeros + len(header) + 3
testtag4.key = pmt.string_to_symbol('tag4')
testtag4.value = pmt.from_long(314)
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()
self.tb.connect(data_src, (hpd, 0))
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(payload))
)
while len(payload_sink.data()) < len(payload):
time.sleep(.2)
self.tb.stop()
self.tb.wait()
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_headerpadding (self):
""" Like test 1, but with header padding. """
n_zeros = 3
header = (1, 2, 3)
header_padding = 1
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, # Items per symbol
0, # Guard interval
"frame_len", # TSB tag key
"detect", # Trigger tag key
False, # No symbols please
gr.sizeof_float, # Item size
"", # Timing tag key
1.0, # Samp rate
(), # No special tags
header_padding
)
mock_header_demod = HeaderToMessageBlock(
numpy.float32,
len(header),
[len(payload)]
)
header_sink = blocks.vector_sink_f()
payload_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)+2)
# Check values
# Header now is padded:
self.assertEqual(header_sink.data(), (0,) + header + (payload[0],))
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': 1},
{'key': 'tag3', 'offset': 3},
]
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_headerpadding_payload_offset (self):
""" Like test 1, but with header padding + payload offset. """
n_zeros = 3
header = (1, 2, 3)
header_padding = 1
payload_offset = -1
payload = tuple(range(5, 20))
data_signal = (0,) * n_zeros + header + payload + (0,) * 100
trigger_signal = [0] * len(data_signal)
trigger_signal[n_zeros] = 1
# This goes on output 1, item 3 + 1 (for payload offset)
testtag4 = make_tag('tag4', 314, n_zeros + len(header) + 3)
data_src = blocks.vector_source_f(
data_signal,
False,
tags=(testtag4,)
)
trigger_src = blocks.vector_source_b(trigger_signal, False)
hpd = digital.header_payload_demux(
len(header),
1, # Items per symbol
0, # Guard interval
"frame_len", # TSB tag key
"detect", # Trigger tag key
False, # No symbols please
gr.sizeof_float, # Item size
"", # Timing tag key
1.0, # Samp rate
(), # No special tags
header_padding
)
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()
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.to_pmt({'frame_len': len(payload), 'payload_offset': payload_offset})
)
while len(payload_sink.data()) < len(payload):
time.sleep(.2)
self.tb.stop()
self.tb.wait()
# Header is now padded:
self.assertEqual(header_sink.data(), (0,) + header + (payload[0],))
# Payload is now offset:
self.assertEqual(
payload_sink.data(),
data_signal[n_zeros + len(header) + payload_offset:n_zeros + len(header) + payload_offset + len(payload)]
)
ptags_payload = {}
for tag in payload_sink.tags():
ptag = gr.tag_to_python(tag)
ptags_payload[ptag.key] = ptag.offset
expected_tags_payload = {
'frame_len': 0,
'payload_offset': 0,
'tag4': 3 - payload_offset,
}
self.assertEqual(expected_tags_payload, ptags_payload)
def test_002_static (self):
"""
- Add a simple channel
- Make symbols QPSK
"""
fft_len = 8
# 4 5 6 7 0 1 2 3
tx_data = [-1, -1, 1, 2, -1, 3, 0, -1, # 0
-1, -1, 0, 2, -1, 2, 0, -1, # 8
-1, -1, 3, 0, -1, 1, 0, -1, # 16 (Pilot symbols)
-1, -1, 1, 1, -1, 0, 2, -1] # 24
cnst = digital.constellation_qpsk()
tx_signal = [cnst.map_to_points_v(x)[0] if x != -1 else 0 for x in tx_data]
occupied_carriers = ((1, 2, 6, 7),)
pilot_carriers = ((), (), (1, 2, 6, 7), ())
pilot_symbols = (
[], [], [cnst.map_to_points_v(x)[0] for x in (1, 0, 3, 0)], []
)
equalizer = digital.ofdm_equalizer_static(fft_len, occupied_carriers, pilot_carriers, pilot_symbols)
channel = [
0, 0, 1, 1, 0, 1, 1, 0,
0, 0, 1, 1, 0, 1, 1, 0, # These coefficients will be rotated slightly (but less than \pi/2)
0, 0, 1j, 1j, 0, 1j, 1j, 0, # Go crazy here!
0, 0, 1j, 1j, 0, 1j, 1j, 0
]
channel = [
0, 0, 1, 1, 0, 1, 1, 0,
0, 0, 1, 1, 0, 1, 1, 0, # These coefficients will be rotated slightly (but less than \pi/2)
0, 0, 1j, 1j, 0, 1j, 1j, 0, # Go crazy here!
0, 0, 1j, 1j, 0, 1j, 1j, 0
]
for idx in range(fft_len, 2*fft_len):
channel[idx] = channel[idx-fft_len] * numpy.exp(1j * .1 * numpy.pi * (numpy.random.rand()-.5))
len_tag_key = "frame_len"
len_tag = gr.gr_tag_t()
len_tag.offset = 0
len_tag.key = pmt.pmt_string_to_symbol(len_tag_key)
len_tag.value = pmt.pmt_from_long(4)
chan_tag = gr.gr_tag_t()
chan_tag.offset = 0
chan_tag.key = pmt.pmt_string_to_symbol("ofdm_sync_chan_taps")
chan_tag.value = pmt.pmt_init_c32vector(fft_len, channel[:fft_len])
src = gr.vector_source_c(numpy.multiply(tx_signal, channel), False, fft_len, (len_tag, chan_tag))
eq = digital.ofdm_frame_equalizer_vcvc(equalizer.base(), 0, len_tag_key, True)
sink = gr.vector_sink_c(fft_len)
self.tb.connect(src, eq, sink)
self.tb.run ()
rx_data = [cnst.decision_maker_v((x,)) if x != 0 else -1 for x in sink.data()]
# Check data
self.assertEqual(tx_data, rx_data)
# Check tags
tag_dict = dict()
for tag in sink.tags():
ptag = gr.tag_to_python(tag)
tag_dict[ptag.key] = ptag.value
if ptag.key == 'ofdm_sync_chan_taps':
tag_dict[ptag.key] = list(pmt.pmt_c32vector_elements(tag.value))
else:
tag_dict[ptag.key] = pmt.to_python(tag.value)
expected_dict = {
'frame_len': 4,
'ofdm_sync_chan_taps': channel[-fft_len:]
}
self.assertEqual(tag_dict, expected_dict)
