def __init__(self,
N=12,
M=256,
start_index=10,
mapping=0,
modulation=16,
cp_ratio=0.25):
gr.hier_block2.__init__(
self,
"scfdma_transmitter_bc",
gr.io_signature(1, 1, gr.sizeof_char * 1),
gr.io_signature(1, 1, gr.sizeof_gr_complex * 1),
)
##################################################
# Parameters
##################################################
self.N = N
self.M = M
self.start_index = start_index
self.modulation = modulation
self.cp_ratio = cp_ratio
self.mapping = mapping
##################################################
# Blocks
##################################################
self.ofdm_scfdma_subcarrier_mapper_vcvc_0 = ofdm.scfdma_subcarrier_mapper_vcvc(
N, M, start_index, mapping)
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc(
[1.0 / (M * N)])
self.ofdm_fbmc_symbol_creation_bvc_0 = ofdm.fbmc_symbol_creation_bvc(
N, modulation)
self.ofdm_cyclic_prefixer_0 = ofdm.cyclic_prefixer(
M, int(M * (1 + cp_ratio)))
self.fft_vxx_0_0 = fft.fft_vcc(M, False, (), True, 1)
self.fft_vxx_0 = fft.fft_vcc(N, True, (), True, 1)
##################################################
# Connections
##################################################
self.connect((self.fft_vxx_0, 0),
(self.ofdm_scfdma_subcarrier_mapper_vcvc_0, 0))
self.connect((self.fft_vxx_0_0, 0), (self.ofdm_cyclic_prefixer_0, 0))
self.connect((self.ofdm_cyclic_prefixer_0, 0),
(self.blocks_multiply_const_vxx_0, 0))
self.connect((self.blocks_multiply_const_vxx_0, 0), (self, 0))
self.connect((self.ofdm_fbmc_symbol_creation_bvc_0, 0),
(self.fft_vxx_0, 0))
self.connect((self.ofdm_scfdma_subcarrier_mapper_vcvc_0, 0),
(self.fft_vxx_0_0, 0))
self.connect((self, 0), (self.ofdm_fbmc_symbol_creation_bvc_0, 0))
def __init__(self, vlen, data_blocks, preamble_block, cp_len, framelength,
bits_per_subc):
gr.hier_block2.__init__(self, "ofdm_frame_src",
gr.io_signature(0, 0, 0),
gr.io_signature(1, 1, gr.sizeof_gr_complex))
data_block_src_i = data_block_src(bits_per_subc, vlen, data_blocks)
mux_ctrl = concatenate([[0], [1] * (framelength - 1)])
preamble_src = gr.vector_source_c(preamble_block, True, vlen)
self.preamble_src = preamble_src
block_mux = ofdm.static_mux_v(vlen * gr.sizeof_gr_complex,
mux_ctrl.tolist())
block_stream = ofdm.cyclic_prefixer(vlen, vlen + cp_len)
self.connect(preamble_src, (block_mux, 0))
self.connect(data_block_src_i, (block_mux, 1))
self.connect(block_mux, block_stream, self)
self.reset_blocks = [data_block_src_i, block_mux]
self.src = data_block_src_i
def __init__(self, N=12, M=256, start_index=10, mapping=0, modulation=16, cp_ratio=0.25):
gr.hier_block2.__init__(self,
"scfdma_transmitter_bc",
gr.io_signature(1, 1, gr.sizeof_char*1),
gr.io_signature(1, 1, gr.sizeof_gr_complex*1),
)
##################################################
# Parameters
##################################################
self.N = N
self.M = M
self.start_index = start_index
self.modulation = modulation
self.cp_ratio = cp_ratio
self.mapping = mapping
##################################################
# Blocks
##################################################
self.ofdm_scfdma_subcarrier_mapper_vcvc_0 = ofdm.scfdma_subcarrier_mapper_vcvc(N, M, start_index, mapping)
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vcc([1.0/(M*N)])
self.ofdm_fbmc_symbol_creation_bvc_0 = ofdm.fbmc_symbol_creation_bvc(N, modulation)
self.ofdm_cyclic_prefixer_0 = ofdm.cyclic_prefixer(M, int(M*(1+cp_ratio)))
self.fft_vxx_0_0 = fft.fft_vcc(M, False, (), True, 1)
self.fft_vxx_0 = fft.fft_vcc(N, True, (), True, 1)
##################################################
# Connections
##################################################
self.connect((self.fft_vxx_0, 0), (self.ofdm_scfdma_subcarrier_mapper_vcvc_0, 0))
self.connect((self.fft_vxx_0_0, 0), (self.ofdm_cyclic_prefixer_0, 0))
self.connect((self.ofdm_cyclic_prefixer_0, 0), (self.blocks_multiply_const_vxx_0,0))
self.connect((self.blocks_multiply_const_vxx_0,0), (self,0))
self.connect((self.ofdm_fbmc_symbol_creation_bvc_0, 0), (self.fft_vxx_0, 0))
self.connect((self.ofdm_scfdma_subcarrier_mapper_vcvc_0, 0), (self.fft_vxx_0_0, 0))
self.connect((self, 0), (self.ofdm_fbmc_symbol_creation_bvc_0, 0))
def __init__( self, vlen, data_blocks, preamble_block, cp_len,
framelength, bits_per_subc ):
gr.hier_block2.__init__( self,
"ofdm_frame_src",
gr.io_signature(0,0,0),
gr.io_signature( 1, 1, gr.sizeof_gr_complex ) )
data_block_src_i = data_block_src( bits_per_subc, vlen, data_blocks )
mux_ctrl = concatenate([[0],[1]*(framelength-1)])
preamble_src = gr.vector_source_c( preamble_block, True, vlen )
self.preamble_src = preamble_src
block_mux = ofdm.static_mux_v( vlen * gr.sizeof_gr_complex, mux_ctrl )
block_stream = ofdm.cyclic_prefixer( vlen, vlen+cp_len )
self.connect( preamble_src, ( block_mux, 0 ) )
self.connect( data_block_src_i, ( block_mux, 1 ) )
self.connect( block_mux, block_stream, self )
self.reset_blocks = [ data_block_src_i, block_mux ]
self.src = data_block_src_i
def __init__(self, fft_length, block_length, block_header, range, options):
gr.hier_block2.__init__(self, "integer_fo_estimator",
gr.io_signature3(3,3,gr.sizeof_gr_complex,gr.sizeof_float,gr.sizeof_char),
gr.io_signature2(3,3,gr.sizeof_float,gr.sizeof_char))
raise NotImplementedError,"Obsolete class"
self._range = range
# threshold after integer part frequency offset estimation
# if peak value below threshold, assume false triggering
self._thr_lo = 0.4 #0.19 # empirically found threshold. see ioe_metric.float
self._thr_hi = 0.4 #0.2
# stuff to be removed after bugfix for hierblock2s
self.input = gr.kludge_copy(gr.sizeof_gr_complex)
self.time_sync = gr.kludge_copy(gr.sizeof_char)
self.epsilon = (self,1)
self.connect((self,0),self.input)
self.connect((self,2),self.time_sync)
delay(gr.sizeof_char,
block_header.schmidl_fine_sync[0]*block_length)
# sample ofdm symbol (preamble 1 and 2)
sampler_symbol1 = vector_sampler(gr.sizeof_gr_complex,fft_length)
sampler_symbol2 = vector_sampler(gr.sizeof_gr_complex,fft_length)
time_delay1 = delay(gr.sizeof_char,block_length*block_header.schmidl_fine_sync[1])
self.connect(self.input, (sampler_symbol1,0))
self.connect(self.input, (sampler_symbol2,0))
if block_header.schmidl_fine_sync[0] > 0:
time_delay0 = delay(gr.sizeof_char,block_length*block_header.schmidl_fine_sync[0])
self.connect(self.time_sync, time_delay0, (sampler_symbol1,1))
else:
self.connect(self.time_sync, (sampler_symbol1,1))
self.connect(self.time_sync, time_delay1, (sampler_symbol2,1))
# negative fractional frequency offset estimate
epsilon = gr.multiply_const_ff(-1.0)
self.connect(self.epsilon, epsilon)
# compensate for fractional frequency offset on per symbol base
# freq_shift: vector length, modulator sensitivity
# freq_shift third input: reset phase accumulator
# symbol/preamble 1
freq_shift_sym1 = frequency_shift_vcc(fft_length, 1.0/fft_length)
self.connect(sampler_symbol1, (freq_shift_sym1,0))
self.connect(epsilon, (freq_shift_sym1,1))
self.connect(gr.vector_source_b([1], True), (freq_shift_sym1,2))
# symbol/preamble 2
freq_shift_sym2 = frequency_shift_vcc(fft_length, 1.0/fft_length)
self.connect(sampler_symbol2, (freq_shift_sym2,0))
self.connect(epsilon, (freq_shift_sym2,1))
self.connect(gr.vector_source_b([1], True), (freq_shift_sym2,2))
# fourier transfrom on both preambles
fft_sym1 = gr.fft_vcc(fft_length, True, [], True) # Forward + Blockshift
fft_sym2 = gr.fft_vcc(fft_length, True, [], True) # Forward + Blockshift
# calculate schmidl's metric for estimation of freq. offset's integer part
assert(hasattr(block_header, "schmidl_fine_sync"))
pre1 = block_header.pilotsym_fd[block_header.schmidl_fine_sync[0]]
pre2 = block_header.pilotsym_fd[block_header.schmidl_fine_sync[1]]
diff_pn = concatenate([[conjugate(math.sqrt(2)*pre2[2*i]/pre1[2*i]),0.0j] for i in arange(len(pre1)/2)])
cfo_estimator = schmidl_cfo_estimator(fft_length, len(pre1),
self._range, diff_pn)
self.connect(freq_shift_sym1, fft_sym1, (cfo_estimator,0)) # preamble 1
self.connect(freq_shift_sym2, fft_sym2, (cfo_estimator,1)) # preamble 2
# search for maximum and its argument in interval [-range .. +range]
#arg_max = arg_max_vff(2*self._range + 1)
arg_max_s = gr.argmax_fs(2*self._range+1)
arg_max = gr.short_to_float()
ifo_max = gr.max_ff(2*self._range + 1) # vlen
ifo_estimate = gr.add_const_ff(-self._range)
self.connect(cfo_estimator, arg_max_s, arg_max, ifo_estimate)
self.connect(cfo_estimator, ifo_max)
self.connect((arg_max_s,1),gr.null_sink(gr.sizeof_short))
# threshold maximal value
ifo_threshold = gr.threshold_ff(self._thr_lo, self._thr_hi, 0.0)
ifo_thr_f2b = gr.float_to_char()
self.connect(ifo_max, ifo_threshold, ifo_thr_f2b)
# gating the streams ifo_estimate (integer part) and epsilon (frac. part)
# if the metric's peak value was above the chosen threshold, assume to have
# found a new burst. peak value below threshold results in blocking the
# streams
self.gate = gate_ff()
self.connect(ifo_thr_f2b, (self.gate,0)) # threshold stream
self.connect(ifo_estimate, (self.gate,1))
self.connect(epsilon, (self.gate,2))
# peak filtering
# resynchronize and suppress peaks that didn't match a preamble
filtered_time_sync = peak_resync_bb(True) # replace
self.connect(self.time_sync, (filtered_time_sync,0))
self.connect(ifo_thr_f2b, (filtered_time_sync,1))
# find complete estimation for frequency offset
# add together fractional and integer part
freq_offset = gr.add_ff()
self.connect((self.gate,1), gr.multiply_const_ff(-1.0), (freq_offset,0)) # integer offset
self.connect((self.gate,2), (freq_offset,1)) # frac offset
# output connections
self.connect(freq_offset, (self,0))
self.connect(filtered_time_sync, (self,1))
self.connect((self.gate,0), (self,2)) # used for frame trigger
#########################################
# debugging
if options.log:
self.epsilon2_sink = gr.vector_sink_f()
self.connect(epsilon, self.epsilon2_sink)
self.connect(cfo_estimator, gr.file_sink(gr.sizeof_float*(self._range*2+1), "data/ioe_metric.float"))
# output joint stream
preamble_stream = gr.streams_to_vector(fft_length * gr.sizeof_gr_complex, 2)
self.connect(fft_sym1, (preamble_stream,0))
self.connect(fft_sym2, (preamble_stream,1))
self.connect(preamble_stream, gr.file_sink(gr.sizeof_gr_complex * 2 * fft_length, "data/preambles.compl"))
# output, preambles before and after correction, magnitude and complex spectrum
self.connect(sampler_symbol1, gr.fft_vcc(fft_length, True, [], True), gr.file_sink(gr.sizeof_gr_complex * fft_length, "data/pre1_bef.compl"))
self.connect(sampler_symbol1, gr.fft_vcc(fft_length, True, [], True), gr.complex_to_mag(fft_length), gr.file_sink(gr.sizeof_float * fft_length, "data/pre1_bef.float"))
self.connect(sampler_symbol2, gr.fft_vcc(fft_length, True, [], True), gr.file_sink(gr.sizeof_gr_complex * fft_length, "data/pre2_bef.compl"))
self.connect(sampler_symbol2, gr.fft_vcc(fft_length, True, [], True), gr.complex_to_mag(fft_length), gr.file_sink(gr.sizeof_float * fft_length, "data/pre2_bef.float"))
self.connect(freq_shift_sym1, gr.fft_vcc(fft_length, True, [], True), gr.file_sink(gr.sizeof_gr_complex * fft_length,"data/pre1.compl"))
self.connect(freq_shift_sym1, gr.fft_vcc(fft_length, True, [], True), gr.complex_to_mag(fft_length), gr.file_sink(gr.sizeof_float * fft_length,"data/pre1.float"))
self.connect(freq_shift_sym2, gr.fft_vcc(fft_length, True, [], True), gr.file_sink(gr.sizeof_gr_complex * fft_length,"data/pre2.compl"))
self.connect(freq_shift_sym2, gr.fft_vcc(fft_length, True, [], True), gr.complex_to_mag(fft_length), gr.file_sink(gr.sizeof_float * fft_length,"data/pre2.float"))
# calculate epsilon from corrected source to check function
test_cp = cyclic_prefixer(fft_length, block_length)
test_eps = foe(fft_length)
self.connect(freq_shift_sym1, test_cp, test_eps, gr.file_sink(gr.sizeof_float, "data/eps_after.float"))
try:
gr.hier_block.update_var_names(self, "ifo_estimator", vars())
gr.hier_block.update_var_names(self, "ifo_estimator", vars(self))
except:
pass
def __init__(self, options):
gr.hier_block2.__init__(self, "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 = options.cp_length
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.bandwidth = options.bandwidth
config.gui_frame_rate = options.gui_frame_rate
config.fbmc = options.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.frame_data_part + \
config.training_data.no_pilotsyms
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)
# adapt OFDM frame rate and GUI display frame rate
self.keep_frame_n = int(
1.0 / (config.frame_length *
(config.cp_length + config.fft_length) / config.bandwidth) /
config.gui_frame_rate)
## 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
test_allocation = [bitloading] * dsubc
bitloading_vec = [bitloading] * 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_vec = [1] * config.data_subcarriers
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([2] * config.data_subcarriers,
[1] * config.data_subcarriers)
self.allocation_src.set_allocation_scheme(0)
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")
## Bitmap Update Trigger for puncturing
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)
bmapsrc_stream_puncturing = [1] * dsubc + [2] * dsubc
bsrc_puncturing = self._bitmap_src_puncturing = blocks.vector_source_b(
bmapsrc_stream_puncturing, True, dsubc)
if options.log and options.coding and not options.nopunct:
log_to_file(self, btrig_puncturing,
"data/bitmap_trig_puncturing.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))
#log_to_file(self, mod, "data/mod_out.compl")
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")
# Standard Transmitter Parts
## Pilot subcarriers
psubc = self._pilot_subcarrier_inserter = pilot_subcarrier_inserter()
self.connect(pa, psubc)
if options.log:
log_to_file(self, psubc, "data/psubc_out.compl")
## Add virtual subcarriers
if config.fft_length > config.subcarriers:
vsubc = self._virtual_subcarrier_extender = \
vector_padding_dc_null(config.subcarriers, config.fft_length,config.dc_null)
self.connect(psubc, vsubc)
else:
vsubc = self._virtual_subcarrier_extender = psubc
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")
## Pilot blocks (preambles)
pblocks = self._pilot_block_inserter = pilot_block_inserter(5, False)
self.connect(ifft, pblocks)
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)
self.connect(pblocks, cp)
lastblock = cp
if options.log:
log_to_file(self, cp, "data/cp_out.compl")
#Digital Amplifier for resource allocation
#if not options.coding:
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
## 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)
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, options):
gr.hier_block2.__init__(self, "transmit_path",
gr.io_signature(0, 0, 0),
gr.io_signature(2, 2, gr.sizeof_gr_complex))
common_options.defaults(options)
config = self.config = station_configuration()
config.data_subcarriers = options.subcarriers
config.cp_length = options.cp_length
config.frame_data_blocks = options.data_blocks
config._verbose = options.verbose
config.fft_length = options.fft_length
config.training_data = default_block_header(config.data_subcarriers,
config.fft_length, options)
config.tx_station_id = options.station_id
config.coding = options.coding
if config.tx_station_id is None:
raise SystemError, "Station ID not set"
config.frame_id_blocks = 1 # FIXME
# digital rms amplitude sent to USRP
rms_amp = options.rms_amplitude
self._options = copy.copy(options)
self.servants = [] # FIXME
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.frame_data_part + \
config.training_data.no_pilotsyms
config.subcarriers = config.data_subcarriers + \
config.training_data.pilot_subcarriers
config.virtual_subcarriers = config.fft_length - config.subcarriers
# 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)
## Control Part
if options.debug:
self._control = ctrl = static_tx_control(options)
print "Statix TX Control used"
else:
self._control = ctrl = corba_tx_control(options)
print "CORBA TX Control used"
id_src = (ctrl, 0)
mux_src = (ctrl, 1)
map_src = self._map_src = (ctrl, 2)
pa_src = (ctrl, 3)
if options.log:
id_src_f = gr.short_to_float()
self.connect(id_src, id_src_f)
log_to_file(self, id_src_f, "data/id_src_out.float")
mux_src_f = gr.short_to_float()
self.connect(mux_src, mux_src_f)
log_to_file(self, mux_src_f, "data/mux_src_out.float")
map_src_s = blocks.vector_to_stream(gr.sizeof_char,
config.data_subcarriers)
map_src_f = gr.char_to_float()
self.connect(map_src, map_src_s, map_src_f)
##log_to_file(self, map_src_f, "data/map_src.float")
##log_to_file(self, pa_src, "data/pa_src_out.float")
## 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")
## Bitmap Update Trigger
# TODO
#bmaptrig_stream = concatenate([[1, 2],[0]*(config.frame_data_part-7)])
bmaptrig_stream = concatenate([[1, 1],
[0] * (config.frame_data_part - 2)])
print "bmaptrig_stream = ", bmaptrig_stream
btrig = self._bitmap_trigger = blocks.vector_source_b(
bmaptrig_stream.tolist(), True)
if options.log:
log_to_file(self, btrig, "data/bitmap_trig.char")
## Bitmap Update Trigger for puncturing
# TODO
if not options.nopunct:
#bmaptrig_stream_puncturing = concatenate([[1],[0]*(config.frame_data_part-2)])
bmaptrig_stream_puncturing = concatenate(
[[1], [0] * (config.frame_data_blocks / 2 - 1)])
btrig_puncturing = self._bitmap_trigger_puncturing = blocks.vector_source_b(
bmaptrig_stream_puncturing.tolist(), True)
bmapsrc_stream_puncturing = concatenate([[1] * dsubc, [2] * dsubc])
bsrc_puncturing = self._bitmap_src_puncturing = blocks.vector_source_b(
bmapsrc_stream_puncturing.tolist(), True, dsubc)
if options.log and options.coding and not options.nopunct:
log_to_file(self, btrig_puncturing,
"data/bitmap_trig_puncturing.char")
## Frame Trigger
# TODO
ftrig_stream = concatenate([[1], [0] * (config.frame_data_part - 1)])
ftrig = self._frame_trigger = blocks.vector_source_b(
ftrig_stream.tolist(), 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_src, (dmux, 0))
self.connect(id_enc, (dmux, 1))
self._data_multiplexer_nextport = 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,
options.coding)
self.connect(dmux, (mod, 0))
self.connect(map_src, (mod, 1))
self.connect(btrig, (mod, 2))
if options.log:
log_to_file(self, mod, "data/mod_out.compl")
modi = gr.complex_to_imag(config.data_subcarriers)
modr = gr.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
if options.debug:
## static
pa = self._power_allocator = power_allocator(
config.data_subcarriers)
self.connect(mod, (pa, 0))
self.connect(pa_src, (pa, 1))
else:
## with CORBA control event channel
ns_ip = ctrl.ns_ip
ns_port = ctrl.ns_port
evchan = ctrl.evchan
pa = self._power_allocator = corba_power_allocator(dsubc, \
evchan, ns_ip, ns_port, True)
self.connect(mod, (pa, 0))
self.connect(id_src, (pa, 1))
self.connect(ftrig, (pa, 2))
if options.log:
log_to_file(self, pa, "data/pa_out.compl")
## Pilot subcarriers
psubc = self._pilot_subcarrier_inserter = pilot_subcarrier_inserter()
self.connect(pa, psubc)
pilot_subc = config.training_data.shifted_pilot_tones
print "pilot_subc", pilot_subc
stc = stc_encoder(config.subcarriers, config.frame_data_blocks,
pilot_subc)
self.connect(psubc, stc)
if options.log:
log_to_file(self, psubc, "data/psubc_out.compl")
log_to_file(self, psubc_2, "data/psubc2_out.compl")
log_to_file(self, pa, "data/pa.compl")
log_to_file(self, (stc, 0), "data/stc_0.compl")
log_to_file(self, (stc, 1), "data/stc_1.compl")
## Add virtual subcarriers
if config.fft_length > config.subcarriers:
vsubc = self._virtual_subcarrier_extender = \
vector_padding(config.subcarriers, config.fft_length)
self.connect(stc, vsubc)
vsubc_2 = self._virtual_subcarrier_extender_2 = \
vector_padding(config.subcarriers, config.fft_length)
self.connect((stc, 1), vsubc_2)
else:
vsubc = self._virtual_subcarrier_extender = psubc
vsubc_2 = self._virtual_subcarrier_extender_2 = psubc_2
log_to_file(self, psubc, "data/psubc.compl")
log_to_file(self, stc, "data/stc1.compl")
log_to_file(self, (stc, 1), "data/stc2.compl")
if options.log:
log_to_file(self, vsubc, "data/vsubc_out.compl")
log_to_file(self, vsubc_2, "data/vsubc2_out.compl")
## IFFT, no window, block shift
ifft = self._ifft = fft_blocks.fft_vcc(config.fft_length, False, [],
True)
self.connect(vsubc, ifft)
ifft_2 = self._ifft_2 = fft_blocks.fft_vcc(config.fft_length, False,
[], True)
self.connect(vsubc_2, ifft_2)
if options.log:
log_to_file(self, ifft, "data/ifft_out.compl")
log_to_file(self, ifft_2, "data/ifft2_out.compl")
## Pilot blocks (preambles)
pblocks = self._pilot_block_inserter = pilot_block_inserter(1, False)
self.connect(ifft, pblocks)
pblocks_2 = self._pilot_block_inserter_2 = pilot_block_inserter(
2, False)
self.connect(ifft_2, pblocks_2)
if options.log:
log_to_file(self, pblocks, "data/pilot_block_ins_out.compl")
log_to_file(self, pblocks_2, "data/pilot_block_ins2_out.compl")
## Cyclic Prefix
cp = self._cyclic_prefixer = cyclic_prefixer(config.fft_length,
config.block_length)
self.connect(pblocks, cp)
cp_2 = self._cyclic_prefixer_2 = cyclic_prefixer(
config.fft_length, config.block_length)
self.connect(pblocks_2, cp_2)
lastblock = cp
lastblock_2 = cp_2
if options.log:
log_to_file(self, cp, "data/cp_out.compl")
log_to_file(self, cp_2, "data/cp2_out.compl")
if options.cheat:
## Artificial Channel
# kept to compare with previous system
achan_ir = concatenate([[1.0], [0.0] * (config.cp_length - 1)])
achan = self._artificial_channel = gr.fir_filter_ccc(1, achan_ir)
self.connect(lastblock, achan)
lastblock = achan
achan_2 = self._artificial_channel_2 = gr.fir_filter_ccc(
1, achan_ir)
self.connect(lastblock_2, achan_2)
lastblock_2 = achan_2
## Digital Amplifier
amp = self._amplifier = ofdm.multiply_const_ccf(1.0 / math.sqrt(2))
self.connect(lastblock, amp)
amp_2 = self._amplifier_2 = ofdm.multiply_const_ccf(1.0 / math.sqrt(2))
self.connect(lastblock_2, amp_2)
self.set_rms_amplitude(rms_amp)
if options.log:
log_to_file(self, amp, "data/amp_tx_out.compl")
log_to_file(self, amp_2, "data/amp_tx2_out.compl")
## Setup Output
self.connect(amp, (self, 0))
self.connect(amp_2, (self, 1))
# ------------------------------------------------------------------------ #
# Display some information about the setup
if config._verbose:
self._print_verbage()
def __init__(self, options):
gr.hier_block2.__init__(self, "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 = options.cp_length
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.bandwidth = options.bandwidth
config.gui_frame_rate = options.gui_frame_rate
config.fbmc = options.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.frame_data_part + \
config.training_data.no_pilotsyms
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)
# adapt OFDM frame rate and GUI display frame rate
self.keep_frame_n = int(1.0 / ( config.frame_length * (config.cp_length + config.fft_length) / config.bandwidth ) / config.gui_frame_rate)
## 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
test_allocation = [bitloading]*dsubc
bitloading_vec = [bitloading]*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_vec = [1]*config.data_subcarriers
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([1]*config.data_subcarriers,[1]*config.data_subcarriers)
self.allocation_src.set_allocation_scheme(0)
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")
## Bitmap Update Trigger for puncturing
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)
bmapsrc_stream_puncturing = [1]*dsubc + [2]*dsubc
bsrc_puncturing = self._bitmap_src_puncturing = blocks.vector_source_b(bmapsrc_stream_puncturing, True, dsubc)
if options.log and options.coding and not options.nopunct:
log_to_file(self, btrig_puncturing, "data/bitmap_trig_puncturing.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))
#log_to_file(self, mod, "data/mod_out.compl")
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")
# Standard Transmitter Parts
## Pilot subcarriers
psubc = self._pilot_subcarrier_inserter = pilot_subcarrier_inserter()
self.connect(pa,psubc)
if options.log:
log_to_file(self, psubc, "data/psubc_out.compl")
## Add virtual subcarriers
if config.fft_length > config.subcarriers:
vsubc = self._virtual_subcarrier_extender = \
vector_padding_dc_null(config.subcarriers, config.fft_length,config.dc_null)
self.connect(psubc,vsubc)
else:
vsubc = self._virtual_subcarrier_extender = psubc
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")
## Pilot blocks (preambles)
pblocks = self._pilot_block_inserter = pilot_block_inserter(5,False)
self.connect( ifft, pblocks )
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)
self.connect( pblocks, cp )
lastblock = cp
if options.log:
log_to_file(self, cp, "data/cp_out.compl")
#Digital Amplifier for resource allocation
#if not options.coding:
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
## 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)
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, fft_length, block_length, block_header, range, options):
gr.hier_block2.__init__(
self, "integer_fo_estimator",
gr.io_signature3(3, 3, gr.sizeof_gr_complex, gr.sizeof_float,
gr.sizeof_char),
gr.io_signature2(3, 3, gr.sizeof_float, gr.sizeof_char))
raise NotImplementedError, "Obsolete class"
self._range = range
# threshold after integer part frequency offset estimation
# if peak value below threshold, assume false triggering
self._thr_lo = 0.4 #0.19 # empirically found threshold. see ioe_metric.float
self._thr_hi = 0.4 #0.2
# stuff to be removed after bugfix for hierblock2s
self.input = gr.kludge_copy(gr.sizeof_gr_complex)
self.time_sync = gr.kludge_copy(gr.sizeof_char)
self.epsilon = (self, 1)
self.connect((self, 0), self.input)
self.connect((self, 2), self.time_sync)
delay(gr.sizeof_char, block_header.schmidl_fine_sync[0] * block_length)
# sample ofdm symbol (preamble 1 and 2)
sampler_symbol1 = vector_sampler(gr.sizeof_gr_complex, fft_length)
sampler_symbol2 = vector_sampler(gr.sizeof_gr_complex, fft_length)
time_delay1 = delay(gr.sizeof_char,
block_length * block_header.schmidl_fine_sync[1])
self.connect(self.input, (sampler_symbol1, 0))
self.connect(self.input, (sampler_symbol2, 0))
if block_header.schmidl_fine_sync[0] > 0:
time_delay0 = delay(
gr.sizeof_char,
block_length * block_header.schmidl_fine_sync[0])
self.connect(self.time_sync, time_delay0, (sampler_symbol1, 1))
else:
self.connect(self.time_sync, (sampler_symbol1, 1))
self.connect(self.time_sync, time_delay1, (sampler_symbol2, 1))
# negative fractional frequency offset estimate
epsilon = gr.multiply_const_ff(-1.0)
self.connect(self.epsilon, epsilon)
# compensate for fractional frequency offset on per symbol base
# freq_shift: vector length, modulator sensitivity
# freq_shift third input: reset phase accumulator
# symbol/preamble 1
freq_shift_sym1 = frequency_shift_vcc(fft_length, 1.0 / fft_length)
self.connect(sampler_symbol1, (freq_shift_sym1, 0))
self.connect(epsilon, (freq_shift_sym1, 1))
self.connect(gr.vector_source_b([1], True), (freq_shift_sym1, 2))
# symbol/preamble 2
freq_shift_sym2 = frequency_shift_vcc(fft_length, 1.0 / fft_length)
self.connect(sampler_symbol2, (freq_shift_sym2, 0))
self.connect(epsilon, (freq_shift_sym2, 1))
self.connect(gr.vector_source_b([1], True), (freq_shift_sym2, 2))
# fourier transfrom on both preambles
fft_sym1 = gr.fft_vcc(fft_length, True, [],
True) # Forward + Blockshift
fft_sym2 = gr.fft_vcc(fft_length, True, [],
True) # Forward + Blockshift
# calculate schmidl's metric for estimation of freq. offset's integer part
assert (hasattr(block_header, "schmidl_fine_sync"))
pre1 = block_header.pilotsym_fd[block_header.schmidl_fine_sync[0]]
pre2 = block_header.pilotsym_fd[block_header.schmidl_fine_sync[1]]
diff_pn = concatenate(
[[conjugate(math.sqrt(2) * pre2[2 * i] / pre1[2 * i]), 0.0j]
for i in arange(len(pre1) / 2)])
cfo_estimator = schmidl_cfo_estimator(fft_length, len(pre1),
self._range, diff_pn)
self.connect(freq_shift_sym1, fft_sym1,
(cfo_estimator, 0)) # preamble 1
self.connect(freq_shift_sym2, fft_sym2,
(cfo_estimator, 1)) # preamble 2
# search for maximum and its argument in interval [-range .. +range]
#arg_max = arg_max_vff(2*self._range + 1)
arg_max_s = gr.argmax_fs(2 * self._range + 1)
arg_max = gr.short_to_float()
ifo_max = gr.max_ff(2 * self._range + 1) # vlen
ifo_estimate = gr.add_const_ff(-self._range)
self.connect(cfo_estimator, arg_max_s, arg_max, ifo_estimate)
self.connect(cfo_estimator, ifo_max)
self.connect((arg_max_s, 1), gr.null_sink(gr.sizeof_short))
# threshold maximal value
ifo_threshold = gr.threshold_ff(self._thr_lo, self._thr_hi, 0.0)
ifo_thr_f2b = gr.float_to_char()
self.connect(ifo_max, ifo_threshold, ifo_thr_f2b)
# gating the streams ifo_estimate (integer part) and epsilon (frac. part)
# if the metric's peak value was above the chosen threshold, assume to have
# found a new burst. peak value below threshold results in blocking the
# streams
self.gate = gate_ff()
self.connect(ifo_thr_f2b, (self.gate, 0)) # threshold stream
self.connect(ifo_estimate, (self.gate, 1))
self.connect(epsilon, (self.gate, 2))
# peak filtering
# resynchronize and suppress peaks that didn't match a preamble
filtered_time_sync = peak_resync_bb(True) # replace
self.connect(self.time_sync, (filtered_time_sync, 0))
self.connect(ifo_thr_f2b, (filtered_time_sync, 1))
# find complete estimation for frequency offset
# add together fractional and integer part
freq_offset = gr.add_ff()
self.connect((self.gate, 1), gr.multiply_const_ff(-1.0),
(freq_offset, 0)) # integer offset
self.connect((self.gate, 2), (freq_offset, 1)) # frac offset
# output connections
self.connect(freq_offset, (self, 0))
self.connect(filtered_time_sync, (self, 1))
self.connect((self.gate, 0), (self, 2)) # used for frame trigger
#########################################
# debugging
if options.log:
self.epsilon2_sink = gr.vector_sink_f()
self.connect(epsilon, self.epsilon2_sink)
self.connect(
cfo_estimator,
gr.file_sink(gr.sizeof_float * (self._range * 2 + 1),
"data/ioe_metric.float"))
# output joint stream
preamble_stream = gr.streams_to_vector(
fft_length * gr.sizeof_gr_complex, 2)
self.connect(fft_sym1, (preamble_stream, 0))
self.connect(fft_sym2, (preamble_stream, 1))
self.connect(
preamble_stream,
gr.file_sink(gr.sizeof_gr_complex * 2 * fft_length,
"data/preambles.compl"))
# output, preambles before and after correction, magnitude and complex spectrum
self.connect(
sampler_symbol1, gr.fft_vcc(fft_length, True, [], True),
gr.file_sink(gr.sizeof_gr_complex * fft_length,
"data/pre1_bef.compl"))
self.connect(
sampler_symbol1, gr.fft_vcc(fft_length, True, [], True),
gr.complex_to_mag(fft_length),
gr.file_sink(gr.sizeof_float * fft_length,
"data/pre1_bef.float"))
self.connect(
sampler_symbol2, gr.fft_vcc(fft_length, True, [], True),
gr.file_sink(gr.sizeof_gr_complex * fft_length,
"data/pre2_bef.compl"))
self.connect(
sampler_symbol2, gr.fft_vcc(fft_length, True, [], True),
gr.complex_to_mag(fft_length),
gr.file_sink(gr.sizeof_float * fft_length,
"data/pre2_bef.float"))
self.connect(
freq_shift_sym1, gr.fft_vcc(fft_length, True, [], True),
gr.file_sink(gr.sizeof_gr_complex * fft_length,
"data/pre1.compl"))
self.connect(
freq_shift_sym1, gr.fft_vcc(fft_length, True, [], True),
gr.complex_to_mag(fft_length),
gr.file_sink(gr.sizeof_float * fft_length, "data/pre1.float"))
self.connect(
freq_shift_sym2, gr.fft_vcc(fft_length, True, [], True),
gr.file_sink(gr.sizeof_gr_complex * fft_length,
"data/pre2.compl"))
self.connect(
freq_shift_sym2, gr.fft_vcc(fft_length, True, [], True),
gr.complex_to_mag(fft_length),
gr.file_sink(gr.sizeof_float * fft_length, "data/pre2.float"))
# calculate epsilon from corrected source to check function
test_cp = cyclic_prefixer(fft_length, block_length)
test_eps = foe(fft_length)
self.connect(freq_shift_sym1, test_cp, test_eps,
gr.file_sink(gr.sizeof_float, "data/eps_after.float"))
try:
gr.hier_block.update_var_names(self, "ifo_estimator", vars())
gr.hier_block.update_var_names(self, "ifo_estimator", vars(self))
except:
pass
def __init__(self, options):
gr.hier_block2.__init__(self, "transmit_path",
gr.io_signature(0,0,0),
gr.io_signature(2,2,gr.sizeof_gr_complex))
common_options.defaults(options)
config = self.config = station_configuration()
config.data_subcarriers = options.subcarriers
config.cp_length = options.cp_length
config.frame_data_blocks = options.data_blocks
config._verbose = options.verbose
config.fft_length = options.fft_length
config.training_data = default_block_header(config.data_subcarriers,
config.fft_length,options)
config.tx_station_id = options.station_id
config.coding = options.coding
if config.tx_station_id is None:
raise SystemError, "Station ID not set"
config.frame_id_blocks = 1 # FIXME
# digital rms amplitude sent to USRP
rms_amp = options.rms_amplitude
self._options = copy.copy(options)
self.servants = [] # FIXME
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.frame_data_part + \
config.training_data.no_pilotsyms
config.subcarriers = config.data_subcarriers + \
config.training_data.pilot_subcarriers
config.virtual_subcarriers = config.fft_length - config.subcarriers
# 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)
## Control Part
if options.debug:
self._control = ctrl = static_tx_control(options)
print "Statix TX Control used"
else:
self._control = ctrl = corba_tx_control(options)
print "CORBA TX Control used"
id_src = (ctrl,0)
mux_src = (ctrl,1)
map_src = self._map_src = (ctrl,2)
pa_src = (ctrl,3)
if options.log:
id_src_f = gr.short_to_float()
self.connect(id_src,id_src_f)
log_to_file(self, id_src_f, "data/id_src_out.float")
mux_src_f = gr.short_to_float()
self.connect(mux_src,mux_src_f)
log_to_file(self, mux_src_f, "data/mux_src_out.float")
map_src_s = blocks.vector_to_stream(gr.sizeof_char,config.data_subcarriers)
map_src_f = gr.char_to_float()
self.connect(map_src,map_src_s,map_src_f)
##log_to_file(self, map_src_f, "data/map_src.float")
##log_to_file(self, pa_src, "data/pa_src_out.float")
## 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")
## Bitmap Update Trigger
# TODO
#bmaptrig_stream = concatenate([[1, 2],[0]*(config.frame_data_part-7)])
bmaptrig_stream = concatenate([[1, 1],[0]*(config.frame_data_part-2)])
print"bmaptrig_stream = ",bmaptrig_stream
btrig = self._bitmap_trigger = blocks.vector_source_b(bmaptrig_stream.tolist(), True)
if options.log:
log_to_file(self, btrig, "data/bitmap_trig.char")
## Bitmap Update Trigger for puncturing
# TODO
if not options.nopunct:
#bmaptrig_stream_puncturing = concatenate([[1],[0]*(config.frame_data_part-2)])
bmaptrig_stream_puncturing = concatenate([[1],[0]*(config.frame_data_blocks/2-1)])
btrig_puncturing = self._bitmap_trigger_puncturing = blocks.vector_source_b(bmaptrig_stream_puncturing.tolist(), True)
bmapsrc_stream_puncturing = concatenate([[1]*dsubc,[2]*dsubc])
bsrc_puncturing = self._bitmap_src_puncturing = blocks.vector_source_b(bmapsrc_stream_puncturing.tolist(), True, dsubc)
if options.log and options.coding and not options.nopunct:
log_to_file(self, btrig_puncturing, "data/bitmap_trig_puncturing.char")
## Frame Trigger
# TODO
ftrig_stream = concatenate([[1],[0]*(config.frame_data_part-1)])
ftrig = self._frame_trigger = blocks.vector_source_b(ftrig_stream.tolist(),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_src,(dmux,0))
self.connect(id_enc,(dmux,1))
self._data_multiplexer_nextport = 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,options.coding)
self.connect(dmux,(mod,0))
self.connect(map_src,(mod,1))
self.connect(btrig,(mod,2))
if options.log:
log_to_file(self, mod, "data/mod_out.compl")
modi = gr.complex_to_imag(config.data_subcarriers)
modr = gr.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
if options.debug:
## static
pa = self._power_allocator = power_allocator(config.data_subcarriers)
self.connect(mod,(pa,0))
self.connect(pa_src,(pa,1))
else:
## with CORBA control event channel
ns_ip = ctrl.ns_ip
ns_port = ctrl.ns_port
evchan = ctrl.evchan
pa = self._power_allocator = corba_power_allocator(dsubc, \
evchan, ns_ip, ns_port, True)
self.connect(mod,(pa,0))
self.connect(id_src,(pa,1))
self.connect(ftrig,(pa,2))
if options.log:
log_to_file(self, pa, "data/pa_out.compl")
## Pilot subcarriers
psubc = self._pilot_subcarrier_inserter = pilot_subcarrier_inserter()
self.connect( pa ,psubc )
pilot_subc = config.training_data.shifted_pilot_tones;
print "pilot_subc", pilot_subc
stc = stc_encoder( config.subcarriers, config.frame_data_blocks, pilot_subc )
self.connect(psubc, stc)
if options.log:
log_to_file(self, psubc, "data/psubc_out.compl")
log_to_file(self, psubc_2, "data/psubc2_out.compl")
log_to_file(self, pa, "data/pa.compl")
log_to_file(self, ( stc, 0 ), "data/stc_0.compl")
log_to_file(self, ( stc, 1 ), "data/stc_1.compl")
## Add virtual subcarriers
if config.fft_length > config.subcarriers:
vsubc = self._virtual_subcarrier_extender = \
vector_padding(config.subcarriers, config.fft_length)
self.connect(stc,vsubc)
vsubc_2 = self._virtual_subcarrier_extender_2 = \
vector_padding(config.subcarriers, config.fft_length)
self.connect((stc,1),vsubc_2)
else:
vsubc = self._virtual_subcarrier_extender = psubc
vsubc_2 = self._virtual_subcarrier_extender_2 = psubc_2
log_to_file(self, psubc, "data/psubc.compl")
log_to_file(self, stc, "data/stc1.compl")
log_to_file(self, (stc,1), "data/stc2.compl")
if options.log:
log_to_file(self, vsubc, "data/vsubc_out.compl")
log_to_file(self, vsubc_2, "data/vsubc2_out.compl")
## IFFT, no window, block shift
ifft = self._ifft = fft_blocks.fft_vcc(config.fft_length,False,[],True)
self.connect(vsubc,ifft)
ifft_2 = self._ifft_2 = fft_blocks.fft_vcc(config.fft_length,False,[],True)
self.connect(vsubc_2,ifft_2)
if options.log:
log_to_file(self, ifft, "data/ifft_out.compl")
log_to_file(self, ifft_2, "data/ifft2_out.compl")
## Pilot blocks (preambles)
pblocks = self._pilot_block_inserter = pilot_block_inserter(1, False)
self.connect( ifft, pblocks )
pblocks_2 = self._pilot_block_inserter_2 = pilot_block_inserter( 2, False)
self.connect( ifft_2, pblocks_2 )
if options.log:
log_to_file(self, pblocks, "data/pilot_block_ins_out.compl")
log_to_file(self, pblocks_2, "data/pilot_block_ins2_out.compl")
## Cyclic Prefix
cp = self._cyclic_prefixer = cyclic_prefixer(config.fft_length,
config.block_length)
self.connect( pblocks, cp )
cp_2 = self._cyclic_prefixer_2 = cyclic_prefixer(config.fft_length,
config.block_length)
self.connect( pblocks_2, cp_2 )
lastblock = cp
lastblock_2 = cp_2
if options.log:
log_to_file(self, cp, "data/cp_out.compl")
log_to_file(self, cp_2, "data/cp2_out.compl")
if options.cheat:
## Artificial Channel
# kept to compare with previous system
achan_ir = concatenate([[1.0],[0.0]*(config.cp_length-1)])
achan = self._artificial_channel = gr.fir_filter_ccc(1,achan_ir)
self.connect( lastblock, achan )
lastblock = achan
achan_2 = self._artificial_channel_2 = gr.fir_filter_ccc(1,achan_ir)
self.connect( lastblock_2, achan_2 )
lastblock_2 = achan_2
## Digital Amplifier
amp = self._amplifier = ofdm.multiply_const_ccf( 1.0/math.sqrt(2) )
self.connect( lastblock, amp )
amp_2 = self._amplifier_2 = ofdm.multiply_const_ccf( 1.0/math.sqrt(2) )
self.connect( lastblock_2, amp_2 )
self.set_rms_amplitude(rms_amp)
if options.log:
log_to_file(self, amp, "data/amp_tx_out.compl")
log_to_file(self, amp_2, "data/amp_tx2_out.compl")
## Setup Output
self.connect(amp,(self,0))
self.connect(amp_2,(self,1))
# ------------------------------------------------------------------------ #
# Display some information about the setup
if config._verbose:
self._print_verbage()