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