def test_002(self):
offset = 10
key = pmt.string_to_symbol('key')
value = pmt.from_long(23)
srcid = pmt.from_bool(False)
format_dict = {
'offset': offset,
'key': key,
'value': value,
'srcid': srcid
}
format_list = [offset, key, value, srcid]
format_tuple = (offset, key, value, srcid)
t_dict = gr.python_to_tag(format_dict)
t_list = gr.python_to_tag(format_list)
t_tuple = gr.python_to_tag(format_tuple)
self.assertTrue(pmt.equal(t_dict.key, key))
self.assertTrue(pmt.equal(t_dict.value, value))
self.assertEqual(t_dict.offset, offset)
self.assertTrue(pmt.equal(t_list.key, key))
self.assertTrue(pmt.equal(t_list.value, value))
self.assertEqual(t_list.offset, offset)
self.assertTrue(pmt.equal(t_tuple.key, key))
self.assertTrue(pmt.equal(t_tuple.value, value))
self.assertEqual(t_tuple.offset, offset)
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 = blocks.tagged_stream_to_pdu(blocks.byte_t, "len")
pdu_send = blocks.socket_pdu("UDP_CLIENT", "localhost", "4141")
#pdu_recv = blocks.socket_pdu("UDP_SERVER", "localhost", port)
pdu_to_ts = blocks.pdu_to_tagged_stream(blocks.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 make_length_tag(offset, length):
return gr.python_to_tag({
'offset': offset,
'key': pmt.intern('packet_len'),
'value': pmt.from_long(length),
'srcid': pmt.intern('qa_burst_shaper')
})
def make_tag(offset, key, value):
return gr.python_to_tag({
'offset': offset,
'key': pmt.intern(key),
'value': value,
'srcid': pmt.intern('qa_burst_shaper')
})
def work(self, input_items, output_items):
in0 = input_items[0]
out = output_items[0]
ninput_items = len(in0)
noutput_items = min(ninput_items, len(out))
out[:noutput_items] = in0[:noutput_items]
if self.tag_stream:
tag = gr.python_to_tag({
"offset": self.nitems_read(0)+ninput_items,
"key": self.stream_tag_key,
"value": self.stream_tag_value,
"srcid": self.stream_tag_srcid,
})
self.add_item_tag(0, tag)
self.tag_stream = False
return noutput_items
def setUp(self):
self.syncword_tag = 'syncword'
self.packetlen_tag = 'packet_len'
self.packet_len = 100
self.data = np.arange(3000, dtype='uint8')
self.tag_positions = [50, 213, 217, 230, 1530, 1531]
tags = [gr.python_to_tag((j, pmt.intern(self.syncword_tag),
pmt.intern('sync'), pmt.intern('test_src')))
for j in self.tag_positions]
self.source = blocks.vector_source_b(self.data, False, 1, tags)
self.tag2pdu = blocks.tagged_stream_to_pdu(byte_t,
self.packetlen_tag)
self.debug = blocks.message_debug()
self.tagger = fixedlen_tagger(self.syncword_tag, self.packetlen_tag,
self.packet_len, np.byte)
self.tb = gr.top_block()
self.tb.connect(self.source, self.tagger, self.tag2pdu)
self.tb.msg_connect((self.tag2pdu, 'pdus'), (self.debug, 'store'))
def phy_tag(offset=0,
key='phy',
nitems=0,
rate=0,
flag=0,
rx_time=0,
payload_sample_index=0):
tag = gr.python_to_tag({
'offset':
offset,
'key':
pmt.intern(key),
'srcid':
pmt.from_bool(False),
'value':
phy_tag_create(nitems=nitems,
rate=rate,
flag=flag,
rx_time=rx_time,
payload_sample_index=payload_sample_index)
})
return tag
