def test_003_tags_plus_data(self):
packet_len = 16
src_data = list(range(packet_len))
tag1 = gr.tag_t()
tag1.offset = 0
tag1.key = pmt.string_to_symbol('spam')
tag1.value = pmt.from_long(23)
tag2 = gr.tag_t()
tag2.offset = 10 # Must be < packet_len
tag2.key = pmt.string_to_symbol('eggs')
tag2.value = pmt.from_long(42)
src = blocks.vector_source_f(src_data, tags=(tag1, tag2))
s2ts = blocks.stream_to_tagged_stream(gr.sizeof_float,
vlen=1,
packet_len=packet_len,
len_tag_key="packet_len")
ts2pdu = pdu.tagged_stream_to_pdu(gr.types.float_t, "packet_len")
dbg = blocks.message_debug()
self.tb.connect(src, s2ts, ts2pdu)
self.tb.msg_connect(ts2pdu, "pdus", dbg, "store")
self.tb.start()
self.tb.wait()
result_msg = dbg.get_message(0)
metadata = pmt.to_python(pmt.car(result_msg))
vector = pmt.f32vector_elements(pmt.cdr(result_msg))
self.assertEqual(metadata, {'eggs': 42, 'spam': 23})
self.assertFloatTuplesAlmostEqual(tuple(vector), src_data)
def test_003(self):
# Test that block stops when interacting with streaming interface
port = str(random.Random().randint(0, 30000) + 10000)
srcdata = (0x73, 0x75, 0x63, 0x68, 0x74, 0x65, 0x73, 0x74, 0x76, 0x65,
0x72, 0x79, 0x70, 0x61, 0x73, 0x73)
tag_dict = {"offset": 0}
tag_dict["key"] = pmt.intern("len")
tag_dict["value"] = pmt.from_long(8)
tag1 = gr.python_to_tag(tag_dict)
tag_dict["offset"] = 8
tag2 = gr.python_to_tag(tag_dict)
tags = [tag1, tag2]
src = blocks.vector_source_b(srcdata, False, 1, tags)
ts_to_pdu = pdu.tagged_stream_to_pdu(gr.types.byte_t, "len")
pdu_send = network.socket_pdu("UDP_CLIENT", "localhost", "4141")
#pdu_recv = network.socket_pdu("UDP_SERVER", "localhost", port)
pdu_to_ts = pdu.pdu_to_tagged_stream(gr.types.byte_t, "len")
head = blocks.head(gr.sizeof_char, 10)
sink = blocks.vector_sink_b(1)
self.tb.connect(src, ts_to_pdu)
self.tb.msg_connect(ts_to_pdu, "pdus", pdu_send, "pdus")
# a UDP socket connects pdu_send to pdu_recv
# TODO: test that the recv socket can be destroyed from downstream
# that signals DONE. Also that we get the PDUs we sent
#self.tb.msg_connect(pdu_recv, "pdus", pdu_to_ts, "pdus")
#self.tb.connect(pdu_to_ts, head, sink)
self.tb.run()
def test_000(self):
# Just run some data through and make sure it doesn't puke.
src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
src = pdu.pdu_to_tagged_stream(gr.types.byte_t)
snk3 = pdu.tagged_stream_to_pdu(gr.types.byte_t)
snk2 = blocks.vector_sink_b()
snk = blocks.tag_debug(1, "test")
snk.set_display(False)
dbg = blocks.message_debug()
# Test that the right number of ports exist.
pi = snk3.message_ports_in()
po = snk3.message_ports_out()
# system port is defined automatically
self.assertEqual(pmt.length(pi), 1)
self.assertEqual(pmt.length(po), 1)
self.tb.connect(src, snk)
self.tb.connect(src, snk2)
self.tb.connect(src, snk3)
self.tb.msg_connect(snk3, "pdus", dbg, "store")
# make our reference and message pmts
port = pmt.intern("pdus")
msg = pmt.cons(pmt.PMT_NIL, pmt.make_u8vector(16, 0xFF))
# post the message
src.to_basic_block()._post(port, msg)
src.to_basic_block()._post(
pmt.intern("system"), pmt.cons(pmt.intern("done"),
pmt.from_long(1)))
self.tb.start()
self.tb.wait()
# Get the vector of data from the vector sink
result_data = snk2.data()
# Get the vector of data from the message sink
# Convert the message PMT as a pair into its vector
result_msg = dbg.get_message(0)
msg_vec = pmt.cdr(result_msg)
# pmt.print(msg_vec)
# Convert the PMT vector into a Python list
msg_data = []
for i in range(16):
msg_data.append(pmt.u8vector_ref(msg_vec, i))
actual_data = 16 * [
0xFF,
]
self.assertEqual(actual_data, list(result_data))
self.assertEqual(actual_data, msg_data)
def run_with_frame_len(self, frame_len):
self.tb = gr.top_block()
noise = analog.noise_source_f(analog.GR_GAUSSIAN, 1, 0)
head = blocks.head(gr.sizeof_float, self.n_frames * frame_len)
tag = blocks.stream_to_tagged_stream(gr.sizeof_float, 1, frame_len,
"packet_len")
stream2pdu = pdu.tagged_stream_to_pdu(gr.types.float_t, 'packet_len')
viterbi = fec.cc_decoder.make(frame_len // 2, 7, 2, [79, -109], 0, -1,
fec.CC_TERMINATED, False)
cc_decoder = fec.async_decoder(viterbi, False, False, frame_len)
self.tb.connect(noise, head, tag, stream2pdu)
self.tb.msg_connect((stream2pdu, 'pdus'), (cc_decoder, 'in'))
self.tb.run()
# the test is considered successful if it hasn't segfaulted or aborted
self.tb = None