def test_002_tags_plus_data(self): packet_len = 16 src_data = 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 = blocks.tagged_stream_to_pdu(blocks.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() while dbg.num_messages() < 1: time.sleep(0.1) self.tb.stop() 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_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_002_32bits (self): # 3 PDUs: | | | | data = (1, 2, 3, 4, 1, 2, 1, 2, 3, 4) tagname = "packet_len" tag1 = gr.tag_t() tag1.offset = 0 tag1.key = pmt.string_to_symbol(tagname) tag1.value = pmt.from_long(4) tag2 = gr.tag_t() tag2.offset = 4 tag2.key = pmt.string_to_symbol(tagname) tag2.value = pmt.from_long(2) tag3 = gr.tag_t() tag3.offset = 6 tag3.key = pmt.string_to_symbol(tagname) tag3.value = pmt.from_long(4) src = blocks.vector_source_b(data, False, 1, (tag1, tag2, tag3)) header = digital.packet_headergenerator_bb(32, tagname) sink = blocks.vector_sink_b() self.tb.connect(src, header, sink) self.tb.run() expected_data = ( # | Number of symbols | Packet number | Parity 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ) self.assertEqual(sink.data(), expected_data)
def next_vector(self, seed, samp_rate, noise_amp, modulation, delay, samples_to_receive, freq, rx_id): timing_tag = gr.tag_t() timing_tag.offset = 0 timing_tag.key = pmt.string_to_symbol('rx_time') timing_tag.value = pmt.to_pmt((float(seed), 0.6)) timing_tag.srcid = pmt.string_to_symbol(str('gr uhd usrp source1')) # Rx freq tags: #print "In source emulation (before tag)" #print freq rx_freq_tag = gr.tag_t() rx_freq_tag.offset = 0 rx_freq_tag.key = pmt.string_to_symbol('rx_freq') rx_freq_tag.value = pmt.from_double(freq) rx_freq_tag.srcid = pmt.string_to_symbol(str('gr uhd usrp source1')) # Samp_rate tags: rx_rate_tag = gr.tag_t() rx_rate_tag.offset = 0 rx_rate_tag.key = pmt.string_to_symbol('rx_rate') rx_rate_tag.value = pmt.from_double(samp_rate) rx_rate_tag.srcid = pmt.string_to_symbol(str('gr uhd usrp source1')) pulse_width = 4 np.random.seed(seed=seed) tx_vector = np.reshape(np.matlib.repmat(np.random.randint(0,2,(5*samples_to_receive)/pulse_width)*2-1,pulse_width,1).T,[1,5*samples_to_receive])[0].tolist() # delay signal vector -> insert zeros at beginnig; nothing happens if signal has not reached the receiver: tx_vector_delayed = np.hstack((np.zeros(delay),tx_vector)) #tx_vector_delayed = tx_vector_delayed[:600] print len(tx_vector_delayed) self.vector_source.set_data(tx_vector_delayed,(timing_tag, rx_freq_tag, rx_rate_tag)) self.head.reset() self.vector_source.rewind()
def test_003_12bits_formatter_object (self): # 3 PDUs: | | | | data = (1, 2, 3, 4, 1, 2, 1, 2, 3, 4) tagname = "packet_len" tag1 = gr.tag_t() tag1.offset = 0 tag1.key = pmt.string_to_symbol(tagname) tag1.value = pmt.from_long(4) tag2 = gr.tag_t() tag2.offset = 4 tag2.key = pmt.string_to_symbol(tagname) tag2.value = pmt.from_long(2) tag3 = gr.tag_t() tag3.offset = 6 tag3.key = pmt.string_to_symbol(tagname) tag3.value = pmt.from_long(4) src = blocks.vector_source_b(data, False, 1, (tag1, tag2, tag3)) formatter_object = digital.packet_header_default(12, tagname) header = digital.packet_headergenerator_bb(formatter_object.formatter(), tagname) sink = blocks.vector_sink_b() self.tb.connect(src, header, sink) self.tb.run() expected_data = ( 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ) self.assertEqual(sink.data(), expected_data)
def test_004_8bits_formatter_ofdm (self): occupied_carriers = ((1, 2, 3, 5, 6, 7),) # 3 PDUs: | | | | data = (1, 2, 3, 4, 1, 2, 1, 2, 3, 4) tagname = "packet_len" tag1 = gr.tag_t() tag1.offset = 0 tag1.key = pmt.string_to_symbol(tagname) tag1.value = pmt.from_long(4) tag2 = gr.tag_t() tag2.offset = 4 tag2.key = pmt.string_to_symbol(tagname) tag2.value = pmt.from_long(2) tag3 = gr.tag_t() tag3.offset = 6 tag3.key = pmt.string_to_symbol(tagname) tag3.value = pmt.from_long(4) src = blocks.vector_source_b(data, False, 1, (tag1, tag2, tag3)) formatter_object = digital.packet_header_ofdm(occupied_carriers, 1, tagname) self.assertEqual(formatter_object.header_len(), 6) self.assertEqual(pmt.symbol_to_string(formatter_object.len_tag_key()), tagname) header = digital.packet_headergenerator_bb(formatter_object.formatter(), tagname) sink = blocks.vector_sink_b() self.tb.connect(src, header, sink) self.tb.run() expected_data = ( 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ) self.assertEqual(sink.data(), expected_data)
def test_005_packet_len_tag (self): """ Standard test """ fft_len = 16 tx_symbols = range(1, 16); tx_symbols = (0, 1, 1j, 2, 3, 0, 0, 0, 0, 0, 0, 4, 5, 2j, 6, 0, 0, 7, 8, 3j, 9, 0, 0, 0, 0, 0, 0, 10, 4j, 11, 12, 0, 0, 13, 1j, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 2j, 0, 0) expected_result = tuple(range(1, 16)) occupied_carriers = ((1, 3, 4, 11, 12, 14), (1, 2, 4, 11, 13, 14),) n_syms = len(tx_symbols)/fft_len tag_name = "len" tag = gr.tag_t() tag.offset = 0 tag.key = pmt.string_to_symbol(tag_name) tag.value = pmt.from_long(n_syms) tag2 = gr.tag_t() tag2.offset = 0 tag2.key = pmt.string_to_symbol("packet_len") tag2.value = pmt.from_long(len(expected_result)) src = blocks.vector_source_c(tx_symbols, False, fft_len, (tag, tag2)) serializer = digital.ofdm_serializer_vcc(fft_len, occupied_carriers, tag_name, "packet_len", 0, "", False) sink = blocks.vector_sink_c() self.tb.connect(src, serializer, sink) self.tb.run () self.assertEqual(sink.data(), expected_result) self.assertEqual(len(sink.tags()), 1) result_tag = sink.tags()[0] self.assertEqual(pmt.symbol_to_string(result_tag.key), "packet_len") self.assertEqual(pmt.to_long(result_tag.value), len(expected_result))
def test_sc_tag(self): constA = [-3.0+1j, -1.0-1j, 1.0+1j, 3-1j] constB = [12.0+1j, -12.0-1j, 6.0+1j, -6-1j] src_data = (0, 1, 2, 3, 3, 2, 1, 0) expected_result = (-3+1j, -1-1j, 1+1j, 3-1j, -6-1j, 6+1j, -12-1j, 12+1j) first_tag = gr.tag_t() first_tag.key = pmt.intern("set_symbol_table") first_tag.value = pmt.init_c32vector(len(constA), constA) first_tag.offset = 0 second_tag = gr.tag_t() second_tag.key = pmt.intern("set_symbol_table") second_tag.value = pmt.init_c32vector(len(constB), constB) second_tag.offset = 4 src = blocks.vector_source_s(src_data, False, 1, [first_tag, second_tag]) op = digital.chunks_to_symbols_sc(constB) dst = blocks.vector_sink_c() self.tb.connect(src, op) self.tb.connect(op, dst) self.tb.run() actual_result = dst.data() self.assertEqual(expected_result, actual_result)
def test_003_t (self): """ more advanced: - 6 symbols per carrier - 2 pilots per carrier - have enough data for nearly 3 OFDM symbols - send that twice - add some random tags - don't shift """ tx_symbols = list(range(1, 16)); # 15 symbols pilot_symbols = ((1j, 2j), (3j, 4j)) occupied_carriers = ((1, 3, 4, 11, 12, 14), (1, 2, 4, 11, 13, 14),) pilot_carriers = ((2, 13), (3, 12)) expected_result = (0, 1, 1j, 2, 3, 0, 0, 0, 0, 0, 0, 4, 5, 2j, 6, 0, 0, 7, 8, 3j, 9, 0, 0, 0, 0, 0, 0, 10, 4j, 11, 12, 0, 0, 13, 1j, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 2j, 0, 0) fft_len = 16 testtag1 = gr.tag_t() testtag1.offset = 0 testtag1.key = pmt.string_to_symbol('tag1') testtag1.value = pmt.from_long(0) testtag2 = gr.tag_t() testtag2.offset = 7 # On the 2nd OFDM symbol testtag2.key = pmt.string_to_symbol('tag2') testtag2.value = pmt.from_long(0) testtag3 = gr.tag_t() testtag3.offset = len(tx_symbols)+1 # First OFDM symbol of packet 2 testtag3.key = pmt.string_to_symbol('tag3') testtag3.value = pmt.from_long(0) testtag4 = gr.tag_t() testtag4.offset = 2*len(tx_symbols)-1 # Last OFDM symbol of packet 2 testtag4.key = pmt.string_to_symbol('tag4') testtag4.value = pmt.from_long(0) src = blocks.vector_source_c(tx_symbols * 2, False, 1, (testtag1, testtag2, testtag3, testtag4)) alloc = digital.ofdm_carrier_allocator_cvc(fft_len, occupied_carriers, pilot_carriers, pilot_symbols, (), self.tsb_key, False) 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_found = {'tag1': False, 'tag2': False, 'tag3': False, 'tag4': False} correct_offsets = {'tag1': 0, 'tag2': 1, 'tag3': 3, 'tag4': 5} for tag in sink.tags(): key = pmt.symbol_to_string(tag.key) if key in list(tags_found.keys()): tags_found[key] = True self.assertEqual(correct_offsets[key], tag.offset) self.assertTrue(all(tags_found.values()))
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_004_connect (self): """ Advanced test: - Allocator -> IFFT -> Frequency offset -> FFT -> Serializer - FFT does shift (moves DC to middle) - Make sure input == output - Frequency offset is -2 carriers """ fft_len = 8 n_syms = 1 carr_offset = -2 freq_offset = 1.0 / fft_len * carr_offset # Normalized frequency occupied_carriers = ((-2, -1, 1, 2),) pilot_carriers = ((-3,),(3,)) pilot_symbols = ((1j,),(-1j,)) tx_data = (1, 2, 3, 4) 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_data)) offsettag = gr.tag_t() offsettag.offset = 0 offsettag.key = pmt.string_to_symbol("ofdm_sync_carr_offset") offsettag.value = pmt.from_long(carr_offset) src = blocks.vector_source_c(tx_data, False, 1, (tag, offsettag)) alloc = digital.ofdm_carrier_allocator_cvc(fft_len, occupied_carriers, pilot_carriers, pilot_symbols, (), tag_name) tx_ifft = fft.fft_vcc(fft_len, False, (1.0/fft_len,)*fft_len, True) oscillator = analog.sig_source_c(1.0, analog.GR_COS_WAVE, freq_offset, 1.0/fft_len) mixer = blocks.multiply_cc() rx_fft = fft.fft_vcc(fft_len, True, (), True) sink2 = blocks.vector_sink_c(fft_len) self.tb.connect(rx_fft, sink2) serializer = digital.ofdm_serializer_vcc( alloc, "", 0, "ofdm_sync_carr_offset", True ) sink = blocks.vector_sink_c() self.tb.connect( src, alloc, tx_ifft, blocks.vector_to_stream(gr.sizeof_gr_complex, fft_len), (mixer, 0), blocks.stream_to_vector(gr.sizeof_gr_complex, fft_len), rx_fft, serializer, sink ) self.tb.connect(oscillator, (mixer, 1)) self.tb.run () self.assertComplexTuplesAlmostEqual(sink.data()[-len(occupied_carriers[0]):], tx_data, places=4)
def test_002_simpledfe (self): """ Use the simple DFE equalizer. """ 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_simpledfe( fft_len, cnst.base(), occupied_carriers, pilot_carriers, pilot_symbols, 0, 0.01 ) channel = [ 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, # These coefficients will be rotated slightly... 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)) len_tag_key = "frame_len" 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(4) 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, channel[:fft_len]) src = blocks.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 = 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) for tag in sink.tags(): if pmt.symbol_to_string(tag.key) == len_tag_key: self.assertEqual(pmt.to_long(tag.value), 4) if pmt.symbol_to_string(tag.key) == "ofdm_sync_chan_taps": self.assertComplexTuplesAlmostEqual(list(pmt.c32vector_elements(tag.value)), channel[-fft_len:], places=1)
def test_001_t (self): """ pretty simple (the carrier allocation is not a practical OFDM configuration!) """ fft_len = 6 tx_symbols = (1, 2, 3) # ^ this gets mapped to the DC carrier because occupied_carriers[0][0] == 0 pilot_symbols = ((1j,),) occupied_carriers = ((0, 1, 2),) pilot_carriers = ((3,),) sync_word = (range(fft_len),) expected_result = tuple(sync_word[0] + [1j, 0, 0, 1, 2, 3]) # ^ DC carrier 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)) src = blocks.vector_source_c(tx_symbols, False, 1, (tag,)) alloc = digital.ofdm_carrier_allocator_cvc(fft_len, occupied_carriers, pilot_carriers, pilot_symbols, sync_word, tag_name) sink = blocks.vector_sink_c(fft_len) self.tb.connect(src, alloc, sink) self.tb.run () self.assertEqual(sink.data(), expected_result)
def make_tag(key, value, offset): """Create a gr.tag_t() from key, value, offset.""" tag = gr.tag_t() tag.offset = offset tag.key = pmt.string_to_symbol(key) tag.value = pmt.to_pmt(value) return tag
def test_002_with_offset (self): """ Standard test, carrier offset """ fft_len = 16 tx_symbols = list(range(1, 16)); tx_symbols = (0, 0, 1, 1j, 2, 3, 0, 0, 0, 0, 0, 0, 4, 5, 2j, 6, 0, 0, 7, 8, 3j, 9, 0, 0, 0, 0, 0, 0, 10, 4j, 11, 12, 0, 0, 13, 1j, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 2j, 0) carr_offset = 1 # Compare this with tx_symbols from the previous test expected_result = tuple(range(1, 16)) + (0, 0, 0) occupied_carriers = ((1, 3, 4, 11, 12, 14), (1, 2, 4, 11, 13, 14),) n_syms = len(tx_symbols) // fft_len offsettag = gr.tag_t() offsettag.offset = 0 offsettag.key = pmt.string_to_symbol("ofdm_sync_carr_offset") offsettag.value = pmt.from_long(carr_offset) src = blocks.vector_source_c(tx_symbols, False, fft_len, (offsettag,)) sink = blocks.tsb_vector_sink_c(tsb_key=self.tsb_key) serializer = digital.ofdm_serializer_vcc( fft_len, occupied_carriers, self.tsb_key, "", 0, "ofdm_sync_carr_offset", False ) self.tb.connect(src, blocks.stream_to_tagged_stream(gr.sizeof_gr_complex, fft_len, n_syms, self.tsb_key), serializer, sink) self.tb.run () self.assertEqual(sink.data()[0], expected_result) self.assertEqual(len(sink.tags()), 1)
def test_001_t2 (self): """ pretty simple (same as before, but odd fft len) """ fft_len = 5 tx_symbols = (1, 2, 3) # ^ this gets mapped to the DC carrier because occupied_carriers[0][0] == 0 occupied_carriers = ((0, 1, 2),) pilot_carriers = ((-2,),) pilot_symbols = ((1j,),) expected_result = (1j, 0, 1, 2, 3) # ^ DC carrier 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)) src = blocks.vector_source_c(tx_symbols, False, 1, (tag,)) alloc = digital.ofdm_carrier_allocator_cvc(fft_len, occupied_carriers, pilot_carriers, pilot_symbols, (), tag_name) sink = blocks.vector_sink_c(fft_len) self.tb.connect(src, alloc, sink) self.tb.run () self.assertEqual(sink.data(), expected_result)
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_002_t (self): """ same, but using negative carrier indices """ fft_len = 6 tx_symbols = (1, 2, 3) pilot_symbols = ((1j,),) occupied_carriers = ((-1, 1, 2),) pilot_carriers = ((3,),) expected_result = (1j, 0, 1, 0, 2, 3) 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)) src = blocks.vector_source_c(tx_symbols, False, 1, (tag,)) alloc = digital.ofdm_carrier_allocator_cvc(fft_len, occupied_carriers, pilot_carriers, pilot_symbols, (), tag_name) sink = blocks.vector_sink_c(fft_len) self.tb.connect(src, alloc, sink) self.tb.run () self.assertEqual(sink.data(), expected_result)
def test_003_connect(self): """ Connect carrier_allocator to ofdm_serializer, make sure output==input """ fft_len = 8 n_syms = 1 occupied_carriers = ((1, 2, 6, 7),) pilot_carriers = ((3,), (5,)) pilot_symbols = ((1j,), (-1j,)) # tx_data = tuple([numpy.random.randint(0, 10) for x in range(4 * n_syms)]) tx_data = (1, 2, 3, 4) 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_data)) src = blocks.vector_source_c(tx_data, False, 1, (tag,)) alloc = digital.ofdm_carrier_allocator_cvc( fft_len, occupied_carriers, pilot_carriers, pilot_symbols, (), # No sync word tag_name, True, # Output is shifted (default) ) serializer = digital.ofdm_serializer_vcc( alloc, "", 0, "", True # Len tag key # Symbols skipped # Carrier offset key # Input is shifted (default) ) sink = blocks.vector_sink_c() self.tb.connect(src, alloc, serializer, sink) self.tb.run() self.assertEqual(sink.data(), tx_data)
def test_003(self): offsets = (6, 3, 8) key = pmt.string_to_symbol('key') srcid = pmt.string_to_symbol('qa_tag_utils') tags = [] for k in offsets: t = gr.tag_t() t.offset = k t.key = key t.value = pmt.from_long(k) t.srcid = srcid tags.append(t) for k, t in zip(sorted(offsets), sorted(tags, key=gr.tag_t_offset_compare_key())): self.assertEqual(t.offset, k) self.assertTrue(pmt.equal(t.key, key)) self.assertTrue(pmt.equal(t.value, pmt.from_long(k))) self.assertTrue(pmt.equal(t.srcid, srcid)) tmin = min(tags, key=gr.tag_t_offset_compare_key()) self.assertEqual(tmin.offset, min(offsets)) self.assertTrue(pmt.equal(tmin.key, key)) self.assertTrue(pmt.equal(tmin.value, pmt.from_long(min(offsets)))) self.assertTrue(pmt.equal(tmin.srcid, srcid)) tmax = max(tags, key=gr.tag_t_offset_compare_key()) self.assertEqual(tmax.offset, max(offsets)) self.assertTrue(pmt.equal(tmax.key, key)) self.assertTrue(pmt.equal(tmax.value, pmt.from_long(max(offsets)))) self.assertTrue(pmt.equal(tmax.srcid, srcid))
def test_001_t (self): """ First header: Packet length 4, packet num 0 Second header: Packet 2, packet num 1 Third header: Invalid (parity bit does not check) (would be len 4, num 2) """ encoded_headers = ( # | Number of bytes | Packet number | Parity 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ) packet_len_tagname = "packet_len" random_tag = gr.tag_t() random_tag.offset = 5 random_tag.key = pmt.string_to_symbol("foo") random_tag.value = pmt.from_long(42) src = blocks.vector_source_b(encoded_headers, tags=(random_tag,)) parser = digital.packet_headerparser_b(32, packet_len_tagname) sink = blocks.message_debug() self.tb.connect(src, parser) self.tb.msg_connect(parser, "header_data", sink, "store") self.tb.start() time.sleep(1) self.tb.stop() self.tb.wait() self.assertEqual(sink.num_messages(), 3) msg1 = pmt.to_python(sink.get_message(0)) msg2 = pmt.to_python(sink.get_message(1)) msg3 = pmt.to_python(sink.get_message(2)) self.assertEqual(msg1, {'packet_len': 4, 'packet_num': 0, 'foo': 42}) self.assertEqual(msg2, {'packet_len': 2, 'packet_num': 1}) self.assertEqual(msg3, False)
def test_0010_tag_propagation (self): """ Make sure tags on the CRC aren't lost. """ # Data with precalculated CRC data = ( 0, 1, 2, 3, 4, 5, 6, 7, 8, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1 ) # 2, 67, 225, 188 testtag = gr.tag_t() testtag.offset = len(data)-1 testtag.key = pmt.string_to_symbol('tag1') testtag.value = pmt.from_long(0) src = blocks.vector_source_b(data, False, 1, (testtag,)) crc_check = digital.crc32_bb(True, self.tsb_key, False) sink = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key) self.tb.connect( src, blocks.stream_to_tagged_stream(gr.sizeof_char, 1, len(data), self.tsb_key), crc_check, sink ) self.tb.run() self.assertEqual([len(data)-33,], [tag.offset for tag in sink.tags() if pmt.symbol_to_string(tag.key) == 'tag1'])
def generate_tag(tag_key, srcid, value, offset): tag = gr.tag_t() tag.key = pmt.string_to_symbol(tag_key) tag.srcid = pmt.string_to_symbol(srcid) tag.value = pmt.from_long(value) tag.offset = offset return tag
def test_001b_shifted (self): """ Same as before, but shifted, because that's the normal mode in OFDM Rx """ fft_len = 16 tx_symbols = ( 0, 0, 0, 0, 0, 0, 1, 2, 0, 3, 4, 5, 0, 0, 0, 0, 0, 0, 0, 0, 6, 1j, 7, 8, 0, 9, 10, 1j, 11, 0, 0, 0, 0, 0, 0, 0, 0, 12, 13, 14, 0, 15, 16, 17, 0, 0, 0, 0, ) expected_result = tuple(range(18)) occupied_carriers = ((13, 14, 15, 1, 2, 3), (-4, -2, -1, 1, 2, 4),) n_syms = len(tx_symbols)/fft_len tag_name = "len" tag = gr.tag_t() tag.offset = 0 tag.key = pmt.string_to_symbol(tag_name) tag.value = pmt.from_long(n_syms) src = blocks.vector_source_c(tx_symbols, False, fft_len, (tag,)) serializer = digital.ofdm_serializer_vcc(fft_len, occupied_carriers, tag_name) sink = blocks.vector_sink_c() self.tb.connect(src, serializer, sink) self.tb.run () self.assertEqual(sink.data(), expected_result) self.assertEqual(len(sink.tags()), 1) result_tag = sink.tags()[0] self.assertEqual(pmt.symbol_to_string(result_tag.key), tag_name) self.assertEqual(pmt.to_long(result_tag.value), n_syms * len(occupied_carriers[0]))
def make_tag(key, value, offset, srcid=None): tag = gr.tag_t() tag.key = pmt.string_to_symbol(key) tag.value = pmt.to_pmt(value) tag.offset = offset if srcid is not None: tag.srcid = pmt.to_pmt(srcid) return tag
def test_003_crc_correct_lentag (self): tag_name = "length" pack_len = 8 packets = range(pack_len*2) tag1 = gr.tag_t() tag1.offset = 0 tag1.key = pmt.string_to_symbol(tag_name) tag1.value = pmt.from_long(pack_len) tag2 = gr.tag_t() tag2.offset = pack_len tag2.key = pmt.string_to_symbol(tag_name) tag2.value = pmt.from_long(pack_len) testtag1 = gr.tag_t() testtag1.offset = 1 testtag1.key = pmt.string_to_symbol("tag1") testtag1.value = pmt.from_long(0) testtag2 = gr.tag_t() testtag2.offset = pack_len testtag2.key = pmt.string_to_symbol("tag2") testtag2.value = pmt.from_long(0) testtag3 = gr.tag_t() testtag3.offset = len(packets)-1 testtag3.key = pmt.string_to_symbol("tag3") testtag3.value = pmt.from_long(0) src = blocks.vector_source_b(packets, False, 1, (testtag1, testtag2, testtag3)) crc = digital.crc32_bb(False, self.tsb_key) sink = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key) self.tb.connect( src, blocks.stream_to_tagged_stream(gr.sizeof_char, 1, pack_len, self.tsb_key), crc, sink ) self.tb.run() self.assertEqual(len(sink.data()), 2) self.assertEqual(len(sink.data()[0]), (pack_len+4)) self.assertEqual(len(sink.data()[1]), (pack_len+4)) correct_offsets = {'tag1': 1, 'tag2': 12, 'tag3': 19} tags_found = {'tag1': False, 'tag2': False, 'tag3': False} for tag in sink.tags(): key = pmt.symbol_to_string(tag.key) if key in correct_offsets.keys(): tags_found[key] = True self.assertEqual(correct_offsets[key], tag.offset) self.assertTrue(all(tags_found.values()))
def test_005_tag_propagation (self): """ Make sure tags on the CRC aren't lost. """ data = (0, 1, 2, 3, 4, 5, 6, 7, 8, 2, 67, 225, 188) tag_name = "len" tag = gr.tag_t() tag.offset = 0 tag.key = pmt.string_to_symbol(tag_name) tag.value = pmt.from_long(len(data)) testtag = gr.tag_t() testtag.offset = len(data)-1 testtag.key = pmt.string_to_symbol('tag1') testtag.value = pmt.from_long(0) src = blocks.vector_source_b(data, False, 1, (tag, testtag)) crc_check = digital.crc32_bb(True, tag_name) sink = blocks.vector_sink_b() self.tb.connect(src, crc_check, sink) self.tb.run() self.assertEqual([len(data)-5,], [tag.offset for tag in sink.tags() if pmt.symbol_to_string(tag.key) == 'tag1'])
def test_008_crc_correct_lentag(self): tag_name = "length" pack_len = 8 packets = list(range(pack_len * 2)) tag1 = gr.tag_t() tag1.offset = 0 tag1.key = pmt.string_to_symbol(tag_name) tag1.value = pmt.from_long(pack_len) tag2 = gr.tag_t() tag2.offset = pack_len tag2.key = pmt.string_to_symbol(tag_name) tag2.value = pmt.from_long(pack_len) testtag1 = gr.tag_t() testtag1.offset = 1 testtag1.key = pmt.string_to_symbol("tag1") testtag1.value = pmt.from_long(0) testtag2 = gr.tag_t() testtag2.offset = pack_len testtag2.key = pmt.string_to_symbol("tag2") testtag2.value = pmt.from_long(0) testtag3 = gr.tag_t() testtag3.offset = len(packets) - 1 testtag3.key = pmt.string_to_symbol("tag3") testtag3.value = pmt.from_long(0) src = blocks.vector_source_b(packets, False, 1, (testtag1, testtag2, testtag3)) crc = digital.crc32_bb(False, self.tsb_key, False) sink = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key) self.tb.connect( src, blocks.stream_to_tagged_stream(gr.sizeof_char, 1, pack_len, self.tsb_key), crc, sink) self.tb.run() self.assertEqual(len(sink.data()), 2) self.assertEqual(len(sink.data()[0]), (pack_len + 32)) self.assertEqual(len(sink.data()[1]), (pack_len + 32)) correct_offsets = {'tag1': 1, 'tag2': 8 + 32, 'tag3': 15 + 32} tags_found = {'tag1': False, 'tag2': False, 'tag3': False} for tag in sink.tags(): key = pmt.symbol_to_string(tag.key) if key in list(correct_offsets.keys()): tags_found[key] = True self.assertEqual(correct_offsets[key], tag.offset) self.assertTrue(all(tags_found.values()))
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 make_tags(): tag1 = gr.tag_t() tag1.key = pmt.intern("foo") tag1.value = pmt.from_long(6) tag1.offset = 0 tag2 = gr.tag_t() tag2.key = pmt.intern("boo") tag2.value = pmt.from_long(6) tag2.offset = 0 tag3 = gr.tag_t() tag3.key = pmt.intern("foo") tag3.value = pmt.from_long(6) tag3.offset = 1 tag4 = gr.tag_t() tag4.key = pmt.intern("packet_len") tag4.value = pmt.from_long(1) tag4.offset = 0 tags = [tag1,tag2,tag3, tag4] return tags
def test_001_t (self): tag = gr.tag_t() tag.key = pmt.string_to_symbol('key') tag.value = pmt.from_long(42) tag.offset = 0 src = blocks.vector_source_f(range(20), False, 1, (tag,)) gate = blocks.tag_gate(gr.sizeof_float, False) sink = blocks.vector_sink_f() self.tb.run () self.assertEqual(len(sink.tags()), 0)
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 make_lengthtags(lengths, offsets, tagname='length', vlen=1): tags = [] assert(len(offsets) == len(lengths)) for offset, length in zip(offsets, lengths): tag = gr.tag_t() tag.offset = offset // vlen tag.key = pmt.string_to_symbol(tagname) tag.value = pmt.from_long(length // vlen) tags.append(tag) return tags
def test_additive_scrambler_tags_oneway(self): src_data = [x for x in range(0, 10)] reset_tag_key = 'reset_lfsr' reset_tag1 = gr.tag_t() reset_tag1.key = pmt.string_to_symbol(reset_tag_key) reset_tag1.offset = 0 reset_tag2 = gr.tag_t() reset_tag2.key = pmt.string_to_symbol(reset_tag_key) reset_tag2.offset = 10 reset_tag3 = gr.tag_t() reset_tag3.key = pmt.string_to_symbol(reset_tag_key) reset_tag3.offset = 20 src = blocks.vector_source_b(src_data * 3, False, 1, (reset_tag1, reset_tag2, reset_tag3)) scrambler = digital.additive_scrambler_bb(0x8a, 0x7f, 7, 0, 8, reset_tag_key) dst = blocks.vector_sink_b() self.tb.connect(src, scrambler, dst) self.tb.run() expected_data = additive_scramble_lfsr(0x8a, 0x7f, 7, 8, src_data) self.assertEqual(expected_data * 3, dst.data())
def test_001_t(self): tag = gr.tag_t() tag.key = pmt.string_to_symbol('key') tag.value = pmt.from_long(42) tag.offset = 0 src = blocks.vector_source_f(range(20), False, 1, (tag, )) gate = blocks.tag_gate(gr.sizeof_float, False) sink = blocks.vector_sink_f() self.tb.run() self.assertEqual(len(sink.tags()), 0)
def test_additive_scrambler_tags_oneway(self): src_data = range(0, 10) reset_tag_key = 'reset_lfsr' reset_tag1 = gr.tag_t() reset_tag1.key = pmt.string_to_symbol(reset_tag_key) reset_tag1.offset = 0 reset_tag2 = gr.tag_t() reset_tag2.key = pmt.string_to_symbol(reset_tag_key) reset_tag2.offset = 10 reset_tag3 = gr.tag_t() reset_tag3.key = pmt.string_to_symbol(reset_tag_key) reset_tag3.offset = 20 src = blocks.vector_source_b(src_data * 3, False, 1, (reset_tag1, reset_tag2, reset_tag3)) scrambler = digital.additive_scrambler_bb(0x8a, 0x7f, 7, 0, 8, reset_tag_key) dst = blocks.vector_sink_b() self.tb.connect(src, scrambler, dst) self.tb.run() expected_data = additive_scramble_lfsr(0x8a, 0x7f, 7, 8, src_data) self.assertEqual(expected_data * 3, dst.data())
def test_002_tb(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 = list(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_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() detected_tags = { 'ofdm_sync_carr_offset': False, 'test_tag_1': False, 'test_tag_2': False } for tag in tags: if pmt.symbol_to_string(tag.key) == 'ofdm_sync_carr_offset': carr_offset_hat = pmt.to_long(tag.value) self.assertEqual(pmt.to_long(tag.value), carr_offset) if pmt.symbol_to_string(tag.key) == 'test_tag_1': self.assertEqual(tag.offset, 0) if pmt.symbol_to_string(tag.key) == 'test_tag_2': self.assertEqual(tag.offset, 0) detected_tags[pmt.symbol_to_string(tag.key)] = True self.assertTrue(all(detected_tags.values()))
def test_004_t (self): tags = [] tags.append(gr.tag_t()) tags[0].key = pmt.string_to_symbol('key') tags[0].value = pmt.from_long(42) tags[0].offset = 0 tags.append(gr.tag_t()) tags[1].key = pmt.string_to_symbol('key') tags[1].value = pmt.from_long(42) tags[1].offset = 5 tags.append(gr.tag_t()) tags[2].key = pmt.string_to_symbol('secondkey') tags[2].value = pmt.from_long(42) tags[2].offset = 6 src = blocks.vector_source_f(range(20), False, 1, tags) gate = blocks.tag_gate(gr.sizeof_float, True) sink = blocks.vector_sink_f() self.tb.connect(src, gate, sink) self.tb.run () self.assertEqual(len(sink.tags()), 3)
def make_len_tags(tupl, key): tags = [] tag = gr.tag_t() tag.key = pmt.string_to_symbol(key) n_read = 0 for element in tupl: tag.offset = n_read n_read += len(element) tag.value = pmt.to_pmt(len(element)) tags.append(tag) return tags
def test_003_crc_correct_lentag(self): tag_name = "length" pack_len = 8 packets = range(pack_len * 2) tag1 = gr.tag_t() tag1.offset = 0 tag1.key = pmt.string_to_symbol(tag_name) tag1.value = pmt.from_long(pack_len) tag2 = gr.tag_t() tag2.offset = pack_len tag2.key = pmt.string_to_symbol(tag_name) tag2.value = pmt.from_long(pack_len) testtag1 = gr.tag_t() testtag1.offset = 1 testtag1.key = pmt.string_to_symbol("tag1") testtag1.value = pmt.from_long(0) testtag2 = gr.tag_t() testtag2.offset = pack_len testtag2.key = pmt.string_to_symbol("tag2") testtag2.value = pmt.from_long(0) testtag3 = gr.tag_t() testtag3.offset = len(packets) - 1 testtag3.key = pmt.string_to_symbol("tag3") testtag3.value = pmt.from_long(0) src = blocks.vector_source_b( packets, False, 1, (tag1, tag2, testtag1, testtag2, testtag3)) crc = digital.crc32_bb(False, tag_name) sink = blocks.vector_sink_b() self.tb.connect(src, crc, sink) self.tb.run() self.assertEqual(len(sink.data()), 2 * (pack_len + 4)) correct_offsets = {'tag1': 1, 'tag2': 12, 'tag3': 19} tags_found = {'tag1': False, 'tag2': False, 'tag3': False} for tag in sink.tags(): key = pmt.symbol_to_string(tag.key) if key in correct_offsets.keys(): tags_found[key] = True self.assertEqual(correct_offsets[key], tag.offset) if key == tag_name: self.assertTrue(tag.offset == 0 or tag.offset == pack_len + 4) self.assertTrue(all(tags_found.values()))
def test_005_t(self): """ Tags """ X_in = ( (1, 2, 3, 4), (5, 6, 7, 8), ) A = ( (0, 1), # Flip them round (1, 0), ) tag1 = gr.tag_t() tag1.offset = 0 tag1.key = pmt.intern("in1") tag1.value = pmt.PMT_T tag2 = gr.tag_t() tag2.offset = 0 tag2.key = pmt.intern("in2") tag2.value = pmt.PMT_T self.run_once(X_in, A, tpp=gr.TPP_ONE_TO_ONE, tags=(tag1, tag2)) self.assertTrue(pmt.equal(tag1.key, self.the_tags[0][0].key)) self.assertTrue(pmt.equal(tag2.key, self.the_tags[1][0].key))
def make_tags(offset): tags = [] tag1 = gr.tag_t() tag1.key = pmt.intern("number_of_symbols") tag1.value = pmt.to_pmt(1) tag1.offset = offset tags.append(tag1) tag2 = gr.tag_t() tag2.key = pmt.intern("sequence_number") tag2.value = pmt.to_pmt(1) tag2.offset = offset tags.append(tag2) tag3 = gr.tag_t() tag3.key = pmt.intern("sender_id") tag3.value = pmt.to_pmt(1) tag3.offset = offset tags.append(tag3) tag4 = gr.tag_t() tag4.key = pmt.intern("receiver_id") tag4.value = pmt.to_pmt(0) tag4.offset = offset tags.append(tag4) tag5 = gr.tag_t() tag5.key = pmt.intern("padding") tag5.value = pmt.to_pmt(0) tag5.offset = offset tags.append(tag5) tag6 = gr.tag_t() tag6.key = pmt.intern("mode") tag6.value = pmt.to_pmt(0) tag6.offset = offset tags.append(tag6) return tuple(tags)
def make_tags(len_tag_key,len_frame_tag_key): debug_tag = gr.tag_t() debug_tag.key = pmt.intern(len_frame_tag_key) debug_tag.value = pmt.from_long(400) debug_tag.offset = 0 tags = [debug_tag] tag1 = gr.tag_t() tag1.key = pmt.intern(len_tag_key) tag1.value = pmt.from_long(6) tag1.offset = 0 tag2 = gr.tag_t() tag2.key = pmt.intern(len_tag_key) tag2.value = pmt.from_long(6) tag2.offset = 6 tag3 = gr.tag_t() tag3.key = pmt.intern(len_tag_key) tag3.value = pmt.from_long(6) tag3.offset = 12 tag4 = gr.tag_t() tag4.key = pmt.intern(len_tag_key) tag4.value = pmt.from_long(6) tag4.offset = 18 tag5 = gr.tag_t() tag5.key = pmt.intern("foo") tag5.value = pmt.from_long(6) tag5.offset = 0 return tuple([tag1,tag2,tag3,tag4, tag5])
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 packets_to_vectors(packets, lengthtagname, vlen=1): tags = [] data = [] offset = 0 for packet in packets: data.extend(packet) tag = gr.tag_t() tag.offset = offset // vlen tag.key = pmt.string_to_symbol(lengthtagname) tag.value = pmt.from_long(len(packet) // vlen) tags.append(tag) offset = offset + len(packet) return data, tags
def test_additive_scrambler_tags(self): src_data = (1,)*1000 src = blocks.vector_source_b(src_data, False) scrambler = digital.additive_scrambler_bb(0x8a, 0x7f, 7, 100) descrambler = digital.additive_scrambler_bb(0x8a, 0x7f, 7, 100) reset_tag_key = 'reset_lfsr' reset_tag1 = gr.tag_t() reset_tag1.key = pmt.string_to_symbol(reset_tag_key) reset_tag1.offset = 17 reset_tag2 = gr.tag_t() reset_tag2.key = pmt.string_to_symbol(reset_tag_key) reset_tag2.offset = 110 reset_tag3 = gr.tag_t() reset_tag3.key = pmt.string_to_symbol(reset_tag_key) reset_tag3.offset = 523 src = blocks.vector_source_b(src_data, False, 1, (reset_tag1, reset_tag2, reset_tag3)) scrambler = digital.additive_scrambler_bb(0x8a, 0x7f, 7, 100, 1, reset_tag_key) descrambler = digital.additive_scrambler_bb(0x8a, 0x7f, 7, 100, 1, reset_tag_key) dst = blocks.vector_sink_b() self.tb.connect(src, scrambler, descrambler, dst) self.tb.run() self.assertEqual(src_data, dst.data())
def test_tag(self): # Send data through bpsk receiver # followed by qpsk receiver data = [0.9 + 0j, 0.1 + 0.9j, -1 - 0.1j, -0.1 - 0.6j] * 2 bpsk_data = [1, 1, 0, 0] qpsk_data = [1, 3, 0, 0] first_tag = gr.tag_t() first_tag.key = pmt.intern("set_constellation") first_tag.value = digital.bpsk_constellation().as_pmt() first_tag.offset = 0 second_tag = gr.tag_t() second_tag.key = pmt.intern("set_constellation") second_tag.value = digital.qpsk_constellation().as_pmt() second_tag.offset = 4 src = blocks.vector_source_c(data, False, 1, [first_tag, second_tag]) decoder = digital.constellation_receiver_cb( digital.bpsk_constellation().base(), 0, 0, 0) snk = blocks.vector_sink_b() tb = gr.top_block() tb.connect(src, decoder, snk) tb.run() self.assertEqual(list(snk.data()), bpsk_data + qpsk_data)
def test_001c_carrier_offset_cp (self): """ Same as before, but put a carrier offset in there and a CP """ fft_len = 8 cp_len = 2 n_syms = 3 # cp_len/fft_len == 1/4, therefore, the phase is rotated by # carr_offset * \pi/2 in every symbol occupied_carriers = ((-2, -1, 1, 2),) carr_offset = -1 tx_data = ( 0,-1j,-1j, 0,-1j,-1j, 0, 0, 0, -1, -1, 0, -1, -1, 0, 0, 0, 1j, 1j, 0, 1j, 1j, 0, 0, ) # Rx'd signal is corrected rx_expected = (0, 0, 1, 1, 0, 1, 1, 0) * n_syms equalizer = digital.ofdm_equalizer_static(fft_len, occupied_carriers) 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, (0, 0, 1, 1, 0, 1, 1, 0)) offset_tag = gr.tag_t() offset_tag.offset = 0 offset_tag.key = pmt.string_to_symbol("ofdm_sync_carr_offset") offset_tag.value = pmt.from_long(carr_offset) src = blocks.vector_source_c(tx_data, False, fft_len, (chan_tag, offset_tag)) eq = digital.ofdm_frame_equalizer_vcvc(equalizer.base(), cp_len, self.tsb_key) sink = blocks.tsb_vector_sink_c(fft_len, tsb_key=self.tsb_key) self.tb.connect( src, blocks.stream_to_tagged_stream(gr.sizeof_gr_complex, fft_len, n_syms, self.tsb_key), eq, sink ) self.tb.run () # Check data self.assertComplexTuplesAlmostEqual(rx_expected, sink.data()[0], places=4)
def test_001_t(self): n_frames = 20 timeslots = 9 subcarriers = 128 active_subcarriers = 110 cp_len = subcarriers // 2 smap = get_subcarrier_map(subcarriers, active_subcarriers) seed = 4711 ftype = 'rrc' falpha = .5 tag_key = 'frame_start' preamble, x_preamble = mapped_preamble(seed, ftype, falpha, active_subcarriers, subcarriers, smap, 2, cp_len, cp_len // 2) block_len = timeslots * subcarriers offset = len(preamble) + cp_len frame_len = len(preamble) + timeslots * subcarriers + cp_len data = np.array([], dtype=np.complex) ref = np.array([], dtype=np.complex) tags = [] print 'frame_len: ', frame_len for i in range(n_frames): d_block = modulate_mapped_gfdm_block( get_random_qpsk(timeslots * active_subcarriers), timeslots, subcarriers, active_subcarriers, 2, falpha) frame = pinch_cp_add_block(d_block, timeslots, subcarriers, cp_len, cp_len // 2) frame = np.concatenate((preamble, frame)) r = frame[offset:offset + block_len] ref = np.concatenate((ref, r)) tag = gr.tag_t() tag.key = pmt.string_to_symbol(tag_key) tag.offset = len(data) tag.srcid = pmt.string_to_symbol('qa') tag.value = pmt.from_long(block_len) tags.append(tag) data = np.concatenate((data, frame)) src = blocks.vector_source_c(data, False, 1, tags) cp_rm = gfdm.remove_prefix_cc(frame_len, block_len, offset, tag_key) snk = blocks.vector_sink_c() self.tb.connect(src, cp_rm, snk) self.tb.run() # # check data res = np.array(snk.data()) tags = snk.tags() self.assertTrue(len(tags) == 0) # propagation policy is TPP_DONT self.assertComplexTuplesAlmostEqual(res, ref, 5)
def test_001_t(self): len_tag_key = "packet_len" receiver_key = 'recv_id' pay_len_key = "pay_len" debug_key = "test" tag_debug = gr.tag_t() tag_debug.key = pmt.intern(debug_key) tag_debug.value = pmt.from_long(400) tag_debug.offset = 2 tag1 = gr.tag_t() tag1.key = pmt.intern(len_tag_key) tag1.value = pmt.from_long(2) tag1.offset = 0 tag2 = gr.tag_t() tag2.key = pmt.intern(len_tag_key) tag2.value = pmt.from_long(2) tag2.offset = 2 tag1r = gr.tag_t() tag1r.key = pmt.intern(receiver_key) tag1r.value = pmt.from_long(3) tag1r.offset = 0 tag2r = gr.tag_t() tag2r.key = pmt.intern(receiver_key) tag2r.value = pmt.from_long(3) tag2r.offset = 2 tag1l = gr.tag_t() tag1l.key = pmt.intern(pay_len_key) tag1l.value = pmt.from_long(2) tag1l.offset = 0 tag2l = gr.tag_t() tag2l.key = pmt.intern(pay_len_key) tag2l.value = pmt.from_long(2) tag2l.offset = 2 packet1 = [10, 10] packet2 = [10, 20] src_data = packet1 + packet2 src_tags = tuple([tag_debug, tag1, tag2, tag1l, tag1r, tag2l, tag2r]) #blocks source = blocks.vector_source_b(src_data, repeat=False, tags=src_tags) dest = blocks.tsb_vector_sink_b(tsb_key="packet_len") gen = ownHeader.generate_short_bb(len_tag_key, pay_len_key, receiver_key) #connections self.tb.connect(source, gen, dest) self.tb.run() #retrieve fdata dest_data = dest.data() dest_tags = dest.tags() # check data self.assertEqual(len(dest_data), 2) self.assertEqual(dest_data[0], (35, )) self.assertEqual(dest_data[1], (35, )) self.assertEqual(len(dest_tags), 0)
def test_002_with_offset(self): """ Standard test, carrier offset """ fft_len = 16 tx_symbols = range(1, 16) tx_symbols = (0, 0, 1, 1j, 2, 3, 0, 0, 0, 0, 0, 0, 4, 5, 2j, 6, 0, 0, 7, 8, 3j, 9, 0, 0, 0, 0, 0, 0, 10, 4j, 11, 12, 0, 0, 13, 1j, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 2j, 0) carr_offset = 1 # Compare this with tx_symbols from the previous test expected_result = tuple(range(1, 16)) + (0, 0, 0) occupied_carriers = ( (1, 3, 4, 11, 12, 14), (1, 2, 4, 11, 13, 14), ) n_syms = len(tx_symbols) / fft_len tag_name = "len" tag = gr.tag_t() tag.offset = 0 tag.key = pmt.string_to_symbol(tag_name) tag.value = pmt.from_long(n_syms) offsettag = gr.tag_t() offsettag.offset = 0 offsettag.key = pmt.string_to_symbol("ofdm_sync_carr_offset") offsettag.value = pmt.from_long(carr_offset) src = blocks.vector_source_c(tx_symbols, False, fft_len, (tag, offsettag)) sink = blocks.vector_sink_c() serializer = digital.ofdm_serializer_vcc(fft_len, occupied_carriers, tag_name, "", 0, "ofdm_sync_carr_offset", False) self.tb.connect(src, serializer, sink) self.tb.run() self.assertEqual(sink.data(), expected_result) self.assertEqual(len(sink.tags()), 2) for tag in sink.tags(): if pmt.symbol_to_string(tag.key) == tag_name: self.assertEqual(pmt.to_long(tag.value), n_syms * len(occupied_carriers[0]))
def test_005_tag_propagation(self): """ Make sure tags on the CRC aren't lost. """ data = (0, 1, 2, 3, 4, 5, 6, 7, 8, 230, 166, 39, 8) tag_name = "len" tag = gr.tag_t() tag.offset = 0 tag.key = pmt.string_to_symbol(tag_name) tag.value = pmt.from_long(len(data)) testtag = gr.tag_t() testtag.offset = len(data) - 1 testtag.key = pmt.string_to_symbol('tag1') testtag.value = pmt.from_long(0) src = blocks.vector_source_b(data, False, 1, (tag, testtag)) crc_check = digital.crc32_bb(True, tag_name) sink = blocks.vector_sink_b() self.tb.connect(src, crc_check, sink) self.tb.run() self.assertEqual([ len(data) - 5, ], [ tag.offset for tag in sink.tags() if pmt.symbol_to_string(tag.key) == 'tag1' ])
def dict_to_tag(d): ''' Convert dictionary to gnuadio stream tag ''' tag = gr.tag_t() tag.offset = d["offset"] tag.key = pmt.to_pmt(d["key"]) tag.value = pmt.to_pmt(d["value"]) if "srcid" in d: tag.srcid = pmt.to_pmt(d["srcid"]) return tag
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_002_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 = blocks.tagged_stream_to_pdu(blocks.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_001_crc_len (self): """ Make sure the output of a CRC set is 4 bytes longer than the input. """ data = range(16) tag_name = "len" tag = gr.tag_t() tag.offset = 0 tag.key = pmt.string_to_symbol(tag_name) tag.value = pmt.from_long(len(data)) src = blocks.vector_source_b(data, False, 1, (tag,)) crc = digital.crc32_bb(False, tag_name) sink = blocks.vector_sink_b() self.tb.connect(src, crc, sink) self.tb.run() # Check that the packets before crc_check are 4 bytes longer that the input. self.assertEqual(len(data)+4, len(sink.data()))
def test_001_12bits(self): # 3 PDUs: | | | data = (1, 2, 3, 4, 1, 2) + tuple(range(25)) tagname = "packet_len" tag1 = gr.tag_t() tag1.offset = 0 tag1.key = pmt.string_to_symbol(tagname) tag1.value = pmt.from_long(4) tag2 = gr.tag_t() tag2.offset = 4 tag2.key = pmt.string_to_symbol(tagname) tag2.value = pmt.from_long(2) tag3 = gr.tag_t() tag3.offset = 6 tag3.key = pmt.string_to_symbol(tagname) tag3.value = pmt.from_long(25) src = blocks.vector_source_b(data, False, 1, (tag1, tag2, tag3)) header = digital.packet_headergenerator_bb(12, tagname) sink = blocks.vector_sink_b() self.tb.connect(src, header, sink) self.tb.run() expected_data = (0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0) self.assertEqual(sink.data(), expected_data)
def next_vector(self, seed, samp_rate, noise_amp, modulation, delay, samples_to_receive, freq, rx_id): timing_tag = gr.tag_t() timing_tag.offset = 0 timing_tag.key = pmt.string_to_symbol('rx_time') timing_tag.value = pmt.to_pmt((float(seed), 0.6)) timing_tag.srcid = pmt.string_to_symbol(str('gr uhd usrp source1')) # Rx freq tags: #print "In source emulation (before tag)" #print freq rx_freq_tag = gr.tag_t() rx_freq_tag.offset = 0 rx_freq_tag.key = pmt.string_to_symbol('rx_freq') rx_freq_tag.value = pmt.from_double(freq) rx_freq_tag.srcid = pmt.string_to_symbol(str('gr uhd usrp source1')) # Samp_rate tags: rx_rate_tag = gr.tag_t() rx_rate_tag.offset = 0 rx_rate_tag.key = pmt.string_to_symbol('rx_rate') rx_rate_tag.value = pmt.from_double(samp_rate) rx_rate_tag.srcid = pmt.string_to_symbol(str('gr uhd usrp source1')) pulse_width = 4 np.random.seed(seed=seed) tx_vector = np.reshape( np.matlib.repmat( np.random.randint(0, 2, (5 * samples_to_receive) / pulse_width) * 2 - 1, pulse_width, 1).T, [1, 5 * samples_to_receive])[0].tolist() # delay signal vector -> insert zeros at beginnig; nothing happens if signal has not reached the receiver: tx_vector_delayed = np.hstack((np.zeros(delay), tx_vector)) #tx_vector_delayed = tx_vector_delayed[:600] print len(tx_vector_delayed) self.vector_source.set_data(tx_vector_delayed, (timing_tag, rx_freq_tag, rx_rate_tag)) self.head.reset() self.vector_source.rewind()