def __init__(self, options):
gr.hier_block2.__init__(
self, "fbmc_transmit_path", gr.io_signature(0, 0, 0), gr.io_signature(1, 1, gr.sizeof_gr_complex)
)
common_options.defaults(options)
config = self.config = station_configuration()
config.data_subcarriers = options.subcarriers
config.cp_length = 0
config.frame_data_blocks = options.data_blocks
config._verbose = options.verbose
config.fft_length = options.fft_length
config.dc_null = options.dc_null
config.training_data = default_block_header(config.data_subcarriers, config.fft_length, config.dc_null, options)
config.coding = options.coding
config.fbmc = options.fbmc
config.adaptive_fbmc = options.adaptive_fbmc
config.frame_id_blocks = 1 # FIXME
# digital rms amplitude sent to USRP
rms_amp = options.rms_amplitude
self._options = copy.copy(options)
config.block_length = config.fft_length + config.cp_length
config.frame_data_part = config.frame_data_blocks + config.frame_id_blocks
config.frame_length = config.training_data.fbmc_no_preambles + 2 * config.frame_data_part
config.subcarriers = config.data_subcarriers + config.training_data.pilot_subcarriers
config.virtual_subcarriers = config.fft_length - config.subcarriers - config.dc_null
# default values if parameters not set
if rms_amp is None:
rms_amp = math.sqrt(config.subcarriers)
config.rms_amplitude = rms_amp
# check some bounds
if config.fft_length < config.subcarriers:
raise SystemError, "Subcarrier number must be less than FFT length"
if config.fft_length < config.cp_length:
raise SystemError, "Cyclic prefix length must be less than FFT length"
## shortcuts
blen = config.block_length
flen = config.frame_length
dsubc = config.data_subcarriers
vsubc = config.virtual_subcarriers
# Adaptive Transmitter Concept
used_id_bits = config.used_id_bits = 8 # TODO: no constant in source code
rep_id_bits = config.rep_id_bits = config.data_subcarriers / used_id_bits # BPSK
if config.data_subcarriers % used_id_bits <> 0:
raise SystemError, "Data subcarriers need to be multiple of %d" % (used_id_bits)
## Allocation Control
self.allocation_src = allocation_src(
config.data_subcarriers,
config.frame_data_blocks,
config.coding,
"tcp://*:3333",
"tcp://" + options.rx_hostname + ":3322",
)
if options.static_allocation: # DEBUG
# how many bits per subcarrier
if options.coding:
mode = 1 # Coding mode 1-9
bitspermode = [0.5, 1, 1.5, 2, 3, 4, 4.5, 5, 6] # Information bits per mode
modulbitspermode = [1, 2, 2, 4, 4, 6, 6, 6, 8] # Coding bits per mode
bitcount_vec = [(int)(config.data_subcarriers * config.frame_data_blocks * bitspermode[mode - 1])]
modul_bitcount_vec = [config.data_subcarriers * config.frame_data_blocks * modulbitspermode[mode - 1]]
bitcount_src = blocks.vector_source_i(bitcount_vec, True, 1)
modul_bitcount_src = blocks.vector_source_i(modul_bitcount_vec, True, 1)
bitloading = mode
else:
bitloading = 1
bitcount_vec = [config.data_subcarriers * config.frame_data_blocks * bitloading]
bitcount_src = blocks.vector_source_i(bitcount_vec, True, 1)
modul_bitcount_src = bitcount_src
# id's for frames
id_vec = range(0, 256)
id_src = blocks.vector_source_s(id_vec, True, 1)
# bitloading for ID symbol and then once for data symbols
# bitloading_vec = [1]*dsubc+[0]*(dsubc/2)+[2]*(dsubc/2)
test_allocation = (
[bitloading] * (int)(config.data_subcarriers / 8)
+ [0] * (int)(config.data_subcarriers / 4 * 3)
+ [bitloading] * (int)(config.data_subcarriers / 8)
)
# bitloading_vec = [1]*dsubc+[bitloading]*dsubc
bitloading_vec = [1] * dsubc + test_allocation
bitloading_src = blocks.vector_source_b(bitloading_vec, True, dsubc)
# bitcount for frames
# bitcount_vec = [config.data_subcarriers*config.frame_data_blocks*bitloading]
bitcount_vec = [config.frame_data_blocks * sum(test_allocation)]
bitcount_src = blocks.vector_source_i(bitcount_vec, True, 1)
# power loading, here same for all symbols
power_vec = (
[1] * (int)(config.data_subcarriers / 8)
+ [0] * (int)(config.data_subcarriers / 4 * 3)
+ [1] * (int)(config.data_subcarriers / 8)
)
power_src = blocks.vector_source_f(power_vec, True, dsubc)
# mux control stream to mux id and data bits
mux_vec = [0] * dsubc + [1] * bitcount_vec[0]
mux_ctrl = blocks.vector_source_b(mux_vec, True, 1)
else:
id_src = (self.allocation_src, 0)
bitcount_src = (self.allocation_src, 4)
bitloading_src = (self.allocation_src, 2)
power_src = (self.allocation_src, 1)
if options.coding:
modul_bitcount_src = (self.allocation_src, 5)
else:
modul_bitcount_src = bitcount_src
mux_ctrl = ofdm.tx_mux_ctrl(dsubc)
self.connect(modul_bitcount_src, mux_ctrl)
# Initial allocation
self.allocation_src.set_allocation([4] * config.data_subcarriers, [1] * config.data_subcarriers)
if options.benchmarking:
self.allocation_src.set_allocation([4] * config.data_subcarriers, [1] * config.data_subcarriers)
if options.lab_special_case:
self.allocation_src.set_allocation(
[0] * (config.data_subcarriers / 4)
+ [2] * (config.data_subcarriers / 2)
+ [0] * (config.data_subcarriers / 4),
[1] * config.data_subcarriers,
)
if options.log:
log_to_file(self, id_src, "data/id_src.short")
log_to_file(self, bitcount_src, "data/bitcount_src.int")
log_to_file(self, bitloading_src, "data/bitloading_src.char")
log_to_file(self, power_src, "data/power_src.cmplx")
## GUI probe output
zmq_probe_bitloading = zeromq.pub_sink(gr.sizeof_char, dsubc, "tcp://*:4445")
# also skip ID symbol bitloading with keep_one_in_n (side effect)
# factor 2 for bitloading because we have two vectors per frame, one for id symbol and one for all payload/data symbols
# factor config.frame_data_part for power because there is one vector per ofdm symbol per frame
self.connect(bitloading_src, blocks.keep_one_in_n(gr.sizeof_char * dsubc, 2 * 40), zmq_probe_bitloading)
zmq_probe_power = zeromq.pub_sink(gr.sizeof_float, dsubc, "tcp://*:4444")
# self.connect(power_src, blocks.keep_one_in_n(gr.sizeof_gr_complex*dsubc,40), blocks.complex_to_real(dsubc), zmq_probe_power)
self.connect(power_src, blocks.keep_one_in_n(gr.sizeof_float * dsubc, 40), zmq_probe_power)
## Workaround to avoid periodic structure
seed(1)
whitener_pn = [randint(0, 1) for i in range(used_id_bits * rep_id_bits)]
## ID Encoder
id_enc = self._id_encoder = repetition_encoder_sb(used_id_bits, rep_id_bits, whitener_pn)
self.connect(id_src, id_enc)
if options.log:
id_enc_f = gr.char_to_float()
self.connect(id_enc, id_enc_f)
log_to_file(self, id_enc_f, "data/id_enc_out.float")
## Reference Data Source
ber_ref_src = ber_reference_source(self._options)
self.connect(id_src, (ber_ref_src, 0))
self.connect(bitcount_src, (ber_ref_src, 1))
if options.log:
log_to_file(self, ber_ref_src, "data/ber_rec_src_tx.char")
if options.log:
log_to_file(self, btrig, "data/bitmap_trig.char")
## Frame Trigger
ftrig_stream = [1] + [0] * (config.frame_data_part - 1)
ftrig = self._frame_trigger = blocks.vector_source_b(ftrig_stream, True)
## Data Multiplexer
# Input 0: control stream
# Input 1: encoded ID stream
# Inputs 2..n: data streams
dmux = self._data_multiplexer = stream_controlled_mux_b()
self.connect(mux_ctrl, (dmux, 0))
self.connect(id_enc, (dmux, 1))
if options.coding:
fo = trellis.fsm(1, 2, [91, 121])
encoder = self._encoder = trellis.encoder_bb(fo, 0)
unpack = self._unpack = blocks.unpack_k_bits_bb(2)
self.connect(ber_ref_src, encoder, unpack)
if options.interleave:
int_object = trellis.interleaver(2000, 666)
interlv = trellis.permutation(int_object.K(), int_object.INTER(), 1, gr.sizeof_char)
if not options.nopunct:
bmaptrig_stream_puncturing = [1] + [0] * (config.frame_data_blocks / 2 - 1)
btrig_puncturing = self._bitmap_trigger_puncturing = blocks.vector_source_b(
bmaptrig_stream_puncturing, True
)
puncturing = self._puncturing = puncture_bb(config.data_subcarriers)
self.connect(bitloading_src, (puncturing, 1))
self.connect(self._bitmap_trigger_puncturing, (puncturing, 2))
self.connect(unpack, puncturing)
last_block = puncturing
if options.interleave:
self.connect(last_block, interlv)
last_block = interlv
if options.benchmarking:
self.connect(last_block, blocks.head(gr.sizeof_char, options.N), (dmux, 2))
else:
self.connect(last_block, (dmux, 2))
else:
if options.benchmarking:
self.connect(unpack, blocks.head(gr.sizeof_char, options.N), (dmux, 2))
else:
self.connect(unpack, (dmux, 2))
else:
if options.benchmarking:
self.connect(ber_ref_src, blocks.head(gr.sizeof_char, options.N), (dmux, 2))
else:
self.connect(ber_ref_src, (dmux, 2))
if options.log:
dmux_f = gr.char_to_float()
self.connect(dmux, dmux_f)
log_to_file(self, dmux_f, "data/dmux_out.float")
## Modulator
mod = self._modulator = generic_mapper_bcv(config.data_subcarriers, config.coding, config.frame_data_part)
self.connect(dmux, (mod, 0))
self.connect(bitloading_src, (mod, 1))
if options.log:
log_to_file(self, mod, "data/mod_out.compl")
modi = blocks.complex_to_imag(config.data_subcarriers)
modr = blocks.complex_to_real(config.data_subcarriers)
self.connect(mod, modi)
self.connect(mod, modr)
log_to_file(self, modi, "data/mod_imag_out.float")
log_to_file(self, modr, "data/mod_real_out.float")
## Power allocator
pa = self._power_allocator = multiply_frame_fc(config.frame_data_part, config.data_subcarriers)
self.connect(mod, (pa, 0))
self.connect(power_src, (pa, 1))
if options.log:
log_to_file(self, pa, "data/pa_out.compl")
if options.fbmc:
psubc = pa
else:
psubc = self._pilot_subcarrier_inserter = pilot_subcarrier_inserter()
self.connect(pa, psubc)
if options.log:
log_to_file(self, psubc, "data/psubc_out.compl")
subcarriers = config.subcarriers
# fbmc_pblocks_timing = self._fbmc_timing_pilot_block_inserter = fbmc_timing_pilot_block_inserter(5,False)
oqam_prep = self._oqam_prep = fbmc_oqam_preprocessing_vcvc(config.subcarriers, 0, 0)
self.connect(psubc, oqam_prep)
fbmc_pblocks = self._fbmc_pilot_block_inserter = fbmc_pilot_block_inserter(5, False)
self.connect(oqam_prep, fbmc_pblocks)
# log_to_file(self, fbmc_pblocks, "data/fbmc_pblocks_out.compl")
# fbmc_insert_pream = self._fbmc_insert_pream = fbmc_insert_preamble_vcvc(M, syms_per_frame, preamble)
# log_to_file(self, oqam_prep, "data/oqam_prep.compl")
# log_to_file(self, psubc, "data/psubc_out.compl")
# fbmc_pblocks = fbmc_pblocks_timing
# log_to_file(self, fbmc_pblocks, "data/fbmc_pblocks_out.compl")
beta_mult = self._beta_mult = fbmc_beta_multiplier_vcvc(config.subcarriers, 4, 4 * config.fft_length - 1, 0)
self.connect(fbmc_pblocks, beta_mult)
log_to_file(self, beta_mult, "data/beta_mult.compl")
## Add virtual subcarriers
if config.fft_length > subcarriers:
vsubc = self._virtual_subcarrier_extender = vector_padding_dc_null(
config.subcarriers, config.fft_length, config.dc_null
)
self.connect(beta_mult, vsubc)
else:
vsubc = self._virtual_subcarrier_extender = beta_mult
if options.log:
log_to_file(self, vsubc, "data/vsubc_out.compl")
## IFFT, no window, block shift
ifft = self._ifft = fft_blocks.fft_vcc(config.fft_length, False, [], True)
self.connect(vsubc, ifft)
if options.log:
log_to_file(self, ifft, "data/ifft_out.compl")
# FBMC separate stream + filterbanks
separate_oqam = self._separate_oqam = fbmc_separate_vcvc(config.fft_length, 2)
poly_netw_1 = self._poly_netw_1 = fbmc_polyphase_network_vcvc(
config.fft_length, 4, 4 * config.fft_length - 1, False
)
poly_netw_2 = self._poly_netw_2 = fbmc_polyphase_network_vcvc(
config.fft_length, 4, 4 * config.fft_length - 1, False
)
overlap_p2s = self._overlap_p2s = fbmc_overlapping_parallel_to_serial_vcc(config.fft_length)
self.connect(ifft, (separate_oqam, 0), poly_netw_1)
self.connect((separate_oqam, 1), poly_netw_2)
self.connect(poly_netw_1, (overlap_p2s, 0))
self.connect(poly_netw_2, (overlap_p2s, 1))
## Pilot blocks (preambles)
# pblocks = self._pilot_block_inserter = pilot_block_inserter2(5,False)
# self.connect( overlap_p2s, blocks.stream_to_vector(gr.sizeof_gr_complex,config.fft_length/2), pblocks )
# log_to_file(self, pblocks, "data/fbmc_pilot_block_ins_out.compl")
if options.log:
log_to_file(self, pblocks, "data/pilot_block_ins_out.compl")
## Cyclic Prefix
# cp = self._cyclic_prefixer = cyclic_prefixer(config.fft_length,
# config.block_length)
# cp= blocks.vector_to_stream(gr.sizeof_gr_complex, config.fft_length/2)
# self.connect(pblocks, cp )
# self.connect( overlap_p2s,blocks.stream_to_vector(gr.sizeof_gr_complex,config.fft_length/2), cp )
lastblock = overlap_p2s
if options.log:
log_to_file(self, overlap_p2s, "data/overlap_p2s_out.compl")
# Digital Amplifier for resource allocation
if config.adaptive_fbmc:
rep = blocks.repeat(gr.sizeof_gr_complex, config.frame_length * config.block_length)
amp = blocks.multiply_cc()
self.connect(lastblock, (amp, 0))
self.connect((self.allocation_src, 3), rep, (amp, 1))
lastblock = amp
else:
self.connect((self.allocation_src, 3), blocks.null_sink(gr.sizeof_gr_complex))
## Digital Amplifier
# amp = self._amplifier = gr.multiply_const_cc(1)
amp = self._amplifier = ofdm.multiply_const_ccf(1.0)
self.connect(lastblock, amp)
self.set_rms_amplitude(rms_amp)
# log_to_file(self, amp, "data/amp_tx_out.compl")
if options.log:
log_to_file(self, amp, "data/amp_tx_out.compl")
## Tx parameters
bandwidth = options.bandwidth or 2e6
bits = 8 * config.data_subcarriers * config.frame_data_blocks # max. QAM256
samples_per_frame = config.frame_length * config.block_length
tb = samples_per_frame / bandwidth
# set dummy carrier frequency if none available due to baseband mode
if options.tx_freq is None:
options.tx_freq = 0.0
self.tx_parameters = {
"carrier_frequency": options.tx_freq / 1e9,
"fft_size": config.fft_length,
"cp_size": config.cp_length,
"subcarrier_spacing": options.bandwidth / config.fft_length / 1e3,
"data_subcarriers": config.data_subcarriers,
"bandwidth": options.bandwidth / 1e6,
"frame_length": config.frame_length,
"symbol_time": (config.cp_length + config.fft_length) / options.bandwidth * 1e6,
"max_data_rate": (bits / tb) / 1e6,
}
## Setup Output
self.connect(amp, self)
# Display some information about the setup
if config._verbose:
self._print_verbage()
def __init__(self,
M=1024,
K=4,
qam_size=16,
syms_per_frame=10,
carriers=924,
theta_sel=0,
exclude_preamble=0,
sel_preamble=0,
zero_pads=1,
extra_pad=False):
gr.hier_block2.__init__(
self,
"fbmc_transmitter_demo",
gr.io_signature(1, 1, gr.sizeof_gr_complex * M),
gr.io_signature(1, 1, gr.sizeof_gr_complex * 1),
)
##################################################
# Parameters
##################################################
self.syms_per_frame = syms_per_frame
self.qam_size = qam_size
self.K = K
self.M = M
self.exclude_preamble = exclude_preamble
self.theta_sel = theta_sel
self.zero_pads = zero_pads
##################################################
# Variables
##################################################
# Assertions
assert (M > 0 and K > 0
and qam_size > 0), "M, K and qam_size should be bigger than 0"
assert ((math.log(M) / math.log(2)) == int(
math.log(M) / math.log(2))), "M shouldbe a power of 2"
assert (K == 4), "for now only K=4 s supported."
assert (qam_size == 4 or qam_size == 16 or qam_size == 64
or qam_size == 256
), "Only 4-,16-,64-,256-qam constellations are supported."
assert (theta_sel == 0 or theta_sel == 1)
assert (exclude_preamble == 0 or exclude_preamble == 1)
##################################################
# Blocks
##################################################
self.fft_vxx_0_0 = fft.fft_vcc(M, False, (), True, 1)
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc(
([1.0 / (M * 0.6863)] * M))
# self.fbmc_symbol_creation_bvc_0 = ofdm.fbmc_symbol_creation_bvc(carriers, qam_size)
self.vector_padding_0 = ofdm.vector_padding(carriers, M, -1)
self.fbmc_separate_vcvc_0 = ofdm.fbmc_separate_vcvc(M, 2)
self.fbmc_polyphase_network_vcvc_0_0 = ofdm.fbmc_polyphase_network_vcvc(
M, K, K * M - 1, False)
self.fbmc_polyphase_network_vcvc_0 = ofdm.fbmc_polyphase_network_vcvc(
M, K, K * M - 1, False)
self.fbmc_overlapping_parallel_to_serial_vcc_0 = ofdm.fbmc_overlapping_parallel_to_serial_vcc(
M)
self.fbmc_oqam_preprocessing_vcvc_0 = ofdm.fbmc_oqam_preprocessing_vcvc(
M, 0, theta_sel)
self.fbmc_insert_preamble_vcvc_0 = ofdm.fbmc_insert_preamble_vcvc(
M, syms_per_frame, sel_preamble, zero_pads, extra_pad)
self.fbmc_beta_multiplier_vcvc_0 = ofdm.fbmc_beta_multiplier_vcvc(
M, K, K * M - 1, 0)
self.blks2_selector_0 = grc_blks2.selector(
item_size=gr.sizeof_gr_complex * M,
num_inputs=2,
num_outputs=1,
input_index=exclude_preamble,
output_index=0,
)
##################################################
# Connections
##################################################
self.connect((self, 0), (self.vector_padding_0, 0))
self.connect((self.vector_padding_0, 0),
(self.fbmc_oqam_preprocessing_vcvc_0, 0))
# self.connect(, (self.fbmc_symbol_creation_bvc_0, 0))
self.connect((self.fbmc_beta_multiplier_vcvc_0, 0),
(self.fft_vxx_0_0, 0))
self.connect((self.fft_vxx_0_0, 0),
(self.blocks_multiply_const_vxx_0, 0))
self.connect((self.blocks_multiply_const_vxx_0, 0),
(self.fbmc_separate_vcvc_0, 0))
self.connect((self.fbmc_polyphase_network_vcvc_0, 0),
(self.fbmc_overlapping_parallel_to_serial_vcc_0, 0))
self.connect((self.fbmc_polyphase_network_vcvc_0_0, 0),
(self.fbmc_overlapping_parallel_to_serial_vcc_0, 1))
self.connect((self.fbmc_separate_vcvc_0, 1),
(self.fbmc_polyphase_network_vcvc_0_0, 0))
self.connect((self.fbmc_separate_vcvc_0, 0),
(self.fbmc_polyphase_network_vcvc_0, 0))
self.connect((self.fbmc_overlapping_parallel_to_serial_vcc_0, 0),
(self, 0))
self.connect((self.fbmc_oqam_preprocessing_vcvc_0, 0),
(self.blks2_selector_0, 1))
self.connect((self.fbmc_oqam_preprocessing_vcvc_0, 0),
(self.fbmc_insert_preamble_vcvc_0, 0))
self.connect((self.fbmc_insert_preamble_vcvc_0, 0),
(self.blks2_selector_0, 0))
self.connect((self.blks2_selector_0, 0),
(self.fbmc_beta_multiplier_vcvc_0, 0))
def __init__(self):
gr.top_block.__init__(self, "Top Block")
Qt.QWidget.__init__(self)
self.setWindowTitle("Top Block")
try:
self.setWindowIcon(Qt.QIcon.fromTheme('gnuradio-grc'))
except:
pass
self.top_scroll_layout = Qt.QVBoxLayout()
self.setLayout(self.top_scroll_layout)
self.top_scroll = Qt.QScrollArea()
self.top_scroll.setFrameStyle(Qt.QFrame.NoFrame)
self.top_scroll_layout.addWidget(self.top_scroll)
self.top_scroll.setWidgetResizable(True)
self.top_widget = Qt.QWidget()
self.top_scroll.setWidget(self.top_widget)
self.top_layout = Qt.QVBoxLayout(self.top_widget)
self.top_grid_layout = Qt.QGridLayout()
self.top_layout.addLayout(self.top_grid_layout)
self.settings = Qt.QSettings("GNU Radio", "top_block")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.used_id_bits = used_id_bits = 8
self.subcarriers = subcarriers = 208
self.id_blocks = id_blocks = 1
self.fft_length = fft_length = 256
self.fbmc = fbmc = 1
self.estimation_preamble = estimation_preamble = 0
self.data_blocks = data_blocks = 10
self.training_data = training_data = default_block_header(subcarriers,fft_length,fbmc,estimation_preamble,[])
self.repeated_id_bits = repeated_id_bits = subcarriers/used_id_bits
self.data_part = data_part = data_blocks + id_blocks
self.whitener_seed = whitener_seed = seed(1)
self.whitener_pn = whitener_pn = [randint(0,1) for i in range(used_id_bits*repeated_id_bits)]
self.variable_function_probe_2 = variable_function_probe_2 = 0
self.variable_function_probe_1 = variable_function_probe_1 = 0
self.variable_function_probe_0 = variable_function_probe_0 = 0
self.tx_hostname = tx_hostname = "localhost"
self.samp_rate = samp_rate = 4*250000
self.interleaver = interleaver = trellis.interleaver(2000,666)
self.frame_length = frame_length = 2*data_part + training_data.fbmc_no_preambles
self.filter_length = filter_length = 4
self.disable_freq_sync = disable_freq_sync = 1
self.coding = coding = 1
self.chunkdivisor = chunkdivisor = int(numpy.ceil(data_blocks/5.0))
self.ber_window = ber_window = 100000
self.amplitude = amplitude = 1
self.SNR = SNR = 40
##################################################
# Blocks
##################################################
self._amplitude_layout = Qt.QVBoxLayout()
self._amplitude_tool_bar = Qt.QToolBar(self)
self._amplitude_layout.addWidget(self._amplitude_tool_bar)
self._amplitude_tool_bar.addWidget(Qt.QLabel("amplitude"+": "))
class qwt_counter_pyslot(Qwt.QwtCounter):
def __init__(self, parent=None):
Qwt.QwtCounter.__init__(self, parent)
@pyqtSlot('double')
def setValue(self, value):
super(Qwt.QwtCounter, self).setValue(value)
self._amplitude_counter = qwt_counter_pyslot()
self._amplitude_counter.setRange(0, 1, 0.02)
self._amplitude_counter.setNumButtons(2)
self._amplitude_counter.setValue(self.amplitude)
self._amplitude_tool_bar.addWidget(self._amplitude_counter)
self._amplitude_counter.valueChanged.connect(self.set_amplitude)
self._amplitude_slider = Qwt.QwtSlider(None, Qt.Qt.Horizontal, Qwt.QwtSlider.BottomScale, Qwt.QwtSlider.BgSlot)
self._amplitude_slider.setRange(0, 1, 0.02)
self._amplitude_slider.setValue(self.amplitude)
self._amplitude_slider.setMinimumWidth(200)
self._amplitude_slider.valueChanged.connect(self.set_amplitude)
self._amplitude_layout.addWidget(self._amplitude_slider)
self.top_layout.addLayout(self._amplitude_layout)
self.tx_rpc_manager_0 = tx_rpc_manager(fft_length, subcarriers, data_blocks, frame_length, 0, 0.0, samp_rate)
self.tigr_transmit_control_0 = tigr_transmit_control(
subcarriers=subcarriers,
fft_length=fft_length,
used_id_bits=used_id_bits,
estimation_preamble=estimation_preamble,
filter_length=filter_length,
fbmc=fbmc,
data_blocks=data_blocks,
data_part=data_part,
repeated_id_bits=repeated_id_bits,
coding=coding,
)
self.tigr_scatterplot_0 = tigr_scatterplot(
subcarriers=subcarriers,
fbmc=fbmc,
fft_length=fft_length,
estimation_preamble=estimation_preamble,
data_blocks=data_blocks,
data_part=11,
frame_length=frame_length,
)
self.rx_rpc_manager_0 = rx_rpc_manager()
self.rms = fbmc_rms_amplifier(amplitude, subcarriers)
self.zeromq_pub_sink_1 = zeromq.pub_sink(gr.sizeof_float, subcarriers, "tcp://*:5559", 100)
self.zeromq_pub_sink_0 = zeromq.pub_sink(gr.sizeof_float, 1, "tcp://*:5557", 100)
def _variable_function_probe_2_probe():
while True:
val = self.rx_rpc_manager_0.add_set_scatter_subcarrier_interface(self.tigr_scatterplot_0.ofdm_vector_element_0.set_element)
try:
self.set_variable_function_probe_2(val)
except AttributeError:
pass
time.sleep(1.0 / (0.000000001))
_variable_function_probe_2_thread = threading.Thread(target=_variable_function_probe_2_probe)
_variable_function_probe_2_thread.daemon = True
_variable_function_probe_2_thread.start()
def _variable_function_probe_1_probe():
while True:
val = self.tx_rpc_manager_0.add_tx_modulation_interface(self.tigr_transmit_control_0.ofdm_allocation_src_0.set_allocation)
try:
self.set_variable_function_probe_1(val)
except AttributeError:
pass
time.sleep(1.0 / (0.000000001))
_variable_function_probe_1_thread = threading.Thread(target=_variable_function_probe_1_probe)
_variable_function_probe_1_thread.daemon = True
_variable_function_probe_1_thread.start()
def _variable_function_probe_0_probe():
while True:
val = self.tx_rpc_manager_0.add_tx_ampl_interface(self.rms.set_rms_amplitude)
try:
self.set_variable_function_probe_0(val)
except AttributeError:
pass
time.sleep(1.0 / (0.000000001))
_variable_function_probe_0_thread = threading.Thread(target=_variable_function_probe_0_probe)
_variable_function_probe_0_thread.daemon = True
_variable_function_probe_0_thread.start()
self.trellis_permutation_0 = trellis.permutation(interleaver.K(), (interleaver.DEINTER()), 1, gr.sizeof_float*1)
self.tigr_fbmc_snr_estimator_0 = tigr_fbmc_snr_estimator(
subcarriers=subcarriers,
fbmc=fbmc,
fft_length=fft_length,
estimation_preamble=estimation_preamble,
frame_length=frame_length,
)
self.tigr_fbmc_inner_receiver_0 = tigr_fbmc_inner_receiver(
subcarriers=subcarriers,
fft_length=fft_length,
data_blocks=data_blocks,
estimation_preamble=estimation_preamble,
filter_length=filter_length,
frame_length=frame_length,
disable_freq_sync=disable_freq_sync,
)
self.tigr_ber_measurement_0 = tigr_ber_measurement(
subcarriers=subcarriers,
fbmc=fbmc,
fft_length=fft_length,
estimation_preamble=estimation_preamble,
ber_window=ber_window,
data_blocks=data_blocks,
)
self.single_pole_iir_filter_xx_0 = filter.single_pole_iir_filter_ff(0.1, subcarriers)
self.ofdm_viterbi_combined_fb_0 = ofdm.viterbi_combined_fb(ofdm.fsm(ofdm.fsm(1,2,[91,121])), subcarriers, -1, -1, 2, chunkdivisor, ([-1,-1,-1,1,1,-1,1,1]), ofdm.TRELLIS_EUCLIDEAN)
self.ofdm_vector_sampler_0 = ofdm.vector_sampler(gr.sizeof_gr_complex*subcarriers, 1)
self.ofdm_vector_padding_0 = ofdm.vector_padding(subcarriers, fft_length, -1)
self.ofdm_multiply_frame_fc_0 = ofdm.multiply_frame_fc(data_part, subcarriers)
self.ofdm_multiply_const_ii_0 = ofdm.multiply_const_ii(1./int(numpy.ceil(data_blocks/5.0)))
self.ofdm_generic_softdemapper_vcf_0 = ofdm.generic_softdemapper_vcf(subcarriers, data_part, 1)
self.ofdm_fbmc_separate_vcvc_1 = ofdm.fbmc_separate_vcvc(fft_length, 2)
self.ofdm_fbmc_polyphase_network_vcvc_1 = ofdm.fbmc_polyphase_network_vcvc(fft_length, filter_length, filter_length*fft_length-1, False)
self.ofdm_fbmc_polyphase_network_vcvc_0 = ofdm.fbmc_polyphase_network_vcvc(fft_length, filter_length, filter_length*fft_length-1, False)
self.ofdm_fbmc_pilot_block_inserter_0 = fbmc_pilot_block_inserter(subcarriers, data_part, training_data, 5)
self.ofdm_fbmc_pilot_block_filter_0 = fbmc_pilot_block_filter(subcarriers, frame_length, data_part, training_data)
self.ofdm_fbmc_overlapping_parallel_to_serial_vcc_0 = ofdm.fbmc_overlapping_parallel_to_serial_vcc(fft_length)
self.ofdm_fbmc_oqam_preprocessing_vcvc_0 = ofdm.fbmc_oqam_preprocessing_vcvc(subcarriers, 0, 0)
self.ofdm_fbmc_frame_sampler_0 = fbmc_frame_sampler(subcarriers, frame_length, data_part, training_data)
self.ofdm_fbmc_beta_multiplier_vcvc_0 = ofdm.fbmc_beta_multiplier_vcvc(fft_length, filter_length, fft_length*fft_length-1, 0)
self.ofdm_dynamic_trigger_ib_0 = ofdm.dynamic_trigger_ib(0)
self.ofdm_depuncture_ff_0 = ofdm.depuncture_ff(subcarriers, 0)
self.ofdm_coded_bpsk_soft_decoder_0 = ofdm.coded_bpsk_soft_decoder(subcarriers, used_id_bits, (whitener_pn))
self.ofdm_allocation_buffer_0 = ofdm.allocation_buffer(subcarriers, data_blocks, "tcp://"+tx_hostname+":3333", 1)
self.fft_vxx_1 = fft.fft_vcc(fft_length, False, ([]), True, 1)
self.channels_channel_model_0 = channels.channel_model(
noise_voltage=math.sqrt(1.0*fft_length/subcarriers)*math.sqrt(0.5)*10**(-SNR/20.0),
frequency_offset=0.0/fft_length,
epsilon=1,
taps=((1.0 ), ),
noise_seed=0,
block_tags=False
)
self.blocks_vector_source_x_0 = blocks.vector_source_b([1] + [0]*(data_blocks/2-1), True, 1, [])
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, samp_rate,True)
self.blocks_keep_one_in_n_1 = blocks.keep_one_in_n(gr.sizeof_float*subcarriers, 20)
self.blks2_selector_0 = grc_blks2.selector(
item_size=gr.sizeof_float*1,
num_inputs=2,
num_outputs=1,
input_index=0,
output_index=0,
)
##################################################
# Connections
##################################################
self.connect((self.ofdm_fbmc_polyphase_network_vcvc_0, 0), (self.ofdm_fbmc_overlapping_parallel_to_serial_vcc_0, 0))
self.connect((self.ofdm_fbmc_polyphase_network_vcvc_1, 0), (self.ofdm_fbmc_overlapping_parallel_to_serial_vcc_0, 1))
self.connect((self.ofdm_fbmc_separate_vcvc_1, 1), (self.ofdm_fbmc_polyphase_network_vcvc_1, 0))
self.connect((self.ofdm_fbmc_oqam_preprocessing_vcvc_0, 0), (self.ofdm_fbmc_pilot_block_inserter_0, 0))
self.connect((self.ofdm_fbmc_pilot_block_inserter_0, 0), (self.ofdm_vector_padding_0, 0))
self.connect((self.ofdm_fbmc_beta_multiplier_vcvc_0, 0), (self.fft_vxx_1, 0))
self.connect((self.fft_vxx_1, 0), (self.ofdm_fbmc_separate_vcvc_1, 0))
self.connect((self.tigr_transmit_control_0, 0), (self.ofdm_fbmc_oqam_preprocessing_vcvc_0, 0))
self.connect((self.single_pole_iir_filter_xx_0, 0), (self.blocks_keep_one_in_n_1, 0))
self.connect((self.ofdm_fbmc_frame_sampler_0, 1), (self.ofdm_fbmc_pilot_block_filter_0, 1))
self.connect((self.ofdm_fbmc_frame_sampler_0, 0), (self.ofdm_fbmc_pilot_block_filter_0, 0))
self.connect((self.ofdm_fbmc_pilot_block_filter_0, 1), (self.ofdm_vector_sampler_0, 1))
self.connect((self.ofdm_vector_sampler_0, 0), (self.ofdm_coded_bpsk_soft_decoder_0, 0))
self.connect((self.ofdm_coded_bpsk_soft_decoder_0, 0), (self.ofdm_allocation_buffer_0, 0))
self.connect((self.ofdm_allocation_buffer_0, 1), (self.ofdm_generic_softdemapper_vcf_0, 1))
self.connect((self.single_pole_iir_filter_xx_0, 0), (self.ofdm_generic_softdemapper_vcf_0, 2))
self.connect((self.ofdm_generic_softdemapper_vcf_0, 0), (self.trellis_permutation_0, 0))
self.connect((self.ofdm_depuncture_ff_0, 0), (self.ofdm_viterbi_combined_fb_0, 0))
self.connect((self.ofdm_allocation_buffer_0, 1), (self.ofdm_depuncture_ff_0, 1))
self.connect((self.blocks_vector_source_x_0, 0), (self.ofdm_depuncture_ff_0, 2))
self.connect((self.ofdm_allocation_buffer_0, 0), (self.ofdm_multiply_const_ii_0, 0))
self.connect((self.ofdm_multiply_const_ii_0, 0), (self.ofdm_viterbi_combined_fb_0, 1))
self.connect((self.ofdm_fbmc_separate_vcvc_1, 0), (self.ofdm_fbmc_polyphase_network_vcvc_0, 0))
self.connect((self.ofdm_viterbi_combined_fb_0, 0), (self.tigr_ber_measurement_0, 2))
self.connect((self.ofdm_dynamic_trigger_ib_0, 0), (self.tigr_ber_measurement_0, 3))
self.connect((self.ofdm_fbmc_frame_sampler_0, 0), (self.tigr_fbmc_snr_estimator_0, 0))
self.connect((self.ofdm_fbmc_frame_sampler_0, 1), (self.tigr_fbmc_snr_estimator_0, 1))
self.connect((self.tigr_fbmc_inner_receiver_0, 1), (self.ofdm_fbmc_frame_sampler_0, 1))
self.connect((self.tigr_fbmc_inner_receiver_0, 2), (self.ofdm_fbmc_frame_sampler_0, 0))
self.connect((self.rms, 0), (self.blocks_throttle_0, 0))
self.connect((self.tigr_fbmc_inner_receiver_0, 3), (self.zeromq_pub_sink_0, 0))
self.connect((self.blocks_keep_one_in_n_1, 0), (self.zeromq_pub_sink_1, 0))
self.connect((self.ofdm_vector_padding_0, 0), (self.ofdm_fbmc_beta_multiplier_vcvc_0, 0))
self.connect((self.tigr_fbmc_inner_receiver_0, 0), (self.single_pole_iir_filter_xx_0, 0))
self.connect((self.ofdm_fbmc_overlapping_parallel_to_serial_vcc_0, 0), (self.rms, 0))
self.connect((self.ofdm_allocation_buffer_0, 0), (self.ofdm_dynamic_trigger_ib_0, 0))
self.connect((self.ofdm_coded_bpsk_soft_decoder_0, 0), (self.tigr_ber_measurement_0, 0))
self.connect((self.ofdm_allocation_buffer_0, 0), (self.tigr_ber_measurement_0, 1))
self.connect((self.blks2_selector_0, 0), (self.ofdm_depuncture_ff_0, 0))
self.connect((self.trellis_permutation_0, 0), (self.blks2_selector_0, 1))
self.connect((self.ofdm_generic_softdemapper_vcf_0, 0), (self.blks2_selector_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.channels_channel_model_0, 0))
self.connect((self.channels_channel_model_0, 0), (self.tigr_fbmc_inner_receiver_0, 0))
self.connect((self.ofdm_fbmc_pilot_block_filter_0, 0), (self.ofdm_vector_sampler_0, 0))
self.connect((self.ofdm_allocation_buffer_0, 2), (self.ofdm_multiply_frame_fc_0, 1))
self.connect((self.ofdm_fbmc_pilot_block_filter_0, 0), (self.ofdm_multiply_frame_fc_0, 0))
self.connect((self.ofdm_multiply_frame_fc_0, 0), (self.tigr_scatterplot_0, 0))
self.connect((self.ofdm_multiply_frame_fc_0, 0), (self.ofdm_generic_softdemapper_vcf_0, 0))
def __init__(self, M=1024, K=4, qam_size=16, syms_per_frame=10, start=10, end=29, theta_sel=0, exclude_preamble=0, sel_preamble=0, zero_pads=1, extra_pad=False):
gr.hier_block2.__init__(self,
"fbmc_transmitter_multiuser_bc",
gr.io_signature(1, 1, gr.sizeof_char*1),
gr.io_signature(1, 1, gr.sizeof_gr_complex*1),
)
##################################################
# Parameters
##################################################
self.syms_per_frame = syms_per_frame
self.qam_size = qam_size
self.K = K
self.M = M
self.exclude_preamble = exclude_preamble
self.theta_sel = theta_sel
self.zero_pads = zero_pads
self.allocation = allocation = end-start+1
##################################################
# Variables
##################################################
# Assertions
assert(M>0 and K>0 and qam_size>0), "M, K and qam_size should be bigger than 0"
assert((math.log(M)/math.log(2))==int(math.log(M)/math.log(2))), "M shouldbe a power of 2"
assert(K==4), "for now only K=4 s supported."
assert(qam_size==4 or qam_size==16 or qam_size==64 or qam_size==256 ), "Only 4-,16-,64-,256-qam constellations are supported."
assert(theta_sel==0 or theta_sel==1)
assert(exclude_preamble==0 or exclude_preamble==1)
##################################################
# Blocks
##################################################
self.fft_vxx_0_0 = fft.fft_vcc(M, False, (), True, 1)
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc(([1.0/(M*0.6863)]*M))
self.fbmc_symbol_creation_bvc_0 = ofdm.fbmc_symbol_creation_bvc(allocation, qam_size)
self.vector_padding_0 = ofdm.fbmc_asymmetrical_vector_padding_vcvc(start,end,M,-1)
self.fbmc_separate_vcvc_0 = ofdm.fbmc_separate_vcvc(M, 2)
self.fbmc_polyphase_network_vcvc_0_0 = ofdm.fbmc_polyphase_network_vcvc(M, K, K*M-1, False)
self.fbmc_polyphase_network_vcvc_0 = ofdm.fbmc_polyphase_network_vcvc(M, K, K*M-1, False)
self.fbmc_overlapping_parallel_to_serial_vcc_0 = ofdm.fbmc_overlapping_parallel_to_serial_vcc(M)
self.fbmc_oqam_preprocessing_vcvc_0 = ofdm.fbmc_oqam_preprocessing_vcvc(M, 0, theta_sel)
self.fbmc_insert_preamble_vcvc_0 = ofdm.fbmc_insert_preamble_vcvc(M, syms_per_frame, sel_preamble, zero_pads,extra_pad)
self.fbmc_beta_multiplier_vcvc_0 = ofdm.fbmc_beta_multiplier_vcvc(M, K, K*M-1, 0)
self.blks2_selector_0 = grc_blks2.selector(
item_size=gr.sizeof_gr_complex*M,
num_inputs=2,
num_outputs=1,
input_index=exclude_preamble,
output_index=0,
)
##################################################
# Connections
##################################################
self.connect((self.fbmc_symbol_creation_bvc_0, 0), (self.vector_padding_0,0))
self.connect((self.vector_padding_0,0),(self.fbmc_oqam_preprocessing_vcvc_0, 0))
self.connect((self, 0), (self.fbmc_symbol_creation_bvc_0, 0))
self.connect((self.fbmc_beta_multiplier_vcvc_0, 0), (self.fft_vxx_0_0, 0))
self.connect((self.fft_vxx_0_0, 0), (self.blocks_multiply_const_vxx_0,0))
self.connect((self.blocks_multiply_const_vxx_0,0), (self.fbmc_separate_vcvc_0, 0))
self.connect((self.fbmc_polyphase_network_vcvc_0, 0), (self.fbmc_overlapping_parallel_to_serial_vcc_0, 0))
self.connect((self.fbmc_polyphase_network_vcvc_0_0, 0), (self.fbmc_overlapping_parallel_to_serial_vcc_0, 1))
self.connect((self.fbmc_separate_vcvc_0, 1), (self.fbmc_polyphase_network_vcvc_0_0, 0))
self.connect((self.fbmc_separate_vcvc_0, 0), (self.fbmc_polyphase_network_vcvc_0, 0))
self.connect((self.fbmc_overlapping_parallel_to_serial_vcc_0, 0), (self, 0))
self.connect((self.fbmc_oqam_preprocessing_vcvc_0, 0), (self.blks2_selector_0, 1))
self.connect((self.fbmc_oqam_preprocessing_vcvc_0, 0), (self.fbmc_insert_preamble_vcvc_0, 0))
self.connect((self.fbmc_insert_preamble_vcvc_0, 0), (self.blks2_selector_0, 0))
self.connect((self.blks2_selector_0, 0), (self.fbmc_beta_multiplier_vcvc_0, 0))
def __init__(self, options):
gr.hier_block2.__init__(self, "fbmc_transmit_path",
gr.io_signature(0,0,0),
gr.io_signature(1,1,gr.sizeof_gr_complex))
common_options.defaults(options)
config = self.config = station_configuration()
config.data_subcarriers = options.subcarriers
config.cp_length = 0
config.frame_data_blocks = options.data_blocks
config._verbose = options.verbose
config.fft_length = options.fft_length
config.dc_null = options.dc_null
config.training_data = default_block_header(config.data_subcarriers,
config.fft_length,config.dc_null,options)
config.coding = options.coding
config.fbmc = options.fbmc
config.adaptive_fbmc = options.adaptive_fbmc
config.frame_id_blocks = 1 # FIXME
# digital rms amplitude sent to USRP
rms_amp = options.rms_amplitude
self._options = copy.copy(options)
config.block_length = config.fft_length + config.cp_length
config.frame_data_part = config.frame_data_blocks + config.frame_id_blocks
config.frame_length = config.training_data.fbmc_no_preambles + 2*config.frame_data_part
config.subcarriers = config.data_subcarriers + \
config.training_data.pilot_subcarriers
config.virtual_subcarriers = config.fft_length - config.subcarriers - config.dc_null
# default values if parameters not set
if rms_amp is None:
rms_amp = math.sqrt(config.subcarriers)
config.rms_amplitude = rms_amp
# check some bounds
if config.fft_length < config.subcarriers:
raise SystemError, "Subcarrier number must be less than FFT length"
if config.fft_length < config.cp_length:
raise SystemError, "Cyclic prefix length must be less than FFT length"
## shortcuts
blen = config.block_length
flen = config.frame_length
dsubc = config.data_subcarriers
vsubc = config.virtual_subcarriers
# Adaptive Transmitter Concept
used_id_bits = config.used_id_bits = 8 #TODO: no constant in source code
rep_id_bits = config.rep_id_bits = config.data_subcarriers/used_id_bits #BPSK
if config.data_subcarriers % used_id_bits <> 0:
raise SystemError,"Data subcarriers need to be multiple of %d" % (used_id_bits)
## Allocation Control
self.allocation_src = allocation_src(config.data_subcarriers, config.frame_data_blocks, config.coding, "tcp://*:3333", "tcp://"+options.rx_hostname+":3322")
if options.static_allocation: #DEBUG
# how many bits per subcarrier
if options.coding:
mode = 1 # Coding mode 1-9
bitspermode= [0.5,1,1.5,2,3,4,4.5,5,6] # Information bits per mode
modulbitspermode = [1,2,2,4,4,6,6,6,8] # Coding bits per mode
bitcount_vec = [(int)(config.data_subcarriers*config.frame_data_blocks*bitspermode[mode-1])]
modul_bitcount_vec = [config.data_subcarriers*config.frame_data_blocks*modulbitspermode[mode-1]]
bitcount_src = blocks.vector_source_i(bitcount_vec,True,1)
modul_bitcount_src = blocks.vector_source_i(modul_bitcount_vec,True,1)
bitloading = mode
else:
bitloading = 1
bitcount_vec = [config.data_subcarriers*config.frame_data_blocks*bitloading]
bitcount_src = blocks.vector_source_i(bitcount_vec,True,1)
modul_bitcount_src = bitcount_src
# id's for frames
id_vec = range(0,256)
id_src = blocks.vector_source_s(id_vec,True,1)
# bitloading for ID symbol and then once for data symbols
#bitloading_vec = [1]*dsubc+[0]*(dsubc/2)+[2]*(dsubc/2)
test_allocation = [bitloading]*(int)(config.data_subcarriers/8)+ [0]*(int)(config.data_subcarriers/4*3) + [bitloading]*(int)(config.data_subcarriers/8)
#bitloading_vec = [1]*dsubc+[bitloading]*dsubc
bitloading_vec = [1]*dsubc+test_allocation
bitloading_src = blocks.vector_source_b(bitloading_vec,True,dsubc)
# bitcount for frames
#bitcount_vec = [config.data_subcarriers*config.frame_data_blocks*bitloading]
bitcount_vec = [config.frame_data_blocks*sum(test_allocation)]
bitcount_src = blocks.vector_source_i(bitcount_vec,True,1)
# power loading, here same for all symbols
power_vec = [1]*(int)(config.data_subcarriers/8)+ [0]*(int)(config.data_subcarriers/4*3) + [1]*(int)(config.data_subcarriers/8)
power_src = blocks.vector_source_f(power_vec,True,dsubc)
# mux control stream to mux id and data bits
mux_vec = [0]*dsubc+[1]*bitcount_vec[0]
mux_ctrl = blocks.vector_source_b(mux_vec,True,1)
else:
id_src = (self.allocation_src,0)
bitcount_src = (self.allocation_src,4)
bitloading_src = (self.allocation_src,2)
power_src = (self.allocation_src,1)
if options.coding:
modul_bitcount_src = (self.allocation_src,5)
else:
modul_bitcount_src = bitcount_src
mux_ctrl = ofdm.tx_mux_ctrl(dsubc)
self.connect(modul_bitcount_src,mux_ctrl)
#Initial allocation
self.allocation_src.set_allocation([4]*config.data_subcarriers,[1]*config.data_subcarriers)
if options.benchmarking:
self.allocation_src.set_allocation([4]*config.data_subcarriers,[1]*config.data_subcarriers)
if options.lab_special_case:
self.allocation_src.set_allocation([0]*(config.data_subcarriers/4)+[2]*(config.data_subcarriers/2)+[0]*(config.data_subcarriers/4),[1]*config.data_subcarriers)
if options.log:
log_to_file(self, id_src, "data/id_src.short")
log_to_file(self, bitcount_src, "data/bitcount_src.int")
log_to_file(self, bitloading_src, "data/bitloading_src.char")
log_to_file(self, power_src, "data/power_src.cmplx")
## GUI probe output
zmq_probe_bitloading = zeromq.pub_sink(gr.sizeof_char,dsubc, "tcp://*:4445")
# also skip ID symbol bitloading with keep_one_in_n (side effect)
# factor 2 for bitloading because we have two vectors per frame, one for id symbol and one for all payload/data symbols
# factor config.frame_data_part for power because there is one vector per ofdm symbol per frame
self.connect(bitloading_src, blocks.keep_one_in_n(gr.sizeof_char*dsubc,2*40), zmq_probe_bitloading)
zmq_probe_power = zeromq.pub_sink(gr.sizeof_float,dsubc, "tcp://*:4444")
#self.connect(power_src, blocks.keep_one_in_n(gr.sizeof_gr_complex*dsubc,40), blocks.complex_to_real(dsubc), zmq_probe_power)
self.connect(power_src, blocks.keep_one_in_n(gr.sizeof_float*dsubc,40), zmq_probe_power)
## Workaround to avoid periodic structure
seed(1)
whitener_pn = [randint(0,1) for i in range(used_id_bits*rep_id_bits)]
## ID Encoder
id_enc = self._id_encoder = repetition_encoder_sb(used_id_bits,rep_id_bits,whitener_pn)
self.connect(id_src,id_enc)
if options.log:
id_enc_f = gr.char_to_float()
self.connect(id_enc,id_enc_f)
log_to_file(self, id_enc_f, "data/id_enc_out.float")
## Reference Data Source
ber_ref_src = ber_reference_source(self._options)
self.connect(id_src,(ber_ref_src,0))
self.connect(bitcount_src,(ber_ref_src,1))
if options.log:
log_to_file(self, ber_ref_src, "data/ber_rec_src_tx.char")
if options.log:
log_to_file(self, btrig, "data/bitmap_trig.char")
## Frame Trigger
ftrig_stream = [1]+[0]*(config.frame_data_part-1)
ftrig = self._frame_trigger = blocks.vector_source_b(ftrig_stream,True)
## Data Multiplexer
# Input 0: control stream
# Input 1: encoded ID stream
# Inputs 2..n: data streams
dmux = self._data_multiplexer = stream_controlled_mux_b()
self.connect(mux_ctrl,(dmux,0))
self.connect(id_enc,(dmux,1))
if options.coding:
fo=trellis.fsm(1,2,[91,121])
encoder = self._encoder = trellis.encoder_bb(fo,0)
unpack = self._unpack = blocks.unpack_k_bits_bb(2)
self.connect(ber_ref_src,encoder,unpack)
if options.interleave:
int_object=trellis.interleaver(2000,666)
interlv = trellis.permutation(int_object.K(),int_object.INTER(),1,gr.sizeof_char)
if not options.nopunct:
bmaptrig_stream_puncturing = [1]+[0]*(config.frame_data_blocks/2-1)
btrig_puncturing = self._bitmap_trigger_puncturing = blocks.vector_source_b(bmaptrig_stream_puncturing, True)
puncturing = self._puncturing = puncture_bb(config.data_subcarriers)
self.connect(bitloading_src,(puncturing,1))
self.connect(self._bitmap_trigger_puncturing,(puncturing,2))
self.connect(unpack,puncturing)
last_block=puncturing
if options.interleave:
self.connect(last_block,interlv)
last_block = interlv
if options.benchmarking:
self.connect(last_block,blocks.head(gr.sizeof_char, options.N),(dmux,2))
else:
self.connect(last_block,(dmux,2))
else:
if options.benchmarking:
self.connect(unpack,blocks.head(gr.sizeof_char, options.N),(dmux,2))
else:
self.connect(unpack,(dmux,2))
else:
if options.benchmarking:
self.connect(ber_ref_src,blocks.head(gr.sizeof_char, options.N),(dmux,2))
else:
self.connect(ber_ref_src,(dmux,2))
if options.log:
dmux_f = gr.char_to_float()
self.connect(dmux,dmux_f)
log_to_file(self, dmux_f, "data/dmux_out.float")
## Modulator
mod = self._modulator = generic_mapper_bcv(config.data_subcarriers,config.coding, config.frame_data_part)
self.connect(dmux,(mod,0))
self.connect(bitloading_src,(mod,1))
if options.log:
log_to_file(self, mod, "data/mod_out.compl")
modi = blocks.complex_to_imag(config.data_subcarriers)
modr = blocks.complex_to_real(config.data_subcarriers)
self.connect(mod,modi)
self.connect(mod,modr)
log_to_file(self, modi, "data/mod_imag_out.float")
log_to_file(self, modr, "data/mod_real_out.float")
## Power allocator
pa = self._power_allocator = multiply_frame_fc(config.frame_data_part, config.data_subcarriers)
self.connect(mod,(pa,0))
self.connect(power_src,(pa,1))
if options.log:
log_to_file(self, pa, "data/pa_out.compl")
if options.fbmc:
psubc = pa
else:
psubc = self._pilot_subcarrier_inserter = pilot_subcarrier_inserter()
self.connect(pa,psubc)
if options.log:
log_to_file(self, psubc, "data/psubc_out.compl")
subcarriers = config.subcarriers
#fbmc_pblocks_timing = self._fbmc_timing_pilot_block_inserter = fbmc_timing_pilot_block_inserter(5,False)
oqam_prep = self._oqam_prep = fbmc_oqam_preprocessing_vcvc(config.subcarriers, 0, 0)
self.connect(psubc,oqam_prep)
fbmc_pblocks = self._fbmc_pilot_block_inserter = fbmc_pilot_block_inserter(5,False)
self.connect(oqam_prep, fbmc_pblocks)
#log_to_file(self, fbmc_pblocks, "data/fbmc_pblocks_out.compl")
#fbmc_insert_pream = self._fbmc_insert_pream = fbmc_insert_preamble_vcvc(M, syms_per_frame, preamble)
#log_to_file(self, oqam_prep, "data/oqam_prep.compl")
#log_to_file(self, psubc, "data/psubc_out.compl")
#fbmc_pblocks = fbmc_pblocks_timing
#log_to_file(self, fbmc_pblocks, "data/fbmc_pblocks_out.compl")
beta_mult = self._beta_mult = fbmc_beta_multiplier_vcvc(config.subcarriers, 4, 4*config.fft_length-1, 0)
self.connect(fbmc_pblocks, beta_mult)
log_to_file(self, beta_mult, "data/beta_mult.compl")
## Add virtual subcarriers
if config.fft_length > subcarriers:
vsubc = self._virtual_subcarrier_extender = \
vector_padding_dc_null(config.subcarriers, config.fft_length,config.dc_null)
self.connect(beta_mult,vsubc)
else:
vsubc = self._virtual_subcarrier_extender = beta_mult
if options.log:
log_to_file(self, vsubc, "data/vsubc_out.compl")
## IFFT, no window, block shift
ifft = self._ifft = fft_blocks.fft_vcc(config.fft_length,False,[],True)
self.connect(vsubc,ifft)
if options.log:
log_to_file(self, ifft, "data/ifft_out.compl")
#FBMC separate stream + filterbanks
separate_oqam = self._separate_oqam = fbmc_separate_vcvc(config.fft_length, 2)
poly_netw_1 = self._poly_netw_1 = fbmc_polyphase_network_vcvc(config.fft_length, 4, 4*config.fft_length-1, False)
poly_netw_2 = self._poly_netw_2 = fbmc_polyphase_network_vcvc(config.fft_length, 4, 4*config.fft_length-1, False)
overlap_p2s = self._overlap_p2s = fbmc_overlapping_parallel_to_serial_vcc(config.fft_length)
self.connect(ifft,(separate_oqam,0),poly_netw_1)
self.connect((separate_oqam,1),poly_netw_2)
self.connect(poly_netw_1,(overlap_p2s,0))
self.connect(poly_netw_2,(overlap_p2s,1))
## Pilot blocks (preambles)
#pblocks = self._pilot_block_inserter = pilot_block_inserter2(5,False)
#self.connect( overlap_p2s, blocks.stream_to_vector(gr.sizeof_gr_complex,config.fft_length/2), pblocks )
#log_to_file(self, pblocks, "data/fbmc_pilot_block_ins_out.compl")
if options.log:
log_to_file(self, pblocks, "data/pilot_block_ins_out.compl")
## Cyclic Prefix
#cp = self._cyclic_prefixer = cyclic_prefixer(config.fft_length,
# config.block_length)
#cp= blocks.vector_to_stream(gr.sizeof_gr_complex, config.fft_length/2)
#self.connect(pblocks, cp )
#self.connect( overlap_p2s,blocks.stream_to_vector(gr.sizeof_gr_complex,config.fft_length/2), cp )
lastblock = overlap_p2s
if options.log:
log_to_file(self, overlap_p2s, "data/overlap_p2s_out.compl")
#Digital Amplifier for resource allocation
if config.adaptive_fbmc:
rep = blocks.repeat(gr.sizeof_gr_complex, config.frame_length * config.block_length)
amp = blocks.multiply_cc()
self.connect( lastblock, (amp,0) )
self.connect((self.allocation_src,3), rep , (amp,1) )
lastblock = amp
else:
self.connect((self.allocation_src,3), blocks.null_sink(gr.sizeof_gr_complex) )
## Digital Amplifier
#amp = self._amplifier = gr.multiply_const_cc(1)
amp = self._amplifier = ofdm.multiply_const_ccf( 1.0 )
self.connect( lastblock, amp )
self.set_rms_amplitude(rms_amp)
#log_to_file(self, amp, "data/amp_tx_out.compl")
if options.log:
log_to_file(self, amp, "data/amp_tx_out.compl")
## Tx parameters
bandwidth = options.bandwidth or 2e6
bits = 8*config.data_subcarriers*config.frame_data_blocks # max. QAM256
samples_per_frame = config.frame_length*config.block_length
tb = samples_per_frame/bandwidth
# set dummy carrier frequency if none available due to baseband mode
if(options.tx_freq is None):
options.tx_freq = 0.0
self.tx_parameters = {'carrier_frequency':options.tx_freq/1e9,'fft_size':config.fft_length, 'cp_size':config.cp_length \
, 'subcarrier_spacing':options.bandwidth/config.fft_length/1e3 \
,'data_subcarriers':config.data_subcarriers, 'bandwidth':options.bandwidth/1e6 \
, 'frame_length':config.frame_length \
, 'symbol_time':(config.cp_length + config.fft_length)/options.bandwidth*1e6, 'max_data_rate':(bits/tb)/1e6}
## Setup Output
self.connect(amp,self)
# Display some information about the setup
if config._verbose:
self._print_verbage()