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_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 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)