def test_003_block_pinching(self): n_reps = 1 n_subcarriers = 8 n_timeslots = 8 block_len = n_subcarriers * n_timeslots cp_len = 8 ramp_len = 4 cs_len = ramp_len * 2 window_len = get_window_len(cp_len, n_timeslots, n_subcarriers, cs_len) window_taps = get_raised_cosine_ramp(ramp_len, window_len) data = np.arange(block_len, dtype=np.complex) + 1 ref = add_cyclic_starfix(data, cp_len, cs_len) ref = pinch_block(ref, window_taps) data = np.tile(data, n_reps) ref = np.tile(ref, n_reps) print "input is: ", len(data), " -> " , len(ref) # short_window = np.concatenate((window_taps[0:ramp_len], window_taps[-ramp_len:])) prefixer = gfdm.cyclic_prefixer_cc(block_len, cp_len, cs_len, ramp_len, window_taps) src = blocks.vector_source_c(data) dst = blocks.vector_sink_c() self.tb.connect(src, prefixer, dst) self.tb.run() res = np.array(dst.data()) print ref[-10:] print res[-10:] self.assertComplexTuplesAlmostEqual(res, ref, 4)
def create_frame(config, tag_key): symbols = get_random_qpsk(config.timeslots * config.active_subcarriers) d_block = modulate_mapped_gfdm_block( symbols, config.timeslots, config.subcarriers, config.active_subcarriers, 2, 0.2, dc_free=True, ) preamble = config.full_preambles[0] frame = add_cyclic_starfix(d_block, config.cp_len, config.cs_len) frame = np.concatenate((preamble, frame)) tag = gr.tag_t() tag.key = pmt.string_to_symbol(tag_key) d = pmt.make_dict() d = pmt.dict_add(d, pmt.mp("xcorr_idx"), pmt.from_uint64(42)) d = pmt.dict_add(d, pmt.mp("xcorr_offset"), pmt.from_uint64(4711)) d = pmt.dict_add(d, pmt.mp("sc_rot"), pmt.from_complex(1.0 + 0.0j)) # tag.offset = data.size + cp_len tag.srcid = pmt.string_to_symbol("qa") tag.value = d return frame, symbols, tag
def test_001_t(self): np.set_printoptions(precision=2) n_frames = 7 alpha = .5 active_subcarriers = 52 timeslots = 9 subcarriers = 64 overlap = 2 cp_len = 8 cs_len = 4 ramp_len = 4 window_len = get_window_len(cp_len, timeslots, subcarriers, cs_len) taps = get_frequency_domain_filter('rrc', alpha, timeslots, subcarriers, overlap) # taps /= np.sqrt(calculate_signal_energy(taps) / time) window_taps = get_raised_cosine_ramp(ramp_len, window_len) pn_symbols = get_random_qpsk(subcarriers) H_preamble = get_frequency_domain_filter('rrc', alpha, 2, subcarriers, overlap) preamble = get_sync_symbol(pn_symbols, H_preamble, subcarriers, overlap, cp_len, ramp_len)[0] smap = get_subcarrier_map(subcarriers, active_subcarriers, True) ref = np.array([], dtype=np.complex) data = np.array([], dtype=np.complex) for i in range(n_frames): d = get_random_qpsk(active_subcarriers * timeslots) dd = map_to_waveform_resources(d, active_subcarriers, subcarriers, smap) D = get_data_matrix(dd, subcarriers, group_by_subcarrier=False) b = gfdm_modulate_block(D, taps, timeslots, subcarriers, overlap, False) b = add_cyclic_starfix(b, cp_len, cs_len) b = pinch_block(b, window_taps) ref = np.concatenate((ref, preamble, b)) data = np.concatenate((data, d)) src = blocks.vector_source_c(data) dut = gfdm.transmitter_cc(timeslots, subcarriers, active_subcarriers, cp_len, cs_len, ramp_len, smap, True, overlap, taps, window_taps, preamble, "packet_len") dst = blocks.vector_sink_c() self.tb.connect(src, dut, dst) self.tb.run() res = np.array(dst.data())[0:len(ref)] self.assertComplexTuplesAlmostEqual(ref, res, 5) tags = dst.tags() for t in tags: print(t.offset, t.value)
def test_001_t(self): np.set_printoptions(precision=2) n_frames = 3 alpha = .5 active = 8 M = 8 K = 16 L = 2 cp_len = 8 cs_len = 4 ramp_len = 4 block_len = M * K window_len = get_window_len(cp_len, M, K, cs_len) taps = get_frequency_domain_filter('rrc', alpha, M, K, L) taps /= np.sqrt(calculate_signal_energy(taps) / M) window_taps = get_raised_cosine_ramp(ramp_len, window_len) pn_symbols = get_random_qpsk(K) H_preamble = get_frequency_domain_filter('rrc', alpha, 2, K, L) preamble = get_sync_symbol(pn_symbols, H_preamble, K, L, cp_len, ramp_len)[0] smap = get_subcarrier_map(K, active, dc_free=True) ref = np.array([], dtype=complex) data = np.array([], dtype=complex) frame_len = window_len + len(preamble) frame_gap = np.zeros(frame_len) for i in range(n_frames): d = get_random_qpsk(active * M) dd = map_to_waveform_resources(d, active, K, smap) D = get_data_matrix(dd, K, group_by_subcarrier=False) b = gfdm_modulate_block(D, taps, M, K, L, False) b = add_cyclic_starfix(b, cp_len, cs_len) b = pinch_block(b, window_taps) ref = np.concatenate((ref, frame_gap, preamble, b)) data = np.concatenate((data, d)) src = blocks.vector_source_c(data) mapper = gfdm.resource_mapper_cc(active, K, M, smap, True) mod = gfdm.simple_modulator_cc(M, K, L, taps) prefixer = gfdm.cyclic_prefixer_cc(block_len, cp_len, cs_len, ramp_len, window_taps) preambler = blocks.vector_insert_c(preamble, window_len + len(preamble), 0) gapper = blocks.vector_insert_c(frame_gap, frame_len + len(frame_gap), 0) dst = blocks.vector_sink_c() self.tb.connect(src, mapper, mod, prefixer, preambler, gapper, dst) # self.tb.connect(src, mapper, dst) self.tb.run() res = np.array(dst.data())[0:len(ref)] self.assertComplexTuplesAlmostEqual(ref, res, 5)
def generate_reference_frame(symbols, timeslots, subcarriers, active_subcarriers, subcarrier_map, taps, overlap, cp_len, cs_len, window_taps, cyclic_shifts, preambles): dd = map_to_waveform_resources(symbols, active_subcarriers, subcarriers, subcarrier_map) D = get_data_matrix(dd, subcarriers, group_by_subcarrier=False) b = gfdm_modulate_block(D, taps, timeslots, subcarriers, overlap, False) frame = [] for cs, p in zip(cyclic_shifts, preambles): data = np.roll(b, cs) data = add_cyclic_starfix(data, cp_len, cs_len) data = pinch_block(data, window_taps) frame.append(np.concatenate((p, data))) return frame
def test_001_t(self): np.set_printoptions(precision=2) n_frames = 3 alpha = .5 active = 8 M = 8 K = 16 L = 2 cp_len = 8 cs_len = 4 ramp_len = 4 block_len = M * K window_len = get_window_len(cp_len, M, K, cs_len) taps = get_frequency_domain_filter('rrc', alpha, M, K, L) taps /= np.sqrt(calculate_signal_energy(taps) / M) window_taps = get_raised_cosine_ramp(ramp_len, window_len) pn_symbols = get_random_qpsk(K) H_preamble = get_frequency_domain_filter('rrc', alpha, 2, K, L) preamble = get_sync_symbol(pn_symbols, H_preamble, K, L, cp_len, ramp_len)[0] smap = get_subcarrier_map(K, active, dc_free=True) ref = np.array([], dtype=np.complex) data = np.array([], dtype=np.complex) frame_len = window_len + len(preamble) frame_gap = np.zeros(frame_len) for i in range(n_frames): d = get_random_qpsk(active * M) dd = map_to_waveform_resources(d, active, K, smap) D = get_data_matrix(dd, K, group_by_subcarrier=False) b = gfdm_modulate_block(D, taps, M, K, L, False) b = add_cyclic_starfix(b, cp_len, cs_len) b = pinch_block(b, window_taps) ref = np.concatenate((ref, frame_gap, preamble, b)) data = np.concatenate((data, d)) src = blocks.vector_source_c(data) mapper = gfdm.resource_mapper_cc(active, K, M, smap, True) mod = gfdm.simple_modulator_cc(M, K, L, taps) prefixer = gfdm.cyclic_prefixer_cc(block_len, cp_len, cs_len, ramp_len, window_taps) preambler = blocks.vector_insert_c(preamble, window_len + len(preamble), 0) gapper = blocks.vector_insert_c(frame_gap, frame_len + len(frame_gap), 0) dst = blocks.vector_sink_c() self.tb.connect(src, mapper, mod, prefixer, preambler, gapper, dst) # self.tb.connect(src, mapper, dst) self.tb.run() res = np.array(dst.data())[0:len(ref)] self.assertComplexTuplesAlmostEqual(ref, res, 5)
def test_001_prefix(self): timeslots = 19 subcarriers = 32 block_len = timeslots * subcarriers cp_len = 16 ramp_len = 4 cs_len = ramp_len * 2 window_len = get_window_len(cp_len, timeslots, subcarriers, cs_len) window_taps = get_raised_cosine_ramp(ramp_len, window_len) data = np.arange(block_len, dtype=complex) + 1 ref = add_cyclic_starfix(data, cp_len, cs_len) ref = pinch_block(ref, window_taps) ref = ref.astype(np.complex64) prefixer = Cyclic_prefixer(block_len, cp_len, cs_len, ramp_len, window_taps) res = prefixer.add_cyclic_prefix(data) self.assertComplexTuplesAlmostEqual(res, ref, 6)
def test_002_prefix_shifted(self): timeslots = 3 subcarriers = 32 cyclic_shift = 4 block_len = timeslots * subcarriers cp_len = 16 cs_len = cp_len // 2 ramp_len = 4 window_len = get_window_len(cp_len, timeslots, subcarriers, cs_len) window_taps = get_raised_cosine_ramp(ramp_len, window_len) data = np.arange(block_len, dtype=complex) + 1 ref = add_cyclic_starfix(data, cp_len, cs_len) ref = np.concatenate((data[-(cp_len + cyclic_shift):], data, data[0:cs_len - cyclic_shift])) ref = pinch_block(ref, window_taps) ref = ref.astype(np.complex64) prefixer = Cyclic_prefixer(block_len, cp_len, cs_len, ramp_len, window_taps, cyclic_shift) res = prefixer.add_cyclic_prefix(data) self.assertEqual(res.size, cp_len + block_len + cs_len) self.assertComplexTuplesAlmostEqual(res, ref, 5)