def test_stretch_01(self):
tb = self.tb
data = 10*[1,]
data0 = [x / 20.0 for x in data]
data1 = [x / 10.0 for x in data]
expected_result0 = 10*[0.05,]
expected_result1 = 10*[0.1,]
src0 = blocks.vector_source_f(data0, False)
src1 = blocks.vector_source_f(data1, False)
inter = blocks.streams_to_vector(gr.sizeof_float, 2)
op = blocks.stretch_ff(0.1, 2)
deinter = blocks.vector_to_streams(gr.sizeof_float, 2)
dst0 = blocks.vector_sink_f()
dst1 = blocks.vector_sink_f()
tb.connect(src0, (inter,0))
tb.connect(src1, (inter,1))
tb.connect(inter, op)
tb.connect(op, deinter)
tb.connect((deinter,0), dst0)
tb.connect((deinter,1), dst1)
tb.run()
dst0_data = dst0.data()
dst1_data = dst1.data()
self.assertFloatTuplesAlmostEqual(expected_result0, dst0_data, 4)
self.assertFloatTuplesAlmostEqual(expected_result1, dst1_data, 4)
def __init__(self, n_chans, n_filterbanks=1, taps=None, outchans=None,
atten=100, bw=1.0, tb=0.2, ripple=0.1):
if n_filterbanks > n_chans:
n_filterbanks = n_chans
if outchans is None:
outchans = list(range(n_chans))
gr.hier_block2.__init__(
self, "pfb_channelizer_hier_ccf",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(len(outchans), len(outchans), gr.sizeof_gr_complex))
if taps is None:
taps = optfir.low_pass(1, n_chans, bw, bw+tb, ripple, atten)
taps = list(taps)
extra_taps = int(math.ceil(1.0*len(taps)/n_chans)*n_chans - len(taps))
taps = taps + [0] * extra_taps
# Make taps for each channel
chantaps = [list(reversed(taps[i: len(taps): n_chans])) for i in range(0, n_chans)]
# Convert the input stream into a stream of vectors.
self.s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, n_chans)
# Create a mapping to separate out each filterbank (a group of channels to be processed together)
# And a list of sets of taps for each filterbank.
low_cpp = int(n_chans / n_filterbanks)
extra = n_chans - low_cpp*n_filterbanks
cpps = [low_cpp+1]*extra + [low_cpp]*(n_filterbanks-extra)
splitter_mapping = []
filterbanktaps = []
total = 0
for cpp in cpps:
splitter_mapping.append([(0, i) for i in range(total, total+cpp)])
filterbanktaps.append(chantaps[total: total+cpp])
total += cpp
assert(total == n_chans)
# Split the stream of vectors in n_filterbanks streams of vectors.
self.splitter = blocks.vector_map(gr.sizeof_gr_complex, [n_chans], splitter_mapping)
# Create the filterbanks
self.fbs = [filter.filterbank_vcvcf(taps) for taps in filterbanktaps]
# Combine the streams of vectors back into a single stream of vectors.
combiner_mapping = [[]]
for i, cpp in enumerate(cpps):
for j in range(cpp):
combiner_mapping[0].append((i, j))
self.combiner = blocks.vector_map(gr.sizeof_gr_complex, cpps, combiner_mapping)
# Add the final FFT to the channelizer.
self.fft = fft.fft_vcc(n_chans, forward=True, window=[1.0]*n_chans)
# Select the desired channels
if outchans != list(range(n_chans)):
selector_mapping = [[(0, i) for i in outchans]]
self.selector = blocks.vector_map(gr.sizeof_gr_complex, [n_chans], selector_mapping)
# Convert stream of vectors to a normal stream.
self.v2ss = blocks.vector_to_streams(gr.sizeof_gr_complex, len(outchans))
self.connect(self, self.s2v, self.splitter)
for i in range(0, n_filterbanks):
self.connect((self.splitter, i), self.fbs[i], (self.combiner, i))
self.connect(self.combiner, self.fft)
if outchans != list(range(n_chans)):
self.connect(self.fft, self.selector, self.v2ss)
else:
self.connect(self.fft, self.v2ss)
for i in range(0, len(outchans)):
self.connect((self.v2ss, i), (self, i))
def test_stretch_01(self):
tb = self.tb
data = 10*[1,]
data0 = map(lambda x: x/20.0, data)
data1 = map(lambda x: x/10.0, data)
expected_result0 = 10*[0.05,]
expected_result1 = 10*[0.1,]
src0 = blocks.vector_source_f(data0, False)
src1 = blocks.vector_source_f(data1, False)
inter = blocks.streams_to_vector(gr.sizeof_float, 2)
op = blocks.stretch_ff(0.1, 2)
deinter = blocks.vector_to_streams(gr.sizeof_float, 2)
dst0 = blocks.vector_sink_f()
dst1 = blocks.vector_sink_f()
tb.connect(src0, (inter,0))
tb.connect(src1, (inter,1))
tb.connect(inter, op)
tb.connect(op, deinter)
tb.connect((deinter,0), dst0)
tb.connect((deinter,1), dst1)
tb.run()
dst0_data = dst0.data()
dst1_data = dst1.data()
self.assertFloatTuplesAlmostEqual(expected_result0, dst0_data, 4)
self.assertFloatTuplesAlmostEqual(expected_result1, dst1_data, 4)
def __init__(self, n_chans, n_filterbanks=1, taps=None, outchans=None,
atten=100, bw=1.0, tb=0.2, ripple=0.1):
if n_filterbanks > n_chans:
n_filterbanks = n_chans
if outchans is None:
outchans = range(n_chans)
gr.hier_block2.__init__(
self, "pfb_channelizer_hier_ccf",
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(len(outchans), len(outchans), gr.sizeof_gr_complex))
if taps is None:
taps = optfir.low_pass(1, n_chans, bw, bw+tb, ripple, atten)
taps = list(taps)
extra_taps = int(math.ceil(1.0*len(taps)/n_chans)*n_chans - len(taps))
taps = taps + [0] * extra_taps
# Make taps for each channel
chantaps = [list(reversed(taps[i: len(taps): n_chans])) for i in range(0, n_chans)]
# Convert the input stream into a stream of vectors.
self.s2v = blocks.stream_to_vector(gr.sizeof_gr_complex, n_chans)
# Create a mapping to separate out each filterbank (a group of channels to be processed together)
# And a list of sets of taps for each filterbank.
low_cpp = int(n_chans/n_filterbanks)
extra = n_chans - low_cpp*n_filterbanks
cpps = [low_cpp+1]*extra + [low_cpp]*(n_filterbanks-extra)
splitter_mapping = []
filterbanktaps = []
total = 0
for cpp in cpps:
splitter_mapping.append([(0, i) for i in range(total, total+cpp)])
filterbanktaps.append(chantaps[total: total+cpp])
total += cpp
assert(total == n_chans)
# Split the stream of vectors in n_filterbanks streams of vectors.
self.splitter = blocks.vector_map(gr.sizeof_gr_complex, [n_chans], splitter_mapping)
# Create the filterbanks
self.fbs = [filter.filterbank_vcvcf(taps) for taps in filterbanktaps]
# Combine the streams of vectors back into a single stream of vectors.
combiner_mapping = [[]]
for i, cpp in enumerate(cpps):
for j in range(cpp):
combiner_mapping[0].append((i, j))
self.combiner = blocks.vector_map(gr.sizeof_gr_complex, cpps, combiner_mapping)
# Add the final FFT to the channelizer.
self.fft = fft.fft_vcc(n_chans, forward=True, window=[1.0]*n_chans)
# Select the desired channels
if outchans != range(n_chans):
selector_mapping = [[(0, i) for i in outchans]]
self.selector = blocks.vector_map(gr.sizeof_gr_complex, [n_chans], selector_mapping)
# Convert stream of vectors to a normal stream.
self.v2ss = blocks.vector_to_streams(gr.sizeof_gr_complex, len(outchans))
self.connect(self, self.s2v, self.splitter)
for i in range(0, n_filterbanks):
self.connect((self.splitter, i), self.fbs[i], (self.combiner, i))
self.connect(self.combiner, self.fft)
if outchans != range(n_chans):
self.connect(self.fft, self.selector, self.v2ss)
else:
self.connect(self.fft, self.v2ss)
for i in range(0, len(outchans)):
self.connect((self.v2ss, i), (self, i))
def __init__(self, sample_rate, amplitude):
gr.hier_block2.__init__(
self,
"gsm_source_c",
gr.io_signature(0, 0, 0), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
self._symb_rate = 13e6 / 48
self._samples_per_symbol = 2
self._data = blocks.vector_source_b(self.gen_gsm_seq(), True, 2)
self._split = blocks.vector_to_streams(gr.sizeof_char * 1, 2)
self._pack = blocks.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST)
self._mod = digital.gmsk_mod(self._samples_per_symbol, bt=0.35)
self._pwr_f = blocks.char_to_float(1, 1)
self._pwr_c = blocks.float_to_complex(1)
self._pwr_w = blocks.repeat(gr.sizeof_gr_complex * 1,
self._samples_per_symbol)
self._mul = blocks.multiply_vcc(1)
self._interpolate = filter.fractional_resampler_cc(
0, (self._symb_rate * self._samples_per_symbol) / sample_rate)
self._scale = blocks.multiply_const_cc(amplitude)
self.connect(self._data, self._split)
self.connect((self._split, 0), self._pack, self._mod, (self._mul, 0))
self.connect((self._split, 1), self._pwr_f, self._pwr_c, self._pwr_w,
(self._mul, 1))
self.connect(self._mul, self._interpolate, self._scale, self)
def __init__(self, sample_rate, amplitude):
gr.hier_block2.__init__(self, "gsm_source_c",
gr.io_signature(0, 0, 0), # Input signature
gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature
self._symb_rate = 13e6 / 48;
self._samples_per_symbol = 2
self._data = blocks.vector_source_b(self.gen_gsm_seq(), True, 2)
self._split = blocks.vector_to_streams(gr.sizeof_char*1, 2)
self._pack = blocks.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST)
self._mod = digital.gmsk_mod(self._samples_per_symbol, bt=0.35)
self._pwr_f = blocks.char_to_float(1, 1)
self._pwr_c = blocks.float_to_complex(1)
self._pwr_w = blocks.repeat(gr.sizeof_gr_complex*1, self._samples_per_symbol)
self._mul = blocks.multiply_vcc(1)
self._interpolate = filter.fractional_resampler_cc( 0,
(self._symb_rate * self._samples_per_symbol) / sample_rate )
self._scale = blocks.multiply_const_cc(amplitude)
self.connect(self._data, self._split)
self.connect((self._split, 0), self._pack, self._mod, (self._mul, 0))
self.connect((self._split, 1), self._pwr_f, self._pwr_c, self._pwr_w, (self._mul, 1))
self.connect(self._mul, self._interpolate, self._scale, self)
def __init__(self):
gr.top_block.__init__(self, "Top Block")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 1e3
##################################################
# Message Queues
##################################################
#blocks_message_sink_0_msgq_out = blocks_message_source_0_msgq_in = gr.msg_queue(2)
self.blocks_message_source_0_msgq_in = gr.msg_queue()
##################################################
# Blocks
##################################################
self.blocks_vector_to_streams_0 = blocks.vector_to_streams(
gr.sizeof_char * 1, 4)
#self.blocks_vector_source_x_0 = blocks.vector_source_b((1, 0, 0, 1), True, 4, [])
self.blocks_uchar_to_float_0_2 = blocks.uchar_to_float()
self.blocks_uchar_to_float_0_1 = blocks.uchar_to_float()
self.blocks_uchar_to_float_0_0 = blocks.uchar_to_float()
self.blocks_uchar_to_float_0 = blocks.uchar_to_float()
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_float * 1,
samp_rate, True)
self.blocks_message_source_0 = blocks.message_source(
gr.sizeof_char * 4, self.blocks_message_source_0_msgq_in)
#self.blocks_message_source_0.message_port_register_in(pmt.pmt_intern("input_port"))
#self.blocks_message_sink_0 = blocks.message_sink(gr.sizeof_char*4, blocks_message_sink_0_msgq_out, False)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float * 1,
"simple.float", False)
self.blocks_file_sink_0.set_unbuffered(False)
self.blocks_add_xx_0 = blocks.add_vff(1)
##################################################
# Connections
##################################################
self.connect((self.blocks_add_xx_0, 0), (self.blocks_throttle_0, 0))
self.connect((self.blocks_message_source_0, 0),
(self.blocks_vector_to_streams_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.blocks_uchar_to_float_0, 0),
(self.blocks_add_xx_0, 3))
self.connect((self.blocks_uchar_to_float_0_0, 0),
(self.blocks_add_xx_0, 2))
self.connect((self.blocks_uchar_to_float_0_1, 0),
(self.blocks_add_xx_0, 1))
self.connect((self.blocks_uchar_to_float_0_2, 0),
(self.blocks_add_xx_0, 0))
#self.connect((self.blocks_vector_source_x_0, 0), (self.blocks_message_sink_0, 0))
self.connect((self.blocks_vector_to_streams_0, 3),
(self.blocks_uchar_to_float_0, 0))
self.connect((self.blocks_vector_to_streams_0, 2),
(self.blocks_uchar_to_float_0_0, 0))
self.connect((self.blocks_vector_to_streams_0, 1),
(self.blocks_uchar_to_float_0_1, 0))
self.connect((self.blocks_vector_to_streams_0, 0),
(self.blocks_uchar_to_float_0_2, 0))
def __init__(self):
gr.hier_block2.__init__(self,
"bch_viterbi_vfvb",
gr.io_signature(1, 1, gr.sizeof_float * 120), # Input signature
gr.io_signature(1, 1, gr.sizeof_char * 40)) # Output signature
# Define blocks and connect them
# Repeat input vector one time to get viterbi decoder state right (tail-biting stuff)
#self.rpt = blocks.repeat(gr.sizeof_float * 120, 2)
# viterbi decoder requires stream as input
#self.vtos = blocks.vector_to_stream(1 * gr.sizeof_float, 120)
# self.vtss = blocks.vector_to_streams(1* gr.sizeof_float, 120, "bch_viterbi_vector_to_streams_0")
self.vtss = blocks.vector_to_streams(1* gr.sizeof_float, 120)
#self.app = blocks.streams_to_stream(1* gr.sizeof_float, 138, "bch_viterbi_streams_to_stream_0")
self.app = blocks.streams_to_stream(1* gr.sizeof_float, 138)
self.connect(self, self.vtss)
for i in range(18):
self.connect( (self.vtss, 120-18+i), (self.app, i) )
for i in range(120):
self.connect( (self.vtss, i), (self.app, i+18) )
# Correct FSM instantiation: k=num_input_bits, n=num_output_bits, Tuple[dim(k*n)] (decimal notation)
self.fsm = trellis.fsm(1, 3, [91, 121, 117])
# Values for viterbi decoder
K = 46 # steps for one coding block
SO = 0 # initial state
SK = -1 # final state (in this case unknown, therefore -1)
D = 3 # dimensionality
# D = 3 follows from the fact that 1 {0,1} input symbol of the encoder produces 3 {0,1} output symbols.
# (packed into one byte {0,1,...,7} )
# with NRZ coding follows:
# 0 --> 1
# 1 --> -1
# This leads to the following constellation input
# | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
constellation = [1, 1, 1, 1, 1, -1, 1, -1, 1, 1, -1, -1, -1, 1, 1, -1, 1, -1, -1, -1, 1, -1, -1, -1]
# print "len(constellation)/D = " + str(len(constellation)/D) + "\tfsm.O = " + str(self.fsm.O())
# Viterbi_combined input: FSM, K, SO, SK, D, TABLE, TYPE
# FSM = Finite State Machine
# K = number of output symbols produced by the FSM
# SO = initial state of the FSM
# SK = final state of the FSM (unknown in this example)
# D = dimensionality
# TABLE = constellation of the input symbols
# self.vit = trellis.viterbi_combined_fb(self.fsm, K, SO, SK, D, constellation, 200, "bch_viterbi_combined_fb_0")
self.vit = trellis.viterbi_combined_fb(self.fsm, K, SO, SK, D, constellation, 200)
self.connect(self.app, self.vit)
# connect all streams which are crated yet
#self.connect(self,self.rpt,self.vtos,self.vit)
# self.keep = blocks.keep_m_in_n(gr.sizeof_char, 40, 46, 6, "bch_viterbi_keep_m_in_n_0")
self.keep = blocks.keep_m_in_n(gr.sizeof_char, 40, 46, 6)
# self.tovec = blocks.stream_to_vector(1, 40, "bch_viterbi_stream_to_vector_0")
self.tovec = blocks.stream_to_vector(1, 40)
self.connect(self.vit, self.keep, self.tovec, self)
def __rebuild(self):
if self.__signal_type.is_analytic():
input_length = self.__freq_resolution
output_length = self.__freq_resolution
self.__after_fft = None
else:
# use vector_to_streams to cut the output in half and discard the redundant part
input_length = self.__freq_resolution * 2
output_length = self.__freq_resolution
self.__after_fft = blocks.vector_to_streams(
itemsize=output_length * gr.sizeof_float, nstreams=2)
sample_rate = self.__signal_type.get_sample_rate()
overlap_factor = int(
math.ceil(_maximum_fft_rate * input_length / sample_rate))
# sanity limit -- OverlapGimmick is not free
overlap_factor = min(16, overlap_factor)
self.__gate = blocks.copy(gr.sizeof_gr_complex)
self.__gate.set_enabled(not self.__paused)
self.__fft_sink = MessageDistributorSink(
itemsize=output_length * gr.sizeof_char,
context=self.__context,
migrate=self.__fft_sink,
notify=self.__update_interested)
self.__overlapper = _OverlapGimmick(size=input_length,
factor=overlap_factor,
itemsize=self.__itemsize)
# Adjusts units so displayed level is independent of resolution and sample rate. Also throw in the packing offset
compensation = to_dB(input_length / sample_rate) + self.__power_offset
# TODO: Consider not using the logpwrfft block
self.__logpwrfft = logpwrfft.logpwrfft_c(
sample_rate=sample_rate * overlap_factor,
fft_size=input_length,
ref_scale=10.0**(-compensation / 20.0) *
2, # not actually using this as a reference scale value but avoiding needing to use a separate add operation to apply the unit change -- this expression is the inverse of what logpwrfft does internally
frame_rate=self.__frame_rate,
avg_alpha=1.0,
average=False)
# It would make slightly more sense to use unsigned chars, but blocks.float_to_uchar does not support vlen.
self.__fft_converter = blocks.float_to_char(
vlen=self.__freq_resolution, scale=1.0)
self.__scope_sink = MessageDistributorSink(
itemsize=self.__time_length * gr.sizeof_gr_complex,
context=self.__context,
migrate=self.__scope_sink,
notify=self.__update_interested)
self.__scope_chunker = blocks.stream_to_vector_decimator(
item_size=gr.sizeof_gr_complex,
sample_rate=sample_rate,
vec_rate=self.__frame_rate, # TODO doesn't need to be coupled
vec_len=self.__time_length)
def __init__(self):
gr.hier_block2.__init__(
self,
"bch_viterbi_vfvb",
gr.io_signature(1, 1, gr.sizeof_float * 120), # Input signature
gr.io_signature(1, 1, gr.sizeof_char * 40)) # Output signature
# Define blocks and connect them
# Repeat input vector one time to get viterbi decoder state right (tail-biting stuff)
#self.rpt = blocks.repeat(gr.sizeof_float * 120, 2)
# viterbi decoder requires stream as input
#self.vtos = blocks.vector_to_stream(1 * gr.sizeof_float, 120)
self.vtss = blocks.vector_to_streams(1 * gr.sizeof_float, 120)
self.app = blocks.streams_to_stream(1 * gr.sizeof_float, 138)
self.connect(self, self.vtss)
for i in range(18):
self.connect((self.vtss, 120 - 18 + i), (self.app, i))
for i in range(120):
self.connect((self.vtss, i), (self.app, i + 18))
# Correct FSM instantiation: k=num_input_bits, n=num_output_bits, Tuple[dim(k*n)] (decimal notation)
self.fsm = trellis.fsm(1, 3, [91, 121, 117])
# Values for viterbi decoder
K = 46 # steps for one coding block
SO = 0 # initial state
SK = -1 # final state (in this case unknown, therefore -1)
D = 3 # dimensionality
# D = 3 follows from the fact that 1 {0,1} input symbol of the encoder produces 3 {0,1} output symbols.
# (packed into one byte {0,1,...,7} )
# with NRZ coding follows:
# 0 --> 1
# 1 --> -1
# This leads to the following constellation input
# | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
constellation = [
1, 1, 1, 1, 1, -1, 1, -1, 1, 1, -1, -1, -1, 1, 1, -1, 1, -1, -1,
-1, 1, -1, -1, -1
]
# print "len(constellation)/D = " + str(len(constellation)/D) + "\tfsm.O = " + str(self.fsm.O())
# Viterbi_combined input: FSM, K, SO, SK, D, TABLE, TYPE
# FSM = Finite State Machine
# K = number of output symbols produced by the FSM
# SO = initial state of the FSM
# SK = final state of the FSM (unknown in this example)
# D = dimensionality
# TABLE = constellation of the input symbols
self.vit = trellis.viterbi_combined_fb(self.fsm, K, SO, SK, D,
constellation, 200)
self.connect(self.app, self.vit)
# connect all streams which are crated yet
#self.connect(self,self.rpt,self.vtos,self.vit)
self.keep = blocks.keep_m_in_n(gr.sizeof_char, 40, 46, 6)
self.tovec = blocks.stream_to_vector(1, 40)
self.connect(self.vit, self.keep, self.tovec, self)
def __do_connect(self, reason):
# log.msg(u'receiver do_connect: %s' % (reason,))
self.context.lock()
try:
self.disconnect_all()
# Connect input of demodulator
if self.__demod_tunable:
self.connect(self, self.__demodulator)
else:
self.connect(self, self.__rotator, self.__demodulator)
if self.__demod_output:
# Construct stereo-to-mono conversion (used at least for level probe)
if self.__demod_stereo:
splitter = blocks.vector_to_streams(gr.sizeof_float, 2)
mono_audio = blocks.multiply_matrix_ff(((0.5, 0.5),))
self.connect(self.__demodulator, splitter)
self.connect((splitter, 0), (mono_audio, 0))
self.connect((splitter, 1), (mono_audio, 1))
else:
mono_audio = self.__demodulator
# Connect mono audio to level probe
self.connect(mono_audio, self.probe_audio)
# Connect demodulator to output gain control, converting as needed
if (self.__audio_channels == 2) == self.__demod_stereo:
# stereo to stereo or mono to mono
self.connect(self.__demodulator, self.__audio_gain_block)
elif self.__audio_channels == 2 and not self.__demod_stereo:
# mono to stereo
duplicator = blocks.streams_to_vector(gr.sizeof_float, 2)
self.connect(self.__demodulator, (duplicator, 0))
self.connect(self.__demodulator, (duplicator, 1))
self.connect(duplicator, self.__audio_gain_block)
elif self.__audio_channels == 1 and self.__demod_stereo:
# stereo to mono
self.connect(mono_audio, self.__audio_gain_block)
else:
raise Exception('shouldn\'t happen')
# Connect gain control to output of receiver
self.connect(self.__audio_gain_block, self)
else:
# Dummy output, ignored by containing block
self.connect(
blocks.vector_source_f([], vlen=self.__audio_channels),
self)
if self.__output_type != self.__last_output_type:
self.__last_output_type = self.__output_type
self.context.changed_needed_connections(u'changed output type')
finally:
self.context.unlock()
def __init__(self, mode, input_rate, output_rate, demod_class=None, freq=0.0, quiet=False):
gr.hier_block2.__init__(
self, type(self).__name__,
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(2, 2, gr.sizeof_float))
if demod_class is None:
mode_def = lookup_mode(mode)
if mode_def is None:
raise Exception('{}: No demodulator registered for mode {!r}, only {!r}'.format(
type(self).__name__, mode, [md.mode for md in get_modes()]))
demod_class = mode_def.demod_class
context = _DemodulatorAdapterContext(adapter=self, freq=freq)
demod = self.__demodulator = IDemodulator(demod_class(
mode=mode,
input_rate=input_rate,
context=context))
self.connect(self, demod)
output_type = demod.get_output_type()
demod_output_rate = output_type.get_sample_rate()
same_rate = demod_output_rate == output_rate
stereo = output_type.get_kind() == 'STEREO'
# connect outputs, resampling and adapting mono/stereo as needed
# TODO: Make the logic for this in receiver.py reusable?
if output_type.get_kind() == 'NONE':
# TODO: produce correct sample rate of zeroes and maybe a warning
dummy = blocks.vector_source_f([])
self.connect(dummy, (self, 0))
self.connect(dummy, (self, 1))
else:
if stereo:
splitter = blocks.vector_to_streams(gr.sizeof_float, 2)
self.connect(demod, splitter)
if same_rate:
if stereo:
self.connect((splitter, 0), (self, 0))
self.connect((splitter, 1), (self, 1))
else:
self.connect(demod, (self, 0))
self.connect(demod, (self, 1))
else:
if not quiet:
gr.log.info(b'{}: Native {} demodulated rate is {}; resampling to {}'.format(
type(self).__name__, mode, demod_output_rate, output_rate))
if stereo:
self.connect((splitter, 0), make_resampler(demod_output_rate, output_rate), (self, 0))
self.connect((splitter, 1), make_resampler(demod_output_rate, output_rate), (self, 1))
else:
resampler = make_resampler(demod_output_rate, output_rate)
self.connect(demod, resampler, (self, 0))
self.connect(resampler, (self, 1))
def __init__(self, mode, input_rate, output_rate, demod_class=None, freq=0.0, quiet=False):
gr.hier_block2.__init__(
self, type(self).__name__,
gr.io_signature(1, 1, gr.sizeof_gr_complex),
gr.io_signature(2, 2, gr.sizeof_float))
if demod_class is None:
mode_def = lookup_mode(mode)
if mode_def is None:
raise Exception('{}: No demodulator registered for mode {!r}, only {!r}'.format(
type(self).__name__, mode, [md.mode for md in get_modes()]))
demod_class = mode_def.demod_class
context = _DemodulatorAdapterContext(adapter=self, freq=freq)
demod = self.__demodulator = IDemodulator(demod_class(
mode=mode,
input_rate=input_rate,
context=context))
self.connect(self, demod)
output_type = demod.get_output_type()
demod_output_rate = output_type.get_sample_rate()
same_rate = demod_output_rate == output_rate
stereo = output_type.get_kind() == 'STEREO'
# connect outputs, resampling and adapting mono/stereo as needed
# TODO: Make the logic for this in receiver.py reusable?
if output_type.get_kind() == 'NONE':
# TODO: produce correct sample rate of zeroes and maybe a warning
dummy = blocks.vector_source_f([])
self.connect(dummy, (self, 0))
self.connect(dummy, (self, 1))
else:
if stereo:
splitter = blocks.vector_to_streams(gr.sizeof_float, 2)
self.connect(demod, splitter)
if same_rate:
if stereo:
self.connect((splitter, 0), (self, 0))
self.connect((splitter, 1), (self, 1))
else:
self.connect(demod, (self, 0))
self.connect(demod, (self, 1))
else:
if not quiet:
gr.log.info('{}: Native {} demodulated rate is {}; resampling to {}'.format(
type(self).__name__, mode, demod_output_rate, output_rate))
if stereo:
self.connect((splitter, 0), make_resampler(demod_output_rate, output_rate), (self, 0))
self.connect((splitter, 1), make_resampler(demod_output_rate, output_rate), (self, 1))
else:
resampler = make_resampler(demod_output_rate, output_rate)
self.connect(demod, resampler, (self, 0))
self.connect(resampler, (self, 1))
def __do_connect(self, reason):
# log.msg(u'receiver do_connect: %s' % (reason,))
self.context.lock()
try:
self.disconnect_all()
# Connect input of demodulator
if self.__demod_tunable:
self.connect(self, self.__demodulator)
else:
self.connect(self, self.__rotator, self.__demodulator)
if self.__demod_output:
# Construct stereo-to-mono conversion (used at least for level probe)
if self.__demod_stereo:
splitter = blocks.vector_to_streams(gr.sizeof_float, 2)
mono_audio = blocks.multiply_matrix_ff(((0.5, 0.5), ))
self.connect(self.__demodulator, splitter)
self.connect((splitter, 0), (mono_audio, 0))
self.connect((splitter, 1), (mono_audio, 1))
else:
mono_audio = self.__demodulator
# Connect mono audio to level probe
self.connect(mono_audio, self.probe_audio)
# Connect demodulator to output gain control, converting as needed
if (self.__audio_channels == 2) == self.__demod_stereo:
# stereo to stereo or mono to mono
self.connect(self.__demodulator, self.__audio_gain_block)
elif self.__audio_channels == 2 and not self.__demod_stereo:
# mono to stereo
duplicator = blocks.streams_to_vector(gr.sizeof_float, 2)
self.connect(self.__demodulator, (duplicator, 0))
self.connect(self.__demodulator, (duplicator, 1))
self.connect(duplicator, self.__audio_gain_block)
elif self.__audio_channels == 1 and self.__demod_stereo:
# stereo to mono
self.connect(mono_audio, self.__audio_gain_block)
else:
raise Exception('shouldn\'t happen')
# Connect gain control to output of receiver
self.connect(self.__audio_gain_block, self)
else:
# Dummy output, ignored by containing block
self.connect(
blocks.vector_source_f([], vlen=self.__audio_channels),
self)
if self.__output_type != self.__last_output_type:
self.__last_output_type = self.__output_type
self.context.changed_needed_connections(u'changed output type')
finally:
self.context.unlock()
def __rebuild(self):
if self.__signal_type.is_analytic():
input_length = self.__freq_resolution
output_length = self.__freq_resolution
self.__after_fft = None
else:
# use vector_to_streams to cut the output in half and discard the redundant part
input_length = self.__freq_resolution * 2
output_length = self.__freq_resolution
self.__after_fft = blocks.vector_to_streams(itemsize=output_length * gr.sizeof_float, nstreams=2)
sample_rate = self.__signal_type.get_sample_rate()
overlap_factor = int(math.ceil(_maximum_fft_rate * input_length / sample_rate))
# sanity limit -- OverlapGimmick is not free
overlap_factor = min(16, overlap_factor)
self.__gate = blocks.copy(gr.sizeof_gr_complex)
self.__gate.set_enabled(not self.__paused)
self.__fft_sink = MessageDistributorSink(
itemsize=output_length * gr.sizeof_char,
context=self.__context,
migrate=self.__fft_sink,
notify=self.__update_interested)
self.__overlapper = _OverlapGimmick(
size=input_length,
factor=overlap_factor,
itemsize=self.__itemsize)
# Adjusts units so displayed level is independent of resolution and sample rate. Also throw in the packing offset
compensation = to_dB(input_length / sample_rate) + self.__power_offset
# TODO: Consider not using the logpwrfft block
self.__logpwrfft = logpwrfft.logpwrfft_c(
sample_rate=sample_rate * overlap_factor,
fft_size=input_length,
ref_scale=10.0 ** (-compensation / 20.0) * 2, # not actually using this as a reference scale value but avoiding needing to use a separate add operation to apply the unit change -- this expression is the inverse of what logpwrfft does internally
frame_rate=self.__frame_rate,
avg_alpha=1.0,
average=False)
# It would make slightly more sense to use unsigned chars, but blocks.float_to_uchar does not support vlen.
self.__fft_converter = blocks.float_to_char(vlen=self.__freq_resolution, scale=1.0)
self.__scope_sink = MessageDistributorSink(
itemsize=self.__time_length * gr.sizeof_gr_complex,
context=self.__context,
migrate=self.__scope_sink,
notify=self.__update_interested)
self.__scope_chunker = blocks.stream_to_vector_decimator(
item_size=gr.sizeof_gr_complex,
sample_rate=sample_rate,
vec_rate=self.__frame_rate, # TODO doesn't need to be coupled
vec_len=self.__time_length)
def __init__(self, sample_rate, device_name, channels, ok_to_block=False):
assert channels > 0
gr.hier_block2.__init__(
self, type(self).__name__,
gr.io_signature(1, 1, gr.sizeof_float * channels),
gr.io_signature(0, 0, 0))
sink = audio.sink(sample_rate, device_name, ok_to_block=ok_to_block)
if channels > 1:
splitter = blocks.vector_to_streams(gr.sizeof_float, channels)
self.connect(self, splitter)
for ch in xrange(channels):
self.connect((splitter, ch), (sink, ch))
else:
self.connect(self, sink)
def __init__(self, sample_rate, device_name, channels, ok_to_block=False):
assert channels > 0
gr.hier_block2.__init__(
self, type(self).__name__,
gr.io_signature(1, 1, gr.sizeof_float * channels),
gr.io_signature(0, 0, 0))
sink = audio.sink(sample_rate, device_name, ok_to_block=ok_to_block)
if channels > 1:
splitter = blocks.vector_to_streams(gr.sizeof_float, channels)
self.connect(self, splitter)
for ch in xrange(channels):
self.connect((splitter, ch), (sink, ch))
else:
self.connect(self, sink)
def __init__(self, mpoints, taps=None):
"""
Takes 1 complex stream in, produces M complex streams out
that runs at 1/M times the input sample rate
Args:
mpoints: number of freq bins/interpolation factor/subbands
taps: filter taps for subband filter
Same channel to frequency mapping as described above.
"""
item_size = gr.sizeof_gr_complex
gr.hier_block2.__init__(
self,
"analysis_filterbank",
gr.io_signature(1, 1, item_size), # Input signature
gr.io_signature(mpoints, mpoints, item_size)) # Output signature
if taps is None:
taps = _generate_synthesis_taps(mpoints)
# pad taps to multiple of mpoints
r = len(taps) % mpoints
if r != 0:
taps = taps + (mpoints - r) * (0, )
# split in mpoints separate set of taps
sub_taps = _split_taps(taps, mpoints)
# print(>> sys.stderr, "mpoints =", mpoints, "len(sub_taps) =", len(sub_taps))
self.s2ss = blocks.stream_to_streams(item_size, mpoints)
# filters here
self.ss2v = blocks.streams_to_vector(item_size, mpoints)
self.fft = fft.fft_vcc(mpoints, True, [])
self.v2ss = blocks.vector_to_streams(item_size, mpoints)
self.connect(self, self.s2ss)
# build mpoints fir filters...
for i in range(mpoints):
f = fft_filter_ccc(1, sub_taps[mpoints - i - 1])
self.connect((self.s2ss, i), f)
self.connect(f, (self.ss2v, i))
self.connect((self.v2ss, i), (self, i))
self.connect(self.ss2v, self.fft, self.v2ss)
def __init__(self, mpoints, taps=None):
"""
Takes 1 complex stream in, produces M complex streams out
that runs at 1/M times the input sample rate
Args:
mpoints: number of freq bins/interpolation factor/subbands
taps: filter taps for subband filter
Same channel to frequency mapping as described above.
"""
item_size = gr.sizeof_gr_complex
gr.hier_block2.__init__(self, "analysis_filterbank",
gr.io_signature(1, 1, item_size), # Input signature
gr.io_signature(mpoints, mpoints, item_size)) # Output signature
if taps is None:
taps = _generate_synthesis_taps(mpoints)
# pad taps to multiple of mpoints
r = len(taps) % mpoints
if r != 0:
taps = taps + (mpoints - r) * (0,)
# split in mpoints separate set of taps
sub_taps = _split_taps(taps, mpoints)
# print >> sys.stderr, "mpoints =", mpoints, "len(sub_taps) =", len(sub_taps)
self.s2ss = blocks.stream_to_streams(item_size, mpoints)
# filters here
self.ss2v = blocks.streams_to_vector(item_size, mpoints)
self.fft = fft.fft_vcc(mpoints, True, [])
self.v2ss = blocks.vector_to_streams(item_size, mpoints)
self.connect(self, self.s2ss)
# build mpoints fir filters...
for i in range(mpoints):
f = fft_filter_ccc(1, sub_taps[mpoints-i-1])
self.connect((self.s2ss, i), f)
self.connect(f, (self.ss2v, i))
self.connect((self.v2ss, i), (self, i))
self.connect(self.ss2v, self.fft, self.v2ss)
def __init__(self, in_rate, out_rate, vlen, complex=False):
# pylint: disable=redefined-builtin
vitemsize = gr.sizeof_gr_complex if complex else gr.sizeof_float
itemsize = vitemsize * vlen
gr.hier_block2.__init__(
self, type(self).__name__,
gr.io_signature(1, 1, itemsize),
gr.io_signature(1, 1, itemsize))
if vlen == 1:
self.connect(self, make_resampler(in_rate, out_rate, complex=complex), self)
else:
splitter = blocks.vector_to_streams(vitemsize, vlen)
joiner = blocks.streams_to_vector(vitemsize, vlen)
self.connect(self, splitter)
for ch in xrange(vlen):
self.connect(
(splitter, ch),
make_resampler(in_rate, out_rate, complex=complex),
(joiner, ch))
self.connect(joiner, self)
def test_004(self):
#Test vector_to_streams.
n = 8
src_len = n * 8
src_data = tuple(range(src_len))
expected_results = src_data
src = blocks.vector_source_i(src_data)
op1 = blocks.stream_to_vector(gr.sizeof_int, n)
op2 = blocks.vector_to_streams(gr.sizeof_int, n)
op3 = blocks.streams_to_stream(gr.sizeof_int, n)
dst = blocks.vector_sink_i()
self.tb.connect(src, op1, op2)
for i in range(n):
self.tb.connect((op2, i), (op3, i))
self.tb.connect(op3, dst)
self.tb.run()
self.assertEqual(expected_results, dst.data())
def test_004(self):
#Test vector_to_streams.
n = 8
src_len = n * 8
src_data = tuple(range(src_len))
expected_results = src_data
src = blocks.vector_source_i(src_data)
op1 = blocks.stream_to_vector(gr.sizeof_int, n)
op2 = blocks.vector_to_streams(gr.sizeof_int, n)
op3 = blocks.streams_to_stream(gr.sizeof_int, n)
dst = blocks.vector_sink_i()
self.tb.connect(src, op1, op2)
for i in range(n):
self.tb.connect((op2, i), (op3, i))
self.tb.connect(op3, dst)
self.tb.run()
self.assertEqual(expected_results, dst.data())
def __init__(self, in_rate, out_rate, vlen, complex=False):
# pylint: disable=redefined-builtin
vitemsize = gr.sizeof_gr_complex if complex else gr.sizeof_float
itemsize = vitemsize * vlen
gr.hier_block2.__init__(self,
type(self).__name__,
gr.io_signature(1, 1, itemsize),
gr.io_signature(1, 1, itemsize))
if vlen == 1:
self.connect(self,
make_resampler(in_rate, out_rate, complex=complex),
self)
else:
splitter = blocks.vector_to_streams(vitemsize, vlen)
joiner = blocks.streams_to_vector(vitemsize, vlen)
self.connect(self, splitter)
for ch in six.moves.range(vlen):
self.connect((splitter, ch),
make_resampler(in_rate, out_rate,
complex=complex), (joiner, ch))
self.connect(joiner, self)
def __do_connect(self):
itemsize = self.__itemsize
if self.__signal_type.is_analytic():
input_length = self.__freq_resolution
output_length = self.__freq_resolution
self.__after_fft = None
else:
# use vector_to_streams to cut the output in half and discard the redundant part
input_length = self.__freq_resolution * 2
output_length = self.__freq_resolution
self.__after_fft = blocks.vector_to_streams(
itemsize=output_length * gr.sizeof_float, nstreams=2)
sample_rate = self.__signal_type.get_sample_rate()
overlap_factor = int(
math.ceil(_maximum_fft_rate * input_length / sample_rate))
# sanity limit -- OverlapGimmick is not free
overlap_factor = min(16, overlap_factor)
self.__frame_rate_to_decimation_conversion = sample_rate * overlap_factor / input_length
self.__gate = blocks.copy(itemsize)
self.__gate.set_enabled(not self.__paused)
overlapper = _OverlappedStreamToVector(size=input_length,
factor=overlap_factor,
itemsize=itemsize)
self.__frame_dec = blocks.keep_one_in_n(
itemsize=itemsize * input_length,
n=max(
1,
int(
round(self.__frame_rate_to_decimation_conversion /
self.__frame_rate))))
# the actual FFT logic, which is similar to GR's logpwrfft_c
window = windows.build(self.__window_type, input_length, 6.76)
window_power = sum(x * x for x in window)
# TODO: use fft_vfc when applicable
fft_block = (fft_vcc if itemsize == gr.sizeof_gr_complex else fft_vfc)(
fft_size=input_length, forward=True, window=window)
mag_squared = blocks.complex_to_mag_squared(input_length)
logarithmizer = blocks.nlog10_ff(
n=10, # the "deci" in "decibel"
vlen=input_length,
k=(
-to_dB(window_power) + # compensate for window
-to_dB(sample_rate)
+ # convert from power-per-sample to power-per-Hz
self.__power_offset # offset for packing into bytes
))
# It would make slightly more sense to use unsigned chars, but blocks.float_to_uchar does not support vlen.
self.__fft_converter = blocks.float_to_char(
vlen=self.__freq_resolution, scale=1.0)
fft_sink = self.__fft_cell.create_sink_internal(
numpy.dtype((numpy.int8, output_length)))
scope_sink = self.__scope_cell.create_sink_internal(
numpy.dtype(('c8', self.__time_length)))
scope_chunker = blocks.stream_to_vector_decimator(
item_size=gr.sizeof_gr_complex,
sample_rate=sample_rate,
vec_rate=self.__frame_rate, # TODO doesn't need to be coupled
vec_len=self.__time_length)
# connect everything
self.__context.lock()
try:
self.disconnect_all()
self.connect(self, self.__gate, overlapper, self.__frame_dec,
fft_block, mag_squared, logarithmizer)
if self.__after_fft is not None:
self.connect(logarithmizer, self.__after_fft)
self.connect(self.__after_fft, self.__fft_converter, fft_sink)
self.connect(
(self.__after_fft, 1),
blocks.null_sink(gr.sizeof_float * self.__freq_resolution))
else:
self.connect(logarithmizer, self.__fft_converter, fft_sink)
if self.__enable_scope:
self.connect(self.__gate, scope_chunker, scope_sink)
finally:
self.__context.unlock()
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.Nt = Nt = 2
self.dft_coef = dft_coef = np.exp(-2 * np.pi * 1j / Nt)
self.A = A = np.arange(Nt)[np.newaxis]
self.tlen = tlen = 4000
self.samp_rate = samp_rate = 100000
self.dft_matrix = dft_matrix = np.power(dft_coef,
np.dot(A.transpose(), A))
self.scramble_2 = scramble_2 = 2 * np.random.random_integers(
0, 1, size=(tlen, Nt)) - 1
self.scramble_1 = scramble_1 = 2 * np.random.random_integers(
0, 1, size=(tlen, Nt)) - 1
self.prefix = prefix = '/home/zhe/gr-PWF/examples'
self.noise = noise = [np.identity(Nt), np.identity(Nt)]
self.max_iteration = max_iteration = 20
self.interpo = interpo = samp_rate / 1000
self.dft_pilot_seq = dft_pilot_seq = np.tile(dft_matrix,
(tlen / Nt, 1))
self.Q = Q = 4
self.L = L = 2
self.sigmagenfile = sigmagenfile = prefix + '/sigmagens/sigmagen_10.bin'
self.pulse = pulse = filter.firdes.root_raised_cosine(
Q, Q, 1, 0.35, 11 * Q)
self.prewhiten1 = prewhiten1 = np.linalg.pinv(noise[1])
self.prewhiten0 = prewhiten0 = np.linalg.pinv(noise[0])
self.pilot_seq_2 = pilot_seq_2 = np.multiply(dft_pilot_seq, scramble_2)
self.pilot_seq_1 = pilot_seq_1 = np.multiply(dft_pilot_seq, scramble_1)
self.pilot2file = pilot2file = prefix + '/pilots/pilot2_4000.bin'
self.pilot1file = pilot1file = prefix + '/pilots/pilot1_4000.bin'
self.payload_size = payload_size = 0
self.npoints = npoints = max_iteration * interpo
self.noise_hat = noise_hat = [np.identity(Nt), np.identity(Nt)]
self.ichn_gain_dB = ichn_gain_dB = 10
self.channelfile = channelfile = prefix + '/channels/2x2channel_10dB_3.bin'
self.channel = channel = np.true_divide(
np.random.standard_normal(size=(L, L, Nt, Nt)) +
np.random.standard_normal(size=(L, L, Nt, Nt)) * 1j, np.sqrt(2))
self.Pt = Pt = 100
##################################################
# Blocks
##################################################
self.qtgui_time_sink_x_0 = qtgui.time_sink_f(
npoints, #size
samp_rate, #samp_rate
"Strong Interference (ichn_gain = 10dB)", #name
2 #number of inputs
)
self.qtgui_time_sink_x_0.set_update_time(0.1)
self.qtgui_time_sink_x_0.set_y_axis(0, 20)
self.qtgui_time_sink_x_0.set_y_label("Weighted Sum-Rate (bits/s/Hz)",
"")
self.qtgui_time_sink_x_0.enable_tags(-1, True)
self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_AUTO,
qtgui.TRIG_SLOPE_POS, 0.0, 0,
0, "")
self.qtgui_time_sink_x_0.enable_autoscale(True)
self.qtgui_time_sink_x_0.enable_grid(True)
self.qtgui_time_sink_x_0.enable_control_panel(False)
if not True:
self.qtgui_time_sink_x_0.disable_legend()
labels = [
"Dual Link", "Identity Sigma", "", "", "", "", "", "", "", ""
]
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
"blue", "red", "green", "black", "cyan", "magenta", "yellow",
"dark red", "dark green", "blue"
]
styles = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
markers = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(2):
if len(labels[i]) == 0:
self.qtgui_time_sink_x_0.set_line_label(
i, "Data {0}".format(i))
else:
self.qtgui_time_sink_x_0.set_line_label(i, labels[i])
self.qtgui_time_sink_x_0.set_line_width(i, widths[i])
self.qtgui_time_sink_x_0.set_line_color(i, colors[i])
self.qtgui_time_sink_x_0.set_line_style(i, styles[i])
self.qtgui_time_sink_x_0.set_line_marker(i, markers[i])
self.qtgui_time_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_time_sink_x_0_win = sip.wrapinstance(
self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_layout.addWidget(self._qtgui_time_sink_x_0_win)
self.phase_corrector_0_2 = phase_corrector(
loop_bandwidth=2 * np.pi * 0.005,
max_freq=2 * np.pi * 0.01,
training_sequence=pilot_seq_1[:, 0],
)
self.phase_corrector_0_1_0 = phase_corrector(
loop_bandwidth=2 * np.pi * 0.005,
max_freq=2 * np.pi * 0.01,
training_sequence=pilot_seq_2[:, 0],
)
self.phase_corrector_0_1 = phase_corrector(
loop_bandwidth=2 * np.pi * 0.005,
max_freq=2 * np.pi * 0.01,
training_sequence=pilot_seq_2[:, 0],
)
self.phase_corrector_0_0_1 = phase_corrector(
loop_bandwidth=2 * np.pi * 0.005,
max_freq=2 * np.pi * 0.01,
training_sequence=pilot_seq_1[:, 1],
)
self.phase_corrector_0_0_0_0 = phase_corrector(
loop_bandwidth=2 * np.pi * 0.005,
max_freq=2 * np.pi * 0.01,
training_sequence=pilot_seq_2[:, 1],
)
self.phase_corrector_0_0_0 = phase_corrector(
loop_bandwidth=2 * np.pi * 0.005,
max_freq=2 * np.pi * 0.01,
training_sequence=pilot_seq_2[:, 1],
)
self.phase_corrector_0_0 = phase_corrector(
loop_bandwidth=2 * np.pi * 0.005,
max_freq=2 * np.pi * 0.01,
training_sequence=pilot_seq_1[:, 1],
)
self.phase_corrector_0 = phase_corrector(
loop_bandwidth=2 * np.pi * 0.005,
max_freq=2 * np.pi * 0.01,
training_sequence=pilot_seq_1[:, 0],
)
self.interp_fir_filter_xxx_0_1_0 = filter.interp_fir_filter_ccc(
Q, (pulse))
self.interp_fir_filter_xxx_0_1_0.declare_sample_delay(0)
self.interp_fir_filter_xxx_0_1 = filter.interp_fir_filter_ccc(
Q, (pulse))
self.interp_fir_filter_xxx_0_1.declare_sample_delay(0)
self.interp_fir_filter_xxx_0_0 = filter.interp_fir_filter_ccc(
Q, (pulse))
self.interp_fir_filter_xxx_0_0.declare_sample_delay(0)
self.interp_fir_filter_xxx_0 = filter.interp_fir_filter_ccc(Q, (pulse))
self.interp_fir_filter_xxx_0.declare_sample_delay(0)
self.fir_filter_xxx_0_1 = filter.fir_filter_ccc(Q, (pulse))
self.fir_filter_xxx_0_1.declare_sample_delay(0)
self.fir_filter_xxx_0_0_0 = filter.fir_filter_ccc(Q, (pulse))
self.fir_filter_xxx_0_0_0.declare_sample_delay(0)
self.fir_filter_xxx_0_0 = filter.fir_filter_ccc(Q, (pulse))
self.fir_filter_xxx_0_0.declare_sample_delay(0)
self.fir_filter_xxx_0 = filter.fir_filter_ccc(Q, (pulse))
self.fir_filter_xxx_0.declare_sample_delay(0)
self.blocks_vector_to_streams_1_2 = blocks.vector_to_streams(
gr.sizeof_gr_complex * 1, 2)
self.blocks_vector_to_streams_1_1_1 = blocks.vector_to_streams(
gr.sizeof_gr_complex * 1, 2)
self.blocks_vector_to_streams_1_1_0_0 = blocks.vector_to_streams(
gr.sizeof_gr_complex * 1, 2)
self.blocks_vector_to_streams_1_1_0 = blocks.vector_to_streams(
gr.sizeof_gr_complex * 1, 2)
self.blocks_vector_to_streams_1_1 = blocks.vector_to_streams(
gr.sizeof_gr_complex * 1, 2)
self.blocks_vector_to_streams_1_0_0 = blocks.vector_to_streams(
gr.sizeof_gr_complex * 1, 2)
self.blocks_vector_to_streams_1_0 = blocks.vector_to_streams(
gr.sizeof_gr_complex * 1, 2)
self.blocks_vector_to_streams_1 = blocks.vector_to_streams(
gr.sizeof_gr_complex * 1, 2)
self.blocks_vector_to_streams_0 = blocks.vector_to_streams(
gr.sizeof_gr_complex * 4, 2)
self.blocks_udp_source_1 = blocks.udp_source(gr.sizeof_gr_complex * 8,
"127.0.0.1", 1234, 1472,
True)
self.blocks_udp_sink_1_0 = blocks.udp_sink(gr.sizeof_gr_complex * 8,
"127.0.0.1", 1234, 1472,
True)
self.blocks_udp_sink_1 = blocks.udp_sink(gr.sizeof_gr_complex * 8,
"127.0.0.1", 1234, 1472, True)
self.blocks_streams_to_vector_1_2 = blocks.streams_to_vector(
gr.sizeof_gr_complex * 1, 2)
self.blocks_streams_to_vector_1_1_1 = blocks.streams_to_vector(
gr.sizeof_gr_complex * 1, 2)
self.blocks_streams_to_vector_1_1_0_0 = blocks.streams_to_vector(
gr.sizeof_gr_complex * 1, 2)
self.blocks_streams_to_vector_1_1_0 = blocks.streams_to_vector(
gr.sizeof_gr_complex * 1, 2)
self.blocks_streams_to_vector_1_1 = blocks.streams_to_vector(
gr.sizeof_gr_complex * 1, 2)
self.blocks_streams_to_vector_1_0_0 = blocks.streams_to_vector(
gr.sizeof_gr_complex * 1, 2)
self.blocks_streams_to_vector_1_0 = blocks.streams_to_vector(
gr.sizeof_gr_complex * 1, 2)
self.blocks_streams_to_vector_1 = blocks.streams_to_vector(
gr.sizeof_gr_complex * 1, 2)
self.blocks_streams_to_vector_0_0 = blocks.streams_to_vector(
gr.sizeof_gr_complex * 4, 2)
self.blocks_streams_to_vector_0 = blocks.streams_to_vector(
gr.sizeof_gr_complex * 4, 2)
self.blocks_repeat_0_0 = blocks.repeat(gr.sizeof_float * 1, interpo)
self.blocks_repeat_0 = blocks.repeat(gr.sizeof_float * 1, interpo)
self.blocks_file_sink_0 = blocks.file_sink(
gr.sizeof_gr_complex * 8,
"/home/zhe/Dropbox/gnuradio_trunk/gnufiles/udp", False)
self.blocks_file_sink_0.set_unbuffered(True)
self.PWF_weighted_sum_rate_0 = PWF.weighted_sum_rate(
L, Nt, Pt, channel, ichn_gain_dB, [1, 1], [prewhiten0, prewhiten1],
False, channelfile)
self.PWF_sigmagen_0 = PWF.sigmagen(L, Nt, Pt, True, sigmagenfile)
self.PWF_power_adjust_1_0 = PWF.power_adjust(Nt, Pt, L)
self.PWF_power_adjust_1 = PWF.power_adjust(Nt, Pt, L)
self.PWF_pilot_receive_tx_0_0 = PWF.pilot_receive_tx(
True, pilot1file, pilot_seq_1, Nt, tlen, noise_hat[0], tlen, 1)
self.PWF_pilot_receive_tx_0 = PWF.pilot_receive_tx(
True, pilot2file, pilot_seq_2, Nt, tlen, noise_hat[1], tlen, 1)
self.PWF_pilot_receive_rx_0_0 = PWF.pilot_receive_rx(
True, pilot2file, pilot_seq_2, prewhiten1, Nt, tlen,
tlen + payload_size, 1)
self.PWF_pilot_receive_rx_0 = PWF.pilot_receive_rx(
True, pilot1file, pilot_seq_1, prewhiten0, Nt, tlen,
tlen + payload_size, 1)
self.PWF_pilot_gen_tx_0_0 = PWF.pilot_gen_tx(Nt, tlen, pilot_seq_2,
True, pilot2file)
self.PWF_pilot_gen_tx_0 = PWF.pilot_gen_tx(Nt, tlen, pilot_seq_1, True,
pilot1file)
self.PWF_pilot_gen_rx_0_0 = PWF.pilot_gen_rx(Nt, tlen, prewhiten0,
pilot_seq_1, True,
pilot1file)
self.PWF_pilot_gen_rx_0 = PWF.pilot_gen_rx(Nt, tlen, prewhiten1,
pilot_seq_2, True,
pilot2file)
self.PWF_debug_printmsg_0 = PWF.debug_printmsg(L, Nt, False, 20)
self.PWF_channel_1 = PWF.channel(L, Nt, ichn_gain_dB, channel, False,
noise_hat, False, channelfile)
self.PWF_channel_0 = PWF.channel(L, Nt, ichn_gain_dB, channel, True,
noise, True, channelfile)
##################################################
# Connections
##################################################
self.connect((self.PWF_channel_0, 0),
(self.blocks_vector_to_streams_1_1, 0))
self.connect((self.PWF_channel_0, 1),
(self.blocks_vector_to_streams_1_1_0, 0))
self.connect((self.PWF_channel_1, 1),
(self.blocks_vector_to_streams_1_1_0_0, 0))
self.connect((self.PWF_channel_1, 0),
(self.blocks_vector_to_streams_1_1_1, 0))
self.connect((self.PWF_debug_printmsg_0, 0),
(self.PWF_pilot_gen_tx_0, 0))
self.connect((self.PWF_debug_printmsg_0, 1),
(self.PWF_pilot_gen_tx_0_0, 0))
self.connect((self.PWF_pilot_gen_rx_0, 0),
(self.blocks_vector_to_streams_1_0_0, 0))
self.connect((self.PWF_pilot_gen_rx_0_0, 0),
(self.blocks_vector_to_streams_1_2, 0))
self.connect((self.PWF_pilot_gen_tx_0, 0),
(self.blocks_vector_to_streams_1, 0))
self.connect((self.PWF_pilot_gen_tx_0_0, 0),
(self.blocks_vector_to_streams_1_0, 0))
self.connect((self.PWF_pilot_receive_rx_0, 0),
(self.PWF_power_adjust_1, 0))
self.connect((self.PWF_pilot_receive_rx_0_0, 0),
(self.PWF_power_adjust_1, 1))
self.connect((self.PWF_pilot_receive_tx_0, 0),
(self.PWF_power_adjust_1_0, 1))
self.connect((self.PWF_pilot_receive_tx_0_0, 0),
(self.PWF_power_adjust_1_0, 0))
self.connect((self.PWF_power_adjust_1, 1),
(self.PWF_pilot_gen_rx_0, 0))
self.connect((self.PWF_power_adjust_1, 0),
(self.PWF_pilot_gen_rx_0_0, 0))
self.connect((self.PWF_power_adjust_1_0, 0),
(self.blocks_streams_to_vector_0_0, 0))
self.connect((self.PWF_power_adjust_1_0, 1),
(self.blocks_streams_to_vector_0_0, 1))
self.connect((self.PWF_sigmagen_0, 0),
(self.blocks_streams_to_vector_0, 0))
self.connect((self.PWF_sigmagen_0, 1),
(self.blocks_streams_to_vector_0, 1))
self.connect((self.PWF_weighted_sum_rate_0, 0),
(self.blocks_repeat_0, 0))
self.connect((self.PWF_weighted_sum_rate_0, 1),
(self.blocks_repeat_0_0, 0))
self.connect((self.blocks_repeat_0, 0), (self.qtgui_time_sink_x_0, 0))
self.connect((self.blocks_repeat_0_0, 0),
(self.qtgui_time_sink_x_0, 1))
self.connect((self.blocks_streams_to_vector_0, 0),
(self.blocks_udp_sink_1, 0))
self.connect((self.blocks_streams_to_vector_0_0, 0),
(self.blocks_udp_sink_1_0, 0))
self.connect((self.blocks_streams_to_vector_1, 0),
(self.PWF_channel_0, 0))
self.connect((self.blocks_streams_to_vector_1_0, 0),
(self.PWF_channel_0, 1))
self.connect((self.blocks_streams_to_vector_1_0_0, 0),
(self.PWF_channel_1, 1))
self.connect((self.blocks_streams_to_vector_1_1, 0),
(self.PWF_pilot_receive_rx_0, 0))
self.connect((self.blocks_streams_to_vector_1_1_0, 0),
(self.PWF_pilot_receive_rx_0_0, 0))
self.connect((self.blocks_streams_to_vector_1_1_0_0, 0),
(self.PWF_pilot_receive_tx_0, 0))
self.connect((self.blocks_streams_to_vector_1_1_1, 0),
(self.PWF_pilot_receive_tx_0_0, 0))
self.connect((self.blocks_streams_to_vector_1_2, 0),
(self.PWF_channel_1, 0))
self.connect((self.blocks_udp_source_1, 0),
(self.blocks_file_sink_0, 0))
self.connect((self.blocks_udp_source_1, 0),
(self.blocks_vector_to_streams_0, 0))
self.connect((self.blocks_vector_to_streams_0, 0),
(self.PWF_debug_printmsg_0, 0))
self.connect((self.blocks_vector_to_streams_0, 1),
(self.PWF_debug_printmsg_0, 1))
self.connect((self.blocks_vector_to_streams_0, 0),
(self.PWF_weighted_sum_rate_0, 0))
self.connect((self.blocks_vector_to_streams_0, 1),
(self.PWF_weighted_sum_rate_0, 1))
self.connect((self.blocks_vector_to_streams_1, 0),
(self.interp_fir_filter_xxx_0, 0))
self.connect((self.blocks_vector_to_streams_1, 1),
(self.interp_fir_filter_xxx_0_1, 0))
self.connect((self.blocks_vector_to_streams_1_0, 0),
(self.interp_fir_filter_xxx_0_0, 0))
self.connect((self.blocks_vector_to_streams_1_0, 1),
(self.interp_fir_filter_xxx_0_1_0, 0))
self.connect((self.blocks_vector_to_streams_1_0_0, 0),
(self.blocks_streams_to_vector_1_0_0, 0))
self.connect((self.blocks_vector_to_streams_1_0_0, 1),
(self.blocks_streams_to_vector_1_0_0, 1))
self.connect((self.blocks_vector_to_streams_1_1, 0),
(self.fir_filter_xxx_0, 0))
self.connect((self.blocks_vector_to_streams_1_1, 1),
(self.fir_filter_xxx_0_0, 0))
self.connect((self.blocks_vector_to_streams_1_1_0, 1),
(self.fir_filter_xxx_0_0_0, 0))
self.connect((self.blocks_vector_to_streams_1_1_0, 0),
(self.fir_filter_xxx_0_1, 0))
self.connect((self.blocks_vector_to_streams_1_1_0_0, 1),
(self.phase_corrector_0_0_0_0, 0))
self.connect((self.blocks_vector_to_streams_1_1_0_0, 0),
(self.phase_corrector_0_1_0, 0))
self.connect((self.blocks_vector_to_streams_1_1_1, 1),
(self.phase_corrector_0_0_1, 0))
self.connect((self.blocks_vector_to_streams_1_1_1, 0),
(self.phase_corrector_0_2, 0))
self.connect((self.blocks_vector_to_streams_1_2, 1),
(self.blocks_streams_to_vector_1_2, 1))
self.connect((self.blocks_vector_to_streams_1_2, 0),
(self.blocks_streams_to_vector_1_2, 0))
self.connect((self.fir_filter_xxx_0, 0), (self.phase_corrector_0, 0))
self.connect((self.fir_filter_xxx_0_0, 0),
(self.phase_corrector_0_0, 0))
self.connect((self.fir_filter_xxx_0_0_0, 0),
(self.phase_corrector_0_0_0, 0))
self.connect((self.fir_filter_xxx_0_1, 0),
(self.phase_corrector_0_1, 0))
self.connect((self.interp_fir_filter_xxx_0, 0),
(self.blocks_streams_to_vector_1, 0))
self.connect((self.interp_fir_filter_xxx_0_0, 0),
(self.blocks_streams_to_vector_1_0, 0))
self.connect((self.interp_fir_filter_xxx_0_1, 0),
(self.blocks_streams_to_vector_1, 1))
self.connect((self.interp_fir_filter_xxx_0_1_0, 0),
(self.blocks_streams_to_vector_1_0, 1))
self.connect((self.phase_corrector_0, 0),
(self.blocks_streams_to_vector_1_1, 0))
self.connect((self.phase_corrector_0_0, 0),
(self.blocks_streams_to_vector_1_1, 1))
self.connect((self.phase_corrector_0_0_0, 0),
(self.blocks_streams_to_vector_1_1_0, 1))
self.connect((self.phase_corrector_0_0_0_0, 0),
(self.blocks_streams_to_vector_1_1_0_0, 1))
self.connect((self.phase_corrector_0_0_1, 0),
(self.blocks_streams_to_vector_1_1_1, 1))
self.connect((self.phase_corrector_0_1, 0),
(self.blocks_streams_to_vector_1_1_0, 0))
self.connect((self.phase_corrector_0_1_0, 0),
(self.blocks_streams_to_vector_1_1_0_0, 0))
self.connect((self.phase_corrector_0_2, 0),
(self.blocks_streams_to_vector_1_1_1, 0))
def __init__(self, filenames, dev_addrs,
onebit, iq, noise, mix, gain, fs, fc, unint, sync_pps):
gr.top_block.__init__(self)
if mix:
raise NotImplementedError("TODO: Hilbert remix mode not implemented.")
uhd_sinks = [
uhd.usrp_sink(",".join(
[addr, "send_frame_size=32768,num_send_frames=128"]),
uhd.stream_args(
cpu_format="fc32",
otwformat="sc8",
channels=[0]))
for addr in dev_addrs]
for sink in uhd_sinks:
sink.set_clock_rate(fs*2, uhd.ALL_MBOARDS)
sink.set_samp_rate(fs)
sink.set_center_freq(fc, 0)
sink.set_gain(gain, 0)
# TODO Use offset tuning?
if sync_pps:
sink.set_clock_source("external") # 10 MHz
sink.set_time_source("external") # PPS
if unint:
if noise or onebit or not iq:
raise NotImplementedError("TODO: RX channel-interleaved mode only "
"supported for noiseless 8-bit complex.")
BLOCK_N=16*1024*1024
demux = blocks.vector_to_streams(2, len(uhd_sinks))
self.connect(blocks.file_source(2*len(uhd_sinks)*BLOCK_N, filenames[0], False),
blocks.vector_to_stream(2*len(uhd_sinks), BLOCK_N),
demux)
for ix, sink in enumerate(uhd_sinks):
self.connect((demux, ix),
blocks.vector_to_stream(1, 2),
blocks.interleaved_char_to_complex(), # [-128.0, +127.0]
blocks.multiply_const_cc(1.0/1024), # [-0.125, 0.125)
# blocks.vector_to_stream(8, 16*1024),
sink)
else:
file_srcs = [blocks.file_source(gr.sizeof_char*1, f, False)
for f in filenames]
for src, sink in zip(file_srcs, uhd_sinks):
if iq:
node = blocks.multiply_const_cc(1.0/1024)
if onebit:
self.connect(src,
blocks.unpack_k_bits_bb(8),
blocks.char_to_short(), # [0, 1] -> [0, 256]
blocks.add_const_ss(-128), # [-128, +128],
blocks.interleaved_short_to_complex(), # [ -128.0, +128.0]
node) # [-0.125, +0.125]
else:
self.connect(src, # [-128..127]
blocks.interleaved_char_to_complex(), # [-128.0, +127.0]
node) # [-0.125, +0.125)
else:
node = blocks.float_to_complex(1)
if onebit:
self.connect(src,
blocks.unpack_k_bits_bb(8), # [0, 1] -> [-0.125, +0.125]
blocks.char_to_float(vlen=1, scale=4),
blocks.add_const_vff((-0.125, )),
node)
else:
self.connect(src, # [-128..127] -> [-0.125, +0.125)
blocks.char_to_float(vlen=1, scale=1024),
node)
if noise:
combiner = blocks.add_vcc(1)
self.connect(node,
combiner,
sink)
self.connect(analog.fastnoise_source_c(analog.GR_GAUSSIAN, noise, -222, 8192),
(combiner, 1))
else:
self.connect(node,
sink)
print "Setting clocks..."
if sync_pps:
time.sleep(1.1) # Ensure there's been an edge. TODO: necessary?
last_pps_time = uhd_sinks[0].get_time_last_pps()
while last_pps_time == uhd_sinks[0].get_time_last_pps():
time.sleep(0.1)
print "Got edge"
[sink.set_time_next_pps(uhd.time_spec(round(time.time())+1)) for sink in uhd_sinks]
time.sleep(1.0) # Wait for edge to set the clocks
else:
# No external PPS/10 MHz. Just set each clock and accept some skew.
t = time.time()
[sink.set_time_now(uhd.time_spec(time.time())) for sink in uhd_sinks]
if len(uhd_sinks) > 1:
print "Uncabled; loosely synced only. Initial skew ~ %.1f ms" % (
(time.time()-t) * 1000)
t_start = uhd.time_spec(time.time() + 1.5)
[sink.set_start_time(t_start) for sink in uhd_sinks]
print "ready"
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.fftl = fftl = 2048
self.samp_rate = samp_rate = fftl * 15e3
self.rxant = rxant = 2
self.resampler = resampler = 400
self.frame_key = frame_key = "slot"
self.N_rb_dl = N_rb_dl = 50
##################################################
# Blocks
##################################################
self.rational_resampler_xxx_0_1 = filter.rational_resampler_ccc(
interpolation=1536 * fftl / 1024,
decimation=resampler,
taps=None,
fractional_bw=None,
)
self.rational_resampler_xxx_0_0 = filter.rational_resampler_ccc(
interpolation=1536 * fftl / 1024,
decimation=resampler,
taps=None,
fractional_bw=None,
)
self.lte_mimo_sss_sync_0 = lte_mimo_sss_sync(
rxant=rxant,
N_rb_dl=N_rb_dl,
)
self.lte_mimo_pss_sync_0 = lte_mimo_pss_sync(
fftlen=fftl,
rxant=rxant,
synclen=5,
)
self.lte_mimo_pss_based_frey_sync_0 = lte_mimo_pss_based_frey_sync(
fftlen=fftl,
rxant=rxant,
)
self.lte_mimo_ofdm_rx_0 = lte_mimo_ofdm_rx(
fftlen=fftl,
ofdm_key=frame_key,
N_rb_dl=N_rb_dl,
rxant=rxant,
)
self.lte_mimo_estimator_0 = lte_mimo_estimator(
estimator_key=frame_key,
N_rb_dl=N_rb_dl,
initial_id=2,
rxant=rxant,
)
self.lte_mimo_decode_pbch_0 = lte_mimo_decode_pbch(
N_rb_dl=N_rb_dl,
rxant=rxant,
)
self.blocks_vector_to_streams_0 = blocks.vector_to_streams(
gr.sizeof_gr_complex * 1, 2)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex * 2,
samp_rate, True)
self.blocks_file_source_0 = blocks.file_source(
gr.sizeof_gr_complex * 2,
"/home/maier/LTE test files/live data/lte_capture_Wed_Aug_6_19:36:39_2014_RXant2_4MS_telekom_band1800_wg_karlruhe_hinten raus.dat",
True)
self.bch_decode_bch_hier_gr37_0 = decode_bch_hier_gr37()
self.MIB = lte.mib_unpack_vbm("MIB")
##################################################
# Connections
##################################################
self.connect((self.rational_resampler_xxx_0_1, 0),
(self.lte_mimo_pss_sync_0, 0))
self.connect((self.rational_resampler_xxx_0_0, 0),
(self.lte_mimo_pss_sync_0, 1))
self.connect((self.blocks_vector_to_streams_0, 1),
(self.rational_resampler_xxx_0_0, 0))
self.connect((self.blocks_vector_to_streams_0, 0),
(self.rational_resampler_xxx_0_1, 0))
self.connect((self.blocks_file_source_0, 0),
(self.blocks_throttle_0, 0))
self.connect((self.blocks_throttle_0, 0),
(self.blocks_vector_to_streams_0, 0))
self.connect((self.lte_mimo_sss_sync_0, 0),
(self.lte_mimo_estimator_0, 0))
self.connect((self.lte_mimo_sss_sync_0, 0),
(self.lte_mimo_decode_pbch_0, 0))
self.connect((self.bch_decode_bch_hier_gr37_0, 1), (self.MIB, 1))
self.connect((self.bch_decode_bch_hier_gr37_0, 0), (self.MIB, 0))
self.connect((self.lte_mimo_estimator_0, 1),
(self.lte_mimo_decode_pbch_0, 2))
self.connect((self.lte_mimo_estimator_0, 0),
(self.lte_mimo_decode_pbch_0, 1))
self.connect((self.lte_mimo_decode_pbch_0, 0),
(self.bch_decode_bch_hier_gr37_0, 0))
self.connect((self.lte_mimo_pss_sync_0, 1),
(self.lte_mimo_pss_based_frey_sync_0, 1))
self.connect((self.lte_mimo_pss_sync_0, 0),
(self.lte_mimo_pss_based_frey_sync_0, 0))
self.connect((self.lte_mimo_pss_based_frey_sync_0, 0),
(self.lte_mimo_ofdm_rx_0, 0))
self.connect((self.lte_mimo_pss_based_frey_sync_0, 1),
(self.lte_mimo_ofdm_rx_0, 1))
self.connect((self.lte_mimo_ofdm_rx_0, 0),
(self.lte_mimo_sss_sync_0, 0))
##################################################
# Asynch Message Connections
##################################################
self.msg_connect(self.lte_mimo_sss_sync_0, "cell_id",
self.lte_mimo_estimator_0, "cell_id")
self.msg_connect(self.lte_mimo_sss_sync_0, "cell_id",
self.lte_mimo_decode_pbch_0, "cell_id")
self.msg_connect(self.lte_mimo_pss_sync_0, "N_id_2",
self.lte_mimo_sss_sync_0, "N_id_2")
def __do_connect(self):
itemsize = self.__itemsize
if self.__signal_type.is_analytic():
input_length = self.__freq_resolution
output_length = self.__freq_resolution
self.__after_fft = None
else:
# use vector_to_streams to cut the output in half and discard the redundant part
input_length = self.__freq_resolution * 2
output_length = self.__freq_resolution
self.__after_fft = blocks.vector_to_streams(itemsize=output_length * gr.sizeof_float, nstreams=2)
sample_rate = self.__signal_type.get_sample_rate()
overlap_factor = int(math.ceil(_maximum_fft_rate * input_length / sample_rate))
# sanity limit -- OverlapGimmick is not free
overlap_factor = min(16, overlap_factor)
self.__frame_rate_to_decimation_conversion = sample_rate * overlap_factor / input_length
self.__gate = blocks.copy(itemsize)
self.__gate.set_enabled(not self.__paused)
overlapper = _OverlappedStreamToVector(
size=input_length,
factor=overlap_factor,
itemsize=itemsize)
self.__frame_dec = blocks.keep_one_in_n(
itemsize=itemsize * input_length,
n=int(round(self.__frame_rate_to_decimation_conversion / self.__frame_rate)))
# the actual FFT logic, which is similar to GR's logpwrfft_c
window = windows.blackmanharris(input_length)
window_power = sum(x * x for x in window)
# TODO: use fft_vfc when applicable
fft_block = (fft_vcc if itemsize == gr.sizeof_gr_complex else fft_vfc)(
fft_size=input_length,
forward=True,
window=window)
mag_squared = blocks.complex_to_mag_squared(input_length)
logarithmizer = blocks.nlog10_ff(
n=10, # the "deci" in "decibel"
vlen=input_length,
k=(
-to_dB(window_power) + # compensate for window
-to_dB(sample_rate) + # convert from power-per-sample to power-per-Hz
self.__power_offset # offset for packing into bytes
))
# It would make slightly more sense to use unsigned chars, but blocks.float_to_uchar does not support vlen.
self.__fft_converter = blocks.float_to_char(vlen=self.__freq_resolution, scale=1.0)
self.__fft_sink = MessageDistributorSink(
itemsize=output_length * gr.sizeof_char,
context=self.__context,
migrate=self.__fft_sink,
notify=self.__update_interested)
self.__scope_sink = MessageDistributorSink(
itemsize=self.__time_length * gr.sizeof_gr_complex,
context=self.__context,
migrate=self.__scope_sink,
notify=self.__update_interested)
scope_chunker = blocks.stream_to_vector_decimator(
item_size=gr.sizeof_gr_complex,
sample_rate=sample_rate,
vec_rate=self.__frame_rate, # TODO doesn't need to be coupled
vec_len=self.__time_length)
# connect everything
self.__context.lock()
try:
self.disconnect_all()
self.connect(
self,
self.__gate,
overlapper,
self.__frame_dec,
fft_block,
mag_squared,
logarithmizer)
if self.__after_fft is not None:
self.connect(logarithmizer, self.__after_fft)
self.connect(self.__after_fft, self.__fft_converter, self.__fft_sink)
self.connect((self.__after_fft, 1), blocks.null_sink(gr.sizeof_float * self.__freq_resolution))
else:
self.connect(logarithmizer, self.__fft_converter, self.__fft_sink)
if self.__enable_scope:
self.connect(
self.__gate,
scope_chunker,
self.__scope_sink)
finally:
self.__context.unlock()
def __init__(self):
gr.top_block.__init__(self, "MIMO TOP FLOW")
##################################################
# Variables
##################################################
self.fftl = fftl = 128
self.samp_rate = samp_rate = fftl*15e3
self.rxant = rxant = 2
self.resampler = resampler = 400
self.frame_key = frame_key = "slot"
self.N_rb_dl = N_rb_dl = 50
##################################################
# Blocks
##################################################
self.lte_mimo_sss_sync_0 = lte_mimo_sss_sync(
N_rb_dl=N_rb_dl,
rxant=rxant,
)
self.lte_mimo_pss_sync_0 = lte_mimo_pss_sync(
rxant=rxant,
synclen=5,
fftlen=fftl,
)
self.lte_mimo_pss_based_frey_sync_0 = lte_mimo_pss_based_frey_sync(
fftlen=fftl,
rxant=rxant,
)
self.lte_mimo_ofdm_rx_0 = lte_mimo_ofdm_rx(
N_rb_dl=N_rb_dl,
ofdm_key=frame_key,
fftlen=fftl,
rxant=rxant,
)
self.lte_mimo_estimator_0 = lte_mimo_estimator(
N_rb_dl=N_rb_dl,
estimator_key=frame_key,
initial_id=2,
rxant=rxant,
)
self.lte_mimo_decode_pbch_0 = lte_mimo_decode_pbch(
N_rb_dl=N_rb_dl,
rxant=rxant,
)
self.blocks_vector_to_streams_0 = blocks.vector_to_streams(gr.sizeof_gr_complex*1, 2)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*2, samp_rate,True)
self.blocks_streams_to_vector_0_0 = blocks.streams_to_vector(gr.sizeof_gr_complex*12 * N_rb_dl, 2)
self.blocks_file_source_0 = blocks.file_source(gr.sizeof_gr_complex*2, "/home/johannes/src/gr-lte/tests/lte_test_data_RX2_NRBDL6.dat", True)
self.bch_decode_bch_hier_gr37_0 = decode_bch_hier_gr37()
self.MIB = lte.mib_unpack_vbm("MIB")
##################################################
# Connections
##################################################
self.connect((self.lte_mimo_pss_sync_0, 1), (self.lte_mimo_pss_based_frey_sync_0, 1))
self.connect((self.lte_mimo_pss_sync_0, 0), (self.lte_mimo_pss_based_frey_sync_0, 0))
self.connect((self.lte_mimo_pss_based_frey_sync_0, 0), (self.lte_mimo_ofdm_rx_0, 0))
self.connect((self.lte_mimo_pss_based_frey_sync_0, 1), (self.lte_mimo_ofdm_rx_0, 1))
self.connect((self.blocks_throttle_0, 0), (self.blocks_vector_to_streams_0, 0))
self.connect((self.blocks_vector_to_streams_0, 0), (self.lte_mimo_pss_sync_0, 0))
self.connect((self.blocks_vector_to_streams_0, 1), (self.lte_mimo_pss_sync_0, 1))
self.connect((self.lte_mimo_ofdm_rx_0, 0), (self.lte_mimo_sss_sync_0, 0))
self.connect((self.lte_mimo_ofdm_rx_0, 1), (self.lte_mimo_sss_sync_0, 1))
self.connect((self.lte_mimo_decode_pbch_0, 0), (self.bch_decode_bch_hier_gr37_0, 0))
self.connect((self.lte_mimo_estimator_0, 0), (self.lte_mimo_decode_pbch_0, 1))
self.connect((self.lte_mimo_estimator_0, 1), (self.lte_mimo_decode_pbch_0, 2))
self.connect((self.bch_decode_bch_hier_gr37_0, 1), (self.MIB, 1))
self.connect((self.bch_decode_bch_hier_gr37_0, 0), (self.MIB, 0))
self.connect((self.lte_mimo_sss_sync_0, 1), (self.blocks_streams_to_vector_0_0, 1))
self.connect((self.lte_mimo_sss_sync_0, 0), (self.blocks_streams_to_vector_0_0, 0))
self.connect((self.blocks_streams_to_vector_0_0, 0), (self.lte_mimo_estimator_0, 0))
self.connect((self.blocks_streams_to_vector_0_0, 0), (self.lte_mimo_decode_pbch_0, 0))
self.connect((self.blocks_file_source_0, 0), (self.blocks_throttle_0, 0))
##################################################
# Asynch Message Connections
##################################################
self.msg_connect(self.lte_mimo_sss_sync_0, "cell_id", self.lte_mimo_estimator_0, "cell_id")
self.msg_connect(self.lte_mimo_pss_sync_0, "N_id_2", self.lte_mimo_sss_sync_0, "N_id_2")
self.msg_connect(self.lte_mimo_sss_sync_0, "cell_id", self.lte_mimo_decode_pbch_0, "cell_id")
def __init__(self):
gr.top_block.__init__(self, "Run Music Lin Array Simulation")
Qt.QWidget.__init__(self)
self.setWindowTitle("Run Music Lin Array Simulation")
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", "run_MUSIC_lin_array_simulation")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.theta1_deg = theta1_deg = 123
self.theta0_deg = theta0_deg = 30
self.input_variables = input_variables = struct({'SampleRate': 320000, 'ToneFreq1': 10000, 'ToneFreq2': 20000, 'NormSpacing': 0.4, 'NumTargets': 2, 'NumArrayElements': 4, 'PSpectrumLength': 2**10, 'SnapshotSize': 2**11, 'OverlapSize': 2**9, })
self.theta1 = theta1 = numpy.pi*theta1_deg/180
self.theta0 = theta0 = numpy.pi*theta0_deg/180
self.ant_locs = ant_locs = numpy.dot(input_variables.NormSpacing, numpy.arange(input_variables.NumArrayElements/2, -input_variables.NumArrayElements/2, -1) if (input_variables.NumArrayElements%2==1) else numpy.arange(input_variables.NumArrayElements/2-0.5, -input_variables.NumArrayElements/2-0.5, -1))
self.amv1 = amv1 = numpy.exp(-1j*ant_locs*2*numpy.pi*numpy.cos(theta1))
self.amv0 = amv0 = numpy.exp(-1j*ant_locs*2*numpy.pi*numpy.cos(theta0))
self.array_manifold_matrix = array_manifold_matrix = numpy.array([amv0, amv1]).transpose()
##################################################
# Blocks
##################################################
self.tab = Qt.QTabWidget()
self.tab_widget_0 = Qt.QWidget()
self.tab_layout_0 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom, self.tab_widget_0)
self.tab_grid_layout_0 = Qt.QGridLayout()
self.tab_layout_0.addLayout(self.tab_grid_layout_0)
self.tab.addTab(self.tab_widget_0, 'Pseudo-Spectrum')
self.tab_widget_1 = Qt.QWidget()
self.tab_layout_1 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom, self.tab_widget_1)
self.tab_grid_layout_1 = Qt.QGridLayout()
self.tab_layout_1.addLayout(self.tab_grid_layout_1)
self.tab.addTab(self.tab_widget_1, 'Direction of Arrival')
self.tab_widget_2 = Qt.QWidget()
self.tab_layout_2 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom, self.tab_widget_2)
self.tab_grid_layout_2 = Qt.QGridLayout()
self.tab_layout_2.addLayout(self.tab_grid_layout_2)
self.tab.addTab(self.tab_widget_2, 'Direction of Arrival')
self.top_layout.addWidget(self.tab)
self._theta1_deg_range = Range(0, 180, 1, 123, 200)
self._theta1_deg_win = RangeWidget(self._theta1_deg_range, self.set_theta1_deg, 'AoA', "counter_slider", float)
self.top_layout.addWidget(self._theta1_deg_win)
self._theta0_deg_range = Range(0, 180, 1, 30, 200)
self._theta0_deg_win = RangeWidget(self._theta0_deg_range, self.set_theta0_deg, 'AoA', "counter_slider", float)
self.top_layout.addWidget(self._theta0_deg_win)
self.qtgui_vector_sink_f_0 = qtgui.vector_sink_f(
input_variables.PSpectrumLength,
0,
180.0/input_variables.PSpectrumLength,
"angle (in degrees)",
"Pseudo-Spectrum (dB)",
"",
1 # Number of inputs
)
self.qtgui_vector_sink_f_0.set_update_time(0.05)
self.qtgui_vector_sink_f_0.set_y_axis(-50, 0)
self.qtgui_vector_sink_f_0.enable_autoscale(False)
self.qtgui_vector_sink_f_0.enable_grid(True)
self.qtgui_vector_sink_f_0.set_x_axis_units("")
self.qtgui_vector_sink_f_0.set_y_axis_units("")
self.qtgui_vector_sink_f_0.set_ref_level(0)
labels = ['', '', '', '', '',
'', '', '', '', '']
widths = [2, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "green", "black", "cyan",
"magenta", "yellow", "dark red", "dark green", "dark blue"]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(1):
if len(labels[i]) == 0:
self.qtgui_vector_sink_f_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_vector_sink_f_0.set_line_label(i, labels[i])
self.qtgui_vector_sink_f_0.set_line_width(i, widths[i])
self.qtgui_vector_sink_f_0.set_line_color(i, colors[i])
self.qtgui_vector_sink_f_0.set_line_alpha(i, alphas[i])
self._qtgui_vector_sink_f_0_win = sip.wrapinstance(self.qtgui_vector_sink_f_0.pyqwidget(), Qt.QWidget)
self.tab_layout_0.addWidget(self._qtgui_vector_sink_f_0_win)
self.doa_find_local_max_0 = doa.find_local_max(input_variables.NumTargets, input_variables.PSpectrumLength, 0.0, 180.0)
self.doa_compass_0 = doa.compass("", 0, 180, 10, 0)
self.tab_layout_1.addLayout(self.doa_compass_0.this_layout)
self.doa_compass = doa.compass("", 0, 180, 10, 0)
self.tab_layout_2.addLayout(self.doa_compass.this_layout)
self.doa_autocorrelate_0 = doa.autocorrelate(input_variables.NumArrayElements, input_variables.SnapshotSize, input_variables.OverlapSize, 1)
self.doa_MUSIC_lin_array_0 = doa.MUSIC_lin_array(input_variables.NormSpacing, input_variables.NumTargets, input_variables.NumArrayElements, input_variables.PSpectrumLength)
self.blocks_vector_to_streams_0 = blocks.vector_to_streams(gr.sizeof_float*1, input_variables.NumTargets)
self.blocks_throttle_0_0 = blocks.throttle(gr.sizeof_gr_complex*1, input_variables.SampleRate,True)
self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_float*input_variables.NumTargets)
self.blocks_multiply_matrix_xx_0 = blocks.multiply_matrix_cc(array_manifold_matrix, gr.TPP_ALL_TO_ALL)
self.blocks_add_xx_0_0 = blocks.add_vcc(1)
self.blocks_add_xx_0 = blocks.add_vcc(1)
self.analog_sig_source_x_0_0 = analog.sig_source_c(input_variables.SampleRate, analog.GR_COS_WAVE, input_variables.ToneFreq2, 1, 0)
self.analog_sig_source_x_0 = analog.sig_source_c(input_variables.SampleRate, analog.GR_COS_WAVE, input_variables.ToneFreq1, 1, 0)
self.analog_noise_source_x_0_0_0 = analog.noise_source_c(analog.GR_GAUSSIAN, 0.5, 0)
self.analog_noise_source_x_0_0 = analog.noise_source_c(analog.GR_GAUSSIAN, 0.0005, 0)
##################################################
# Connections
##################################################
self.connect((self.analog_noise_source_x_0_0, 0), (self.blocks_add_xx_0, 1))
self.connect((self.analog_noise_source_x_0_0_0, 0), (self.blocks_add_xx_0_0, 1))
self.connect((self.analog_sig_source_x_0, 0), (self.blocks_add_xx_0, 0))
self.connect((self.analog_sig_source_x_0_0, 0), (self.blocks_add_xx_0_0, 0))
self.connect((self.blocks_add_xx_0, 0), (self.blocks_multiply_matrix_xx_0, 0))
self.connect((self.blocks_add_xx_0_0, 0), (self.blocks_throttle_0_0, 0))
self.connect((self.blocks_multiply_matrix_xx_0, 0), (self.doa_autocorrelate_0, 0))
self.connect((self.blocks_multiply_matrix_xx_0, 1), (self.doa_autocorrelate_0, 1))
self.connect((self.blocks_multiply_matrix_xx_0, 2), (self.doa_autocorrelate_0, 2))
self.connect((self.blocks_multiply_matrix_xx_0, 3), (self.doa_autocorrelate_0, 3))
self.connect((self.blocks_throttle_0_0, 0), (self.blocks_multiply_matrix_xx_0, 1))
self.connect((self.blocks_vector_to_streams_0, 0), (self.doa_compass, 0))
self.connect((self.blocks_vector_to_streams_0, 1), (self.doa_compass_0, 0))
self.connect((self.doa_MUSIC_lin_array_0, 0), (self.doa_find_local_max_0, 0))
self.connect((self.doa_MUSIC_lin_array_0, 0), (self.qtgui_vector_sink_f_0, 0))
self.connect((self.doa_autocorrelate_0, 0), (self.doa_MUSIC_lin_array_0, 0))
self.connect((self.doa_find_local_max_0, 0), (self.blocks_null_sink_0, 0))
self.connect((self.doa_find_local_max_0, 1), (self.blocks_vector_to_streams_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.Nt = Nt = 2
self.dft_coef = dft_coef = np.exp(-2*np.pi*1j/Nt)
self.A = A = np.arange(Nt)[np.newaxis]
self.tlen = tlen = 4000
self.samp_rate = samp_rate = 100000
self.dft_matrix = dft_matrix = np.power(dft_coef, np.dot(A.transpose(),A))
self.scramble_2 = scramble_2 = 2*np.random.random_integers(0,1,size=(tlen,Nt))-1
self.scramble_1 = scramble_1 = 2*np.random.random_integers(0,1,size=(tlen,Nt))-1
self.prefix = prefix = '/home/zhe/gr-PWF/examples'
self.noise = noise = [np.identity(Nt), np.identity(Nt)]
self.max_iteration = max_iteration = 20
self.interpo = interpo = samp_rate/1000
self.dft_pilot_seq = dft_pilot_seq = np.tile(dft_matrix,(tlen/Nt,1))
self.Q = Q = 4
self.L = L = 2
self.sigmagenfile = sigmagenfile = prefix+'/sigmagens/sigmagen_10.bin'
self.pulse = pulse = filter.firdes.root_raised_cosine(Q,Q,1,0.35,11*Q)
self.prewhiten1 = prewhiten1 = np.linalg.pinv(noise[1])
self.prewhiten0 = prewhiten0 = np.linalg.pinv(noise[0])
self.pilot_seq_2 = pilot_seq_2 = np.multiply(dft_pilot_seq,scramble_2)
self.pilot_seq_1 = pilot_seq_1 = np.multiply(dft_pilot_seq,scramble_1)
self.pilot2file = pilot2file = prefix+'/pilots/pilot2_4000.bin'
self.pilot1file = pilot1file = prefix+'/pilots/pilot1_4000.bin'
self.payload_size = payload_size = 0
self.npoints = npoints = max_iteration*interpo
self.noise_hat = noise_hat = [np.identity(Nt), np.identity(Nt)]
self.ichn_gain_dB = ichn_gain_dB = 10
self.channelfile = channelfile = prefix+'/channels/2x2channel_10dB_3.bin'
self.channel = channel = np.true_divide(np.random.standard_normal(size=(L,L,Nt,Nt))+np.random.standard_normal(size=(L,L,Nt,Nt))*1j,np.sqrt(2))
self.Pt = Pt = 100
##################################################
# Blocks
##################################################
self.qtgui_time_sink_x_0 = qtgui.time_sink_f(
npoints, #size
samp_rate, #samp_rate
"Strong Interference (ichn_gain = 10dB)", #name
2 #number of inputs
)
self.qtgui_time_sink_x_0.set_update_time(0.1)
self.qtgui_time_sink_x_0.set_y_axis(0, 20)
self.qtgui_time_sink_x_0.set_y_label("Weighted Sum-Rate (bits/s/Hz)", "")
self.qtgui_time_sink_x_0.enable_tags(-1, True)
self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_AUTO, qtgui.TRIG_SLOPE_POS, 0.0, 0, 0, "")
self.qtgui_time_sink_x_0.enable_autoscale(True)
self.qtgui_time_sink_x_0.enable_grid(True)
self.qtgui_time_sink_x_0.enable_control_panel(False)
if not True:
self.qtgui_time_sink_x_0.disable_legend()
labels = ["Dual Link", "Identity Sigma", "", "", "",
"", "", "", "", ""]
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "green", "black", "cyan",
"magenta", "yellow", "dark red", "dark green", "blue"]
styles = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
markers = [-1, -1, -1, -1, -1,
-1, -1, -1, -1, -1]
alphas = [1.0, 1.0, 1.0, 1.0, 1.0,
1.0, 1.0, 1.0, 1.0, 1.0]
for i in xrange(2):
if len(labels[i]) == 0:
self.qtgui_time_sink_x_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_time_sink_x_0.set_line_label(i, labels[i])
self.qtgui_time_sink_x_0.set_line_width(i, widths[i])
self.qtgui_time_sink_x_0.set_line_color(i, colors[i])
self.qtgui_time_sink_x_0.set_line_style(i, styles[i])
self.qtgui_time_sink_x_0.set_line_marker(i, markers[i])
self.qtgui_time_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_time_sink_x_0_win = sip.wrapinstance(self.qtgui_time_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_layout.addWidget(self._qtgui_time_sink_x_0_win)
self.phase_corrector_0_2 = phase_corrector(
loop_bandwidth=2*np.pi*0.005,
max_freq=2*np.pi*0.01,
training_sequence=pilot_seq_1[:,0],
)
self.phase_corrector_0_1_0 = phase_corrector(
loop_bandwidth=2*np.pi*0.005,
max_freq=2*np.pi*0.01,
training_sequence=pilot_seq_2[:,0],
)
self.phase_corrector_0_1 = phase_corrector(
loop_bandwidth=2*np.pi*0.005,
max_freq=2*np.pi*0.01,
training_sequence=pilot_seq_2[:,0],
)
self.phase_corrector_0_0_1 = phase_corrector(
loop_bandwidth=2*np.pi*0.005,
max_freq=2*np.pi*0.01,
training_sequence=pilot_seq_1[:,1],
)
self.phase_corrector_0_0_0_0 = phase_corrector(
loop_bandwidth=2*np.pi*0.005,
max_freq=2*np.pi*0.01,
training_sequence=pilot_seq_2[:,1],
)
self.phase_corrector_0_0_0 = phase_corrector(
loop_bandwidth=2*np.pi*0.005,
max_freq=2*np.pi*0.01,
training_sequence=pilot_seq_2[:,1],
)
self.phase_corrector_0_0 = phase_corrector(
loop_bandwidth=2*np.pi*0.005,
max_freq=2*np.pi*0.01,
training_sequence=pilot_seq_1[:,1],
)
self.phase_corrector_0 = phase_corrector(
loop_bandwidth=2*np.pi*0.005,
max_freq=2*np.pi*0.01,
training_sequence=pilot_seq_1[:,0],
)
self.interp_fir_filter_xxx_0_1_0 = filter.interp_fir_filter_ccc(Q, (pulse))
self.interp_fir_filter_xxx_0_1_0.declare_sample_delay(0)
self.interp_fir_filter_xxx_0_1 = filter.interp_fir_filter_ccc(Q, (pulse))
self.interp_fir_filter_xxx_0_1.declare_sample_delay(0)
self.interp_fir_filter_xxx_0_0 = filter.interp_fir_filter_ccc(Q, (pulse))
self.interp_fir_filter_xxx_0_0.declare_sample_delay(0)
self.interp_fir_filter_xxx_0 = filter.interp_fir_filter_ccc(Q, (pulse))
self.interp_fir_filter_xxx_0.declare_sample_delay(0)
self.fir_filter_xxx_0_1 = filter.fir_filter_ccc(Q, (pulse))
self.fir_filter_xxx_0_1.declare_sample_delay(0)
self.fir_filter_xxx_0_0_0 = filter.fir_filter_ccc(Q, (pulse))
self.fir_filter_xxx_0_0_0.declare_sample_delay(0)
self.fir_filter_xxx_0_0 = filter.fir_filter_ccc(Q, (pulse))
self.fir_filter_xxx_0_0.declare_sample_delay(0)
self.fir_filter_xxx_0 = filter.fir_filter_ccc(Q, (pulse))
self.fir_filter_xxx_0.declare_sample_delay(0)
self.blocks_vector_to_streams_1_2 = blocks.vector_to_streams(gr.sizeof_gr_complex*1, 2)
self.blocks_vector_to_streams_1_1_1 = blocks.vector_to_streams(gr.sizeof_gr_complex*1, 2)
self.blocks_vector_to_streams_1_1_0_0 = blocks.vector_to_streams(gr.sizeof_gr_complex*1, 2)
self.blocks_vector_to_streams_1_1_0 = blocks.vector_to_streams(gr.sizeof_gr_complex*1, 2)
self.blocks_vector_to_streams_1_1 = blocks.vector_to_streams(gr.sizeof_gr_complex*1, 2)
self.blocks_vector_to_streams_1_0_0 = blocks.vector_to_streams(gr.sizeof_gr_complex*1, 2)
self.blocks_vector_to_streams_1_0 = blocks.vector_to_streams(gr.sizeof_gr_complex*1, 2)
self.blocks_vector_to_streams_1 = blocks.vector_to_streams(gr.sizeof_gr_complex*1, 2)
self.blocks_vector_to_streams_0 = blocks.vector_to_streams(gr.sizeof_gr_complex*4, 2)
self.blocks_udp_source_1 = blocks.udp_source(gr.sizeof_gr_complex*8, "127.0.0.1", 1234, 1472, True)
self.blocks_udp_sink_1_0 = blocks.udp_sink(gr.sizeof_gr_complex*8, "127.0.0.1", 1234, 1472, True)
self.blocks_udp_sink_1 = blocks.udp_sink(gr.sizeof_gr_complex*8, "127.0.0.1", 1234, 1472, True)
self.blocks_streams_to_vector_1_2 = blocks.streams_to_vector(gr.sizeof_gr_complex*1, 2)
self.blocks_streams_to_vector_1_1_1 = blocks.streams_to_vector(gr.sizeof_gr_complex*1, 2)
self.blocks_streams_to_vector_1_1_0_0 = blocks.streams_to_vector(gr.sizeof_gr_complex*1, 2)
self.blocks_streams_to_vector_1_1_0 = blocks.streams_to_vector(gr.sizeof_gr_complex*1, 2)
self.blocks_streams_to_vector_1_1 = blocks.streams_to_vector(gr.sizeof_gr_complex*1, 2)
self.blocks_streams_to_vector_1_0_0 = blocks.streams_to_vector(gr.sizeof_gr_complex*1, 2)
self.blocks_streams_to_vector_1_0 = blocks.streams_to_vector(gr.sizeof_gr_complex*1, 2)
self.blocks_streams_to_vector_1 = blocks.streams_to_vector(gr.sizeof_gr_complex*1, 2)
self.blocks_streams_to_vector_0_0 = blocks.streams_to_vector(gr.sizeof_gr_complex*4, 2)
self.blocks_streams_to_vector_0 = blocks.streams_to_vector(gr.sizeof_gr_complex*4, 2)
self.blocks_repeat_0_0 = blocks.repeat(gr.sizeof_float*1, interpo)
self.blocks_repeat_0 = blocks.repeat(gr.sizeof_float*1, interpo)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_gr_complex*8, "/home/zhe/Dropbox/gnuradio_trunk/gnufiles/udp", False)
self.blocks_file_sink_0.set_unbuffered(True)
self.PWF_weighted_sum_rate_0 = PWF.weighted_sum_rate(L, Nt, Pt, channel, ichn_gain_dB, [1,1],[prewhiten0 ,prewhiten1], False, channelfile)
self.PWF_sigmagen_0 = PWF.sigmagen(L, Nt, Pt, True, sigmagenfile)
self.PWF_power_adjust_1_0 = PWF.power_adjust(Nt, Pt, L)
self.PWF_power_adjust_1 = PWF.power_adjust(Nt, Pt, L)
self.PWF_pilot_receive_tx_0_0 = PWF.pilot_receive_tx(True, pilot1file, pilot_seq_1, Nt, tlen,noise_hat[0], tlen, 1)
self.PWF_pilot_receive_tx_0 = PWF.pilot_receive_tx(True, pilot2file, pilot_seq_2, Nt, tlen,noise_hat[1], tlen, 1)
self.PWF_pilot_receive_rx_0_0 = PWF.pilot_receive_rx(True, pilot2file, pilot_seq_2, prewhiten1, Nt, tlen, tlen+payload_size, 1)
self.PWF_pilot_receive_rx_0 = PWF.pilot_receive_rx(True, pilot1file, pilot_seq_1, prewhiten0, Nt, tlen, tlen+payload_size, 1)
self.PWF_pilot_gen_tx_0_0 = PWF.pilot_gen_tx(Nt, tlen, pilot_seq_2, True, pilot2file)
self.PWF_pilot_gen_tx_0 = PWF.pilot_gen_tx(Nt, tlen, pilot_seq_1, True, pilot1file)
self.PWF_pilot_gen_rx_0_0 = PWF.pilot_gen_rx(Nt, tlen, prewhiten0, pilot_seq_1, True, pilot1file)
self.PWF_pilot_gen_rx_0 = PWF.pilot_gen_rx(Nt, tlen, prewhiten1, pilot_seq_2, True, pilot2file)
self.PWF_debug_printmsg_0 = PWF.debug_printmsg(L, Nt, False, 20)
self.PWF_channel_1 = PWF.channel(L, Nt, ichn_gain_dB, channel, False,noise_hat, False, channelfile)
self.PWF_channel_0 = PWF.channel(L, Nt, ichn_gain_dB, channel, True,noise, True, channelfile)
##################################################
# Connections
##################################################
self.connect((self.PWF_channel_0, 0), (self.blocks_vector_to_streams_1_1, 0))
self.connect((self.PWF_channel_0, 1), (self.blocks_vector_to_streams_1_1_0, 0))
self.connect((self.PWF_channel_1, 1), (self.blocks_vector_to_streams_1_1_0_0, 0))
self.connect((self.PWF_channel_1, 0), (self.blocks_vector_to_streams_1_1_1, 0))
self.connect((self.PWF_debug_printmsg_0, 0), (self.PWF_pilot_gen_tx_0, 0))
self.connect((self.PWF_debug_printmsg_0, 1), (self.PWF_pilot_gen_tx_0_0, 0))
self.connect((self.PWF_pilot_gen_rx_0, 0), (self.blocks_vector_to_streams_1_0_0, 0))
self.connect((self.PWF_pilot_gen_rx_0_0, 0), (self.blocks_vector_to_streams_1_2, 0))
self.connect((self.PWF_pilot_gen_tx_0, 0), (self.blocks_vector_to_streams_1, 0))
self.connect((self.PWF_pilot_gen_tx_0_0, 0), (self.blocks_vector_to_streams_1_0, 0))
self.connect((self.PWF_pilot_receive_rx_0, 0), (self.PWF_power_adjust_1, 0))
self.connect((self.PWF_pilot_receive_rx_0_0, 0), (self.PWF_power_adjust_1, 1))
self.connect((self.PWF_pilot_receive_tx_0, 0), (self.PWF_power_adjust_1_0, 1))
self.connect((self.PWF_pilot_receive_tx_0_0, 0), (self.PWF_power_adjust_1_0, 0))
self.connect((self.PWF_power_adjust_1, 1), (self.PWF_pilot_gen_rx_0, 0))
self.connect((self.PWF_power_adjust_1, 0), (self.PWF_pilot_gen_rx_0_0, 0))
self.connect((self.PWF_power_adjust_1_0, 0), (self.blocks_streams_to_vector_0_0, 0))
self.connect((self.PWF_power_adjust_1_0, 1), (self.blocks_streams_to_vector_0_0, 1))
self.connect((self.PWF_sigmagen_0, 0), (self.blocks_streams_to_vector_0, 0))
self.connect((self.PWF_sigmagen_0, 1), (self.blocks_streams_to_vector_0, 1))
self.connect((self.PWF_weighted_sum_rate_0, 0), (self.blocks_repeat_0, 0))
self.connect((self.PWF_weighted_sum_rate_0, 1), (self.blocks_repeat_0_0, 0))
self.connect((self.blocks_repeat_0, 0), (self.qtgui_time_sink_x_0, 0))
self.connect((self.blocks_repeat_0_0, 0), (self.qtgui_time_sink_x_0, 1))
self.connect((self.blocks_streams_to_vector_0, 0), (self.blocks_udp_sink_1, 0))
self.connect((self.blocks_streams_to_vector_0_0, 0), (self.blocks_udp_sink_1_0, 0))
self.connect((self.blocks_streams_to_vector_1, 0), (self.PWF_channel_0, 0))
self.connect((self.blocks_streams_to_vector_1_0, 0), (self.PWF_channel_0, 1))
self.connect((self.blocks_streams_to_vector_1_0_0, 0), (self.PWF_channel_1, 1))
self.connect((self.blocks_streams_to_vector_1_1, 0), (self.PWF_pilot_receive_rx_0, 0))
self.connect((self.blocks_streams_to_vector_1_1_0, 0), (self.PWF_pilot_receive_rx_0_0, 0))
self.connect((self.blocks_streams_to_vector_1_1_0_0, 0), (self.PWF_pilot_receive_tx_0, 0))
self.connect((self.blocks_streams_to_vector_1_1_1, 0), (self.PWF_pilot_receive_tx_0_0, 0))
self.connect((self.blocks_streams_to_vector_1_2, 0), (self.PWF_channel_1, 0))
self.connect((self.blocks_udp_source_1, 0), (self.blocks_file_sink_0, 0))
self.connect((self.blocks_udp_source_1, 0), (self.blocks_vector_to_streams_0, 0))
self.connect((self.blocks_vector_to_streams_0, 0), (self.PWF_debug_printmsg_0, 0))
self.connect((self.blocks_vector_to_streams_0, 1), (self.PWF_debug_printmsg_0, 1))
self.connect((self.blocks_vector_to_streams_0, 0), (self.PWF_weighted_sum_rate_0, 0))
self.connect((self.blocks_vector_to_streams_0, 1), (self.PWF_weighted_sum_rate_0, 1))
self.connect((self.blocks_vector_to_streams_1, 0), (self.interp_fir_filter_xxx_0, 0))
self.connect((self.blocks_vector_to_streams_1, 1), (self.interp_fir_filter_xxx_0_1, 0))
self.connect((self.blocks_vector_to_streams_1_0, 0), (self.interp_fir_filter_xxx_0_0, 0))
self.connect((self.blocks_vector_to_streams_1_0, 1), (self.interp_fir_filter_xxx_0_1_0, 0))
self.connect((self.blocks_vector_to_streams_1_0_0, 0), (self.blocks_streams_to_vector_1_0_0, 0))
self.connect((self.blocks_vector_to_streams_1_0_0, 1), (self.blocks_streams_to_vector_1_0_0, 1))
self.connect((self.blocks_vector_to_streams_1_1, 0), (self.fir_filter_xxx_0, 0))
self.connect((self.blocks_vector_to_streams_1_1, 1), (self.fir_filter_xxx_0_0, 0))
self.connect((self.blocks_vector_to_streams_1_1_0, 1), (self.fir_filter_xxx_0_0_0, 0))
self.connect((self.blocks_vector_to_streams_1_1_0, 0), (self.fir_filter_xxx_0_1, 0))
self.connect((self.blocks_vector_to_streams_1_1_0_0, 1), (self.phase_corrector_0_0_0_0, 0))
self.connect((self.blocks_vector_to_streams_1_1_0_0, 0), (self.phase_corrector_0_1_0, 0))
self.connect((self.blocks_vector_to_streams_1_1_1, 1), (self.phase_corrector_0_0_1, 0))
self.connect((self.blocks_vector_to_streams_1_1_1, 0), (self.phase_corrector_0_2, 0))
self.connect((self.blocks_vector_to_streams_1_2, 1), (self.blocks_streams_to_vector_1_2, 1))
self.connect((self.blocks_vector_to_streams_1_2, 0), (self.blocks_streams_to_vector_1_2, 0))
self.connect((self.fir_filter_xxx_0, 0), (self.phase_corrector_0, 0))
self.connect((self.fir_filter_xxx_0_0, 0), (self.phase_corrector_0_0, 0))
self.connect((self.fir_filter_xxx_0_0_0, 0), (self.phase_corrector_0_0_0, 0))
self.connect((self.fir_filter_xxx_0_1, 0), (self.phase_corrector_0_1, 0))
self.connect((self.interp_fir_filter_xxx_0, 0), (self.blocks_streams_to_vector_1, 0))
self.connect((self.interp_fir_filter_xxx_0_0, 0), (self.blocks_streams_to_vector_1_0, 0))
self.connect((self.interp_fir_filter_xxx_0_1, 0), (self.blocks_streams_to_vector_1, 1))
self.connect((self.interp_fir_filter_xxx_0_1_0, 0), (self.blocks_streams_to_vector_1_0, 1))
self.connect((self.phase_corrector_0, 0), (self.blocks_streams_to_vector_1_1, 0))
self.connect((self.phase_corrector_0_0, 0), (self.blocks_streams_to_vector_1_1, 1))
self.connect((self.phase_corrector_0_0_0, 0), (self.blocks_streams_to_vector_1_1_0, 1))
self.connect((self.phase_corrector_0_0_0_0, 0), (self.blocks_streams_to_vector_1_1_0_0, 1))
self.connect((self.phase_corrector_0_0_1, 0), (self.blocks_streams_to_vector_1_1_1, 1))
self.connect((self.phase_corrector_0_1, 0), (self.blocks_streams_to_vector_1_1_0, 0))
self.connect((self.phase_corrector_0_1_0, 0), (self.blocks_streams_to_vector_1_1_0_0, 0))
self.connect((self.phase_corrector_0_2, 0), (self.blocks_streams_to_vector_1_1_1, 0))
def __init__(self,
center_freq,
samp_rate,
gain,
fsk_deviation_hz,
baseband_file_name,
baseband_samp_rate,
freq_hop_list,
verbose=False,
hardware_transmit_enable=True,
hw_sel=0,
hw_gain=0,
iq_file_out=False):
gr.top_block.__init__(self)
# display the parameters used for transmit
if True: #verbose:
print "Baseband File Name: {}".format(baseband_file_name)
print "Baseband Sample Rate: {}".format(baseband_samp_rate)
print "SDR Center Freq: {}".format(center_freq)
print "SDR Sample Rate: {}".format(samp_rate)
print "Flowgraph Gain: {}".format(gain)
print "GFSK deviation: {}".format(fsk_deviation_hz)
print "Freq 0-2: {}".format(freq_hop_list)
print "Verbose: {}".format(verbose)
print "Hardware TX Enable: {}".format(hardware_transmit_enable)
print "IQ to File: {}".format(iq_file_out)
##################################################
# Variables
##################################################
self.center_freq = center_freq
self.samp_rate = samp_rate
self.gain = gain
self.fsk_deviation_hz = fsk_deviation_hz
self.baseband_file_name = baseband_file_name
self.baseband_samp_rate = baseband_samp_rate
self.freq_hop_list = freq_hop_list
self.hw_sel = hw_sel
self.hw_gain = hw_gain
"""
r = gr.enable_realtime_scheduling()
if r == gr.RT_OK:
print "Note: Realtime scheduling enabled"
"""
# self.cutoff_freq = channel_width/2
##################################################
# Blocks
##################################################
# replace this with a message source
#self.blocks_file_source_0 = blocks.file_source(
# gr.sizeof_char * 1,
# baseband_file_name,
# repeat)
# message sink is primary method of getting baseband data into
# the flowgraph
#self.source_queue = gr.msg_queue()
#self.blocks_message_source_0 = blocks.message_source(
# gr.sizeof_char*1,
# self.source_queue)
#self.blocks_message_source_0.set_max_output_buffer(1)
# TESTING FLOWGRAPH ONLY (DELETE WHEN DONE)
#blocks_message_sink_0_msgq_out = blocks_message_source_0_msgq_in = gr.msg_queue(2)
#self.blocks_vector_source_x_0 = blocks.vector_source_b((1, 0, 0, 1), True, 4, [])
#self.blocks_message_sink_0 = blocks.message_sink(gr.sizeof_char * 4, blocks_message_sink_0_msgq_out, False)
#self.connect((self.blocks_vector_source_x_0, 0), (self.blocks_message_sink_0, 0))
self.source_queue_v = gr.msg_queue()
#self.source_queue_v = gr.msg_queue(2048) # smaller values cause hang
self.blocks_message_source_0 = blocks.message_source(
gr.sizeof_char * 4, self.source_queue_v)
self.blocks_vector_to_streams = blocks.vector_to_streams(
gr.sizeof_char * 1, 4)
self.connect((self.blocks_message_source_0, 0),
(self.blocks_vector_to_streams, 0))
# blocks and connections for carrier for first hop frequency
self.analog_sig_source_0 = analog.sig_source_c(
samp_rate, analog.GR_COS_WAVE, freq_hop_list[0] - center_freq, 1,
0)
self.repeat_0 = blocks.repeat(gr.sizeof_char * 1,
int(samp_rate / baseband_samp_rate))
self.blocks_uchar_to_float_0 = blocks.uchar_to_float()
self.blocks_float_to_complex_0 = blocks.float_to_complex(1)
self.blocks_multiply_0 = blocks.multiply_vcc(1)
self.connect((self.blocks_vector_to_streams, 1), (self.repeat_0, 0))
self.connect((self.repeat_0, 0), (self.blocks_uchar_to_float_0, 0))
self.connect((self.blocks_uchar_to_float_0, 0),
(self.blocks_float_to_complex_0, 0))
self.connect((self.blocks_uchar_to_float_0, 0),
(self.blocks_float_to_complex_0, 1))
self.connect((self.blocks_float_to_complex_0, 0),
(self.blocks_multiply_0, 1))
self.connect((self.analog_sig_source_0, 0),
(self.blocks_multiply_0, 0))
# blocks and connections for carrier for second hop frequency
self.analog_sig_source_1 = analog.sig_source_c(
samp_rate, analog.GR_COS_WAVE, freq_hop_list[1] - center_freq, 1,
0)
self.repeat_1 = blocks.repeat(gr.sizeof_char * 1,
int(samp_rate / baseband_samp_rate))
self.blocks_uchar_to_float_1 = blocks.uchar_to_float()
self.blocks_float_to_complex_1 = blocks.float_to_complex(1)
self.blocks_multiply_1 = blocks.multiply_vcc(1)
self.connect((self.blocks_vector_to_streams, 2), (self.repeat_1, 0))
self.connect((self.repeat_1, 0), (self.blocks_uchar_to_float_1, 0))
self.connect((self.blocks_uchar_to_float_1, 0),
(self.blocks_float_to_complex_1, 0))
self.connect((self.blocks_uchar_to_float_1, 0),
(self.blocks_float_to_complex_1, 1))
self.connect((self.blocks_float_to_complex_1, 0),
(self.blocks_multiply_1, 1))
self.connect((self.analog_sig_source_1, 0),
(self.blocks_multiply_1, 0))
# blocks and connections for carrier for third hop frequency
self.analog_sig_source_2 = analog.sig_source_c(
samp_rate, analog.GR_COS_WAVE, freq_hop_list[2] - center_freq, 1,
0)
self.repeat_2 = blocks.repeat(gr.sizeof_char * 1,
int(samp_rate / baseband_samp_rate))
self.blocks_uchar_to_float_2 = blocks.uchar_to_float()
self.blocks_float_to_complex_2 = blocks.float_to_complex(1)
self.blocks_multiply_2 = blocks.multiply_vcc(1)
self.connect((self.blocks_vector_to_streams, 3), (self.repeat_2, 0))
self.connect((self.repeat_2, 0), (self.blocks_uchar_to_float_2, 0))
self.connect((self.blocks_uchar_to_float_2, 0),
(self.blocks_float_to_complex_2, 0))
self.connect((self.blocks_uchar_to_float_2, 0),
(self.blocks_float_to_complex_2, 1))
self.connect((self.blocks_float_to_complex_2, 0),
(self.blocks_multiply_2, 1))
self.connect((self.analog_sig_source_2, 0),
(self.blocks_multiply_2, 0))
# now add the three gated carrier together; the selected
# one will pass through
self.blocks_add = blocks.add_vcc(1)
self.connect((self.blocks_multiply_0, 0), (self.blocks_add, 0))
self.connect((self.blocks_multiply_1, 0), (self.blocks_add, 1))
self.connect((self.blocks_multiply_2, 0), (self.blocks_add, 2))
# all of the baseband data goes to the modulation chain
self.blocks_unpacked_to_packed = blocks.unpacked_to_packed_bb(
1, gr.GR_MSB_FIRST)
self.digital_gfsk_mod = digital.gfsk_mod(
samples_per_symbol=int(samp_rate / baseband_samp_rate),
sensitivity=(2 * math.pi * (fsk_deviation_hz / 2)) / samp_rate,
bt=0.35,
verbose=False,
log=False,
)
self.connect((self.blocks_vector_to_streams, 0),
(self.blocks_unpacked_to_packed, 0))
self.connect((self.blocks_unpacked_to_packed, 0),
(self.digital_gfsk_mod, 0))
# use the passed-through carrier to tune/modulate the gfsk output
self.blocks_multiply_tune = blocks.multiply_vcc(1)
self.connect((self.digital_gfsk_mod, 0),
(self.blocks_multiply_tune, 0))
self.connect((self.blocks_add, 0), (self.blocks_multiply_tune, 1))
# setup osmocom block for HackRF control
# NEED: add control switch for USRP models
if hardware_transmit_enable:
if self.hw_sel == 0:
self.osmosdr_sink = osmosdr.sink(args="numchan=" + str(1) +
" " + "")
self.osmosdr_sink.set_sample_rate(samp_rate)
self.osmosdr_sink.set_center_freq(center_freq, 0)
self.osmosdr_sink.set_freq_corr(0, 0)
self.osmosdr_sink.set_gain(hw_gain, 0)
self.osmosdr_sink.set_if_gain(20, 0)
self.osmosdr_sink.set_bb_gain(20, 0)
self.osmosdr_sink.set_antenna("", 0)
self.osmosdr_sink.set_bandwidth(0, 0)
self.connect((self.blocks_multiply_tune, 0),
(self.osmosdr_sink, 0))
elif self.hw_sel == 1:
self.uhd_usrp_sink_0 = uhd.usrp_sink(
",".join(("", "")),
uhd.stream_args(
cpu_format="fc32",
channels=range(1),
),
)
self.uhd_usrp_sink_0.set_samp_rate(samp_rate)
self.uhd_usrp_sink_0.set_center_freq(center_freq, 0)
self.uhd_usrp_sink_0.set_gain(hw_gain, 0)
self.uhd_usrp_sink_0.set_antenna('TX/RX', 0)
self.connect((self.blocks_multiply_tune, 0),
(self.uhd_usrp_sink_0, 0))
# this file sink provides an IQ capture of the RF
# being transmitted by this app; the resulting file
# is used for debugging only and should be disabled
# under normal use
if iq_file_out:
self.blocks_file_sink_iq = blocks.file_sink(
gr.sizeof_gr_complex * 1, "takeover_output_c435M_s8M.iq",
False)
self.blocks_file_sink_iq.set_unbuffered(False)
self.connect((self.blocks_multiply_tune, 0),
(self.blocks_file_sink_iq, 0))
# attempts to decrease latency
#self.blocks_message_source_0.set_max_noutput_items(128)
#self.blocks_multiply_tune.set_max_noutput_items(512)
buffer_size = 1
self.blocks_message_source_0.set_max_output_buffer(buffer_size)
self.blocks_vector_to_streams.set_max_output_buffer(buffer_size)
def __init__(self):
gr.top_block.__init__(self, "Top Block")
##################################################
# Variables
##################################################
self.fsk_deviation_hz = fsk_deviation_hz = 15e3
self.channel_width = channel_width = fsk_deviation_hz * 1.3
self.t_width = t_width = channel_width / 10
self.samp_rate = samp_rate = 8e6
self.freq2 = freq2 = 433.777e6
self.freq1 = freq1 = 434.138e6
self.freq0 = freq0 = 433.178e6
self.channel_filter_taps = channel_filter_taps = firdes.low_pass(
1, samp_rate, channel_width, t_width)
self.center_freq = center_freq = 435e6
self.baseband_samp_rate = baseband_samp_rate = 16e3
##################################################
# Message Queues
##################################################
#blocks_message_sink_0_msgq_out = blocks_message_source_0_msgq_in = gr.msg_queue(2)
self.blocks_message_source_0_msgq_in = gr.msg_queue()
##################################################
# Blocks
##################################################
self.digital_gfsk_mod_0 = digital.gfsk_mod(
samples_per_symbol=int(samp_rate / baseband_samp_rate),
sensitivity=(2 * math.pi * (fsk_deviation_hz / 2)) / samp_rate,
bt=0.35,
verbose=False,
log=False,
)
self.blocks_vector_to_streams_0 = blocks.vector_to_streams(
gr.sizeof_char * 1, 4)
self.blocks_vector_source_x_0 = blocks.vector_source_b((1, 0, 0, 1),
True, 4, [])
self.blocks_unpacked_to_packed_xx_0 = blocks.unpacked_to_packed_bb(
1, gr.GR_MSB_FIRST)
self.blocks_uchar_to_float_1_0_0 = blocks.uchar_to_float()
self.blocks_uchar_to_float_1_0 = blocks.uchar_to_float()
self.blocks_uchar_to_float_1 = blocks.uchar_to_float()
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex * 1,
samp_rate, True)
self.blocks_null_sink_0 = blocks.null_sink(gr.sizeof_gr_complex * 1)
self.blocks_multiply_xx_0_0_0_1 = blocks.multiply_vcc(1)
self.blocks_multiply_xx_0_0_0 = blocks.multiply_vcc(1)
self.blocks_multiply_xx_0_0 = blocks.multiply_vcc(1)
self.blocks_multiply_xx_0 = blocks.multiply_vcc(1)
self.blocks_message_source_0 = blocks.message_source(
gr.sizeof_char * 4, self.blocks_message_source_0_msgq_in)
#self.blocks_message_sink_0 = blocks.message_sink(gr.sizeof_char * 4, blocks_message_sink_0_msgq_out, False)
self.blocks_float_to_complex_0_1 = blocks.float_to_complex(1)
self.blocks_float_to_complex_0_0 = blocks.float_to_complex(1)
self.blocks_float_to_complex_0 = blocks.float_to_complex(1)
self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_gr_complex * 1,
"test.iq", False)
self.blocks_file_sink_0.set_unbuffered(False)
self.blocks_add_xx_0 = blocks.add_vcc(1)
self.analog_sig_source_x_0_0_0_1 = analog.sig_source_c(
samp_rate, analog.GR_COS_WAVE, freq2 - center_freq, 1, 0)
self.analog_sig_source_x_0_0_0 = analog.sig_source_c(
samp_rate, analog.GR_COS_WAVE, freq1 - center_freq, 1, 0)
self.analog_sig_source_x_0_0 = analog.sig_source_c(
samp_rate, analog.GR_COS_WAVE, freq0 - center_freq, 1, 0)
##################################################
# Connections
##################################################
self.connect((self.analog_sig_source_x_0_0, 0),
(self.blocks_multiply_xx_0_0, 0))
self.connect((self.analog_sig_source_x_0_0_0, 0),
(self.blocks_multiply_xx_0_0_0, 0))
self.connect((self.analog_sig_source_x_0_0_0_1, 0),
(self.blocks_multiply_xx_0_0_0_1, 0))
self.connect((self.blocks_add_xx_0, 0), (self.blocks_multiply_xx_0, 0))
self.connect((self.blocks_float_to_complex_0, 0),
(self.blocks_multiply_xx_0_0, 1))
self.connect((self.blocks_float_to_complex_0_0, 0),
(self.blocks_multiply_xx_0_0_0, 1))
self.connect((self.blocks_float_to_complex_0_1, 0),
(self.blocks_multiply_xx_0_0_0_1, 1))
self.connect((self.blocks_message_source_0, 0),
(self.blocks_vector_to_streams_0, 0))
self.connect((self.blocks_multiply_xx_0, 0),
(self.blocks_throttle_0, 0))
self.connect((self.blocks_multiply_xx_0_0, 0),
(self.blocks_add_xx_0, 0))
self.connect((self.blocks_multiply_xx_0_0_0, 0),
(self.blocks_add_xx_0, 1))
self.connect((self.blocks_multiply_xx_0_0_0_1, 0),
(self.blocks_add_xx_0, 2))
self.connect((self.blocks_throttle_0, 0), (self.blocks_file_sink_0, 0))
self.connect((self.blocks_throttle_0, 0), (self.blocks_null_sink_0, 0))
self.connect((self.blocks_uchar_to_float_1, 0),
(self.blocks_float_to_complex_0, 0))
self.connect((self.blocks_uchar_to_float_1, 0),
(self.blocks_float_to_complex_0, 1))
self.connect((self.blocks_uchar_to_float_1_0, 0),
(self.blocks_float_to_complex_0_0, 0))
self.connect((self.blocks_uchar_to_float_1_0, 0),
(self.blocks_float_to_complex_0_0, 1))
self.connect((self.blocks_uchar_to_float_1_0_0, 0),
(self.blocks_float_to_complex_0_1, 0))
self.connect((self.blocks_uchar_to_float_1_0_0, 0),
(self.blocks_float_to_complex_0_1, 1))
self.connect((self.blocks_unpacked_to_packed_xx_0, 0),
(self.digital_gfsk_mod_0, 0))
#self.connect((self.blocks_vector_source_x_0, 0), (self.blocks_message_sink_0, 0))
self.connect((self.blocks_vector_to_streams_0, 1),
(self.blocks_uchar_to_float_1, 0))
self.connect((self.blocks_vector_to_streams_0, 2),
(self.blocks_uchar_to_float_1_0, 0))
self.connect((self.blocks_vector_to_streams_0, 3),
(self.blocks_uchar_to_float_1_0_0, 0))
self.connect((self.blocks_vector_to_streams_0, 0),
(self.blocks_unpacked_to_packed_xx_0, 0))
self.connect((self.digital_gfsk_mod_0, 0),
(self.blocks_multiply_xx_0, 1))
def __init__(
self,
scrambler,
fieldSize = 4,
codewordLength = 12,
augmentingLength = 3,
continuous = True,
autocovarianceLength = 32,
distributionWidth = 32,
symbols = long(1e7),
windowSize = 16384,
selectionMethod = 'MSW'):
gr.top_block.__init__(self, "Guided Scrambling Statistical Simulation")
##################################################
# Variables
##################################################
scramblingPolynomial = scrambler
self.constellation = constellation = gs.defaultConstellation_f(fieldSize)
self.windowSize = windowSize
##################################################
# Blocks
##################################################
self.symbolGenerator = gs.SymbolGenerator_b(([1] * fieldSize), '')
self.guidedScrambler = gs.GuidedScrambler_bb(
fieldSize,
codewordLength,
augmentingLength,
continuous,
(scrambler))
self.terminator = gs.Terminator(1*gr.sizeof_char, symbols)
self.symbolMapper = gs.SymbolMapper_bc((constellation))
self.integrate = gs.Integrate_cc(1)
self.streamToVector = blocks.stream_to_vector(
gr.sizeof_gr_complex*1,
codewordLength)
self.vectorToStreams = blocks.vector_to_streams(
gr.sizeof_gr_complex*1,
codewordLength)
self.autocovariances = []
self.XXaverages = []
self.XYaverages = []
self.YXaverages = []
self.YYaverages = []
self.distributions = []
for i in range(codewordLength):
self.autocovariances.append(gs.Autocovariance_cf(
autocovarianceLength,
0,
codewordLength,
i))
self.XXaverages.append(gs.Average_ff(autocovarianceLength))
self.XYaverages.append(gs.Average_ff(autocovarianceLength))
self.YXaverages.append(gs.Average_ff(autocovarianceLength))
self.YYaverages.append(gs.Average_ff(autocovarianceLength))
self.distributions.append(gs.Distribution_cf(
distributionWidth,
1,
-distributionWidth*(1+1j)/2,
False))
self.fftStreamToVector = blocks.stream_to_vector(
gr.sizeof_gr_complex,
windowSize)
fftWindow = window.hanning(windowSize)
self.windowConstant = np.sum(np.array(fftWindow)**2)
self.fft = gr_fft.fft_vcc(
windowSize,
True,
(fftWindow),
True,
8)
self.complexToMagSquared = blocks.complex_to_mag_squared(windowSize)
self.fftAverage = gs.Average_ff(windowSize)
self.powerComplexToMagSquared = blocks.complex_to_mag_squared(1)
self.powerAverage = gs.Average_ff(1)
##################################################
# Connections
##################################################
self.connect((self.symbolGenerator, 0), (self.guidedScrambler, 0))
self.connect((self.guidedScrambler, 0), (self.symbolMapper, 0))
self.connect((self.guidedScrambler, 0), (self.terminator, 0))
self.connect((self.symbolMapper, 0), (self.integrate, 0))
self.connect((self.integrate, 0), (self.streamToVector, 0))
self.connect((self.streamToVector, 0), (self.vectorToStreams, 0))
for i in range(codewordLength):
self.connect((self.integrate, 0), (self.autocovariances[i], 0))
self.connect((self.autocovariances[i], 0), (self.XXaverages[i], 0))
self.connect((self.autocovariances[i], 1), (self.XYaverages[i], 0))
self.connect((self.autocovariances[i], 2), (self.YXaverages[i], 0))
self.connect((self.autocovariances[i], 3), (self.YYaverages[i], 0))
self.connect((self.vectorToStreams, i), (self.distributions[i], 0))
self.connect((self.symbolMapper, 0), (self.fftStreamToVector, 0))
self.connect((self.fftStreamToVector, 0), (self.fft, 0))
self.connect((self.fft, 0), (self.complexToMagSquared, 0))
self.connect((self.complexToMagSquared, 0), (self.fftAverage, 0))
self.connect((self.symbolMapper, 0), (self.powerComplexToMagSquared, 0))
self.connect((self.powerComplexToMagSquared, 0), (self.powerAverage, 0))
def __init__(self):
gr.top_block.__init__(self, "MIMO TOP FLOW 4 Tx ant")
Qt.QWidget.__init__(self)
self.setWindowTitle("MIMO TOP FLOW 4 Tx ant")
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", "MIMO_TOP_FLOW_4_TXant")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.fftl = fftl = 1024
self.samp_rate = samp_rate = fftl*15e3
self.rxant = rxant = 2
self.resampler = resampler = 400
self.frame_key = frame_key = "slot"
self.N_rb_dl = N_rb_dl = 50
##################################################
# Blocks
##################################################
self.rational_resampler_xxx_0_1 = filter.rational_resampler_ccc(
interpolation=1536*fftl/1024,
decimation=resampler,
taps=None,
fractional_bw=None,
)
self.rational_resampler_xxx_0_0 = filter.rational_resampler_ccc(
interpolation=1536*fftl/1024,
decimation=resampler,
taps=None,
fractional_bw=None,
)
self.lte_mimo_sss_sync_0 = lte_mimo_sss_sync(
N_rb_dl=N_rb_dl,
rxant=rxant,
)
self.lte_mimo_pss_sync_0 = lte_mimo_pss_sync(
rxant=rxant,
synclen=5,
fftlen=fftl,
)
self.lte_mimo_pss_based_frey_sync_0 = lte_mimo_pss_based_frey_sync(
fftlen=fftl,
rxant=rxant,
)
self.lte_mimo_ofdm_rx_0 = lte_mimo_ofdm_rx(
N_rb_dl=N_rb_dl,
ofdm_key=frame_key,
fftlen=fftl,
rxant=rxant,
)
self.lte_mimo_estimator_4_txant_0 = lte_mimo_estimator_4_txant(
N_rb_dl=N_rb_dl,
estimator_key=frame_key,
initial_id=333,
rxant=rxant,
)
self.lte_mimo_decode_pbch_4_txant_0 = lte_mimo_decode_pbch_4_txant(
N_rb_dl=N_rb_dl,
rxant=rxant,
)
self.blocks_vector_to_streams_0 = blocks.vector_to_streams(gr.sizeof_gr_complex*1, 2)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex*2, samp_rate,True)
self.blocks_file_source_0 = blocks.file_source(gr.sizeof_gr_complex*2, "/home/maier/LTE test files/live data/lte_capture_Wed_Aug_6_19:36:39_2014_RXant2_4MS_telekom_band1800_wg_karlruhe_hinten raus_messung1.dat", True)
self.bch_decode_bch_hier_gr37_0 = decode_bch_hier_gr37()
self.MIB = lte.mib_unpack_vbm("MIB")
##################################################
# Connections
##################################################
self.connect((self.lte_mimo_sss_sync_0, 0), (self.lte_mimo_estimator_4_txant_0, 0))
self.connect((self.lte_mimo_sss_sync_0, 0), (self.lte_mimo_decode_pbch_4_txant_0, 0))
self.connect((self.lte_mimo_estimator_4_txant_0, 0), (self.lte_mimo_decode_pbch_4_txant_0, 1))
self.connect((self.lte_mimo_estimator_4_txant_0, 1), (self.lte_mimo_decode_pbch_4_txant_0, 2))
self.connect((self.blocks_file_source_0, 0), (self.blocks_throttle_0, 0))
self.connect((self.lte_mimo_decode_pbch_4_txant_0, 0), (self.bch_decode_bch_hier_gr37_0, 0))
self.connect((self.bch_decode_bch_hier_gr37_0, 0), (self.MIB, 0))
self.connect((self.bch_decode_bch_hier_gr37_0, 1), (self.MIB, 1))
self.connect((self.lte_mimo_estimator_4_txant_0, 2), (self.lte_mimo_decode_pbch_4_txant_0, 3))
self.connect((self.lte_mimo_estimator_4_txant_0, 3), (self.lte_mimo_decode_pbch_4_txant_0, 4))
self.connect((self.blocks_vector_to_streams_0, 0), (self.rational_resampler_xxx_0_1, 0))
self.connect((self.blocks_vector_to_streams_0, 1), (self.rational_resampler_xxx_0_0, 0))
self.connect((self.lte_mimo_pss_sync_0, 0), (self.lte_mimo_pss_based_frey_sync_0, 0))
self.connect((self.lte_mimo_ofdm_rx_0, 0), (self.lte_mimo_sss_sync_0, 0))
self.connect((self.lte_mimo_pss_based_frey_sync_0, 0), (self.lte_mimo_ofdm_rx_0, 0))
self.connect((self.lte_mimo_pss_based_frey_sync_0, 1), (self.lte_mimo_ofdm_rx_0, 1))
self.connect((self.lte_mimo_pss_sync_0, 1), (self.lte_mimo_pss_based_frey_sync_0, 1))
self.connect((self.blocks_throttle_0, 0), (self.blocks_vector_to_streams_0, 0))
self.connect((self.rational_resampler_xxx_0_0, 0), (self.lte_mimo_pss_sync_0, 1))
self.connect((self.rational_resampler_xxx_0_1, 0), (self.lte_mimo_pss_sync_0, 0))
##################################################
# Asynch Message Connections
##################################################
self.msg_connect(self.lte_mimo_sss_sync_0, "cell_id", self.lte_mimo_estimator_4_txant_0, "cell_id")
self.msg_connect(self.lte_mimo_sss_sync_0, "cell_id", self.lte_mimo_decode_pbch_4_txant_0, "cell_id")
self.msg_connect(self.lte_mimo_pss_sync_0, "N_id_2", self.lte_mimo_sss_sync_0, "N_id_2")
def __init__(self, mpoints, taps=None):
"""
Takes M complex streams in, produces single complex stream out
that runs at M times the input sample rate
Args:
mpoints: number of freq bins/interpolation factor/subbands
taps: filter taps for subband filter
The channel spacing is equal to the input sample rate.
The total bandwidth and output sample rate are equal the input
sample rate * nchannels.
Output stream to frequency mapping:
channel zero is at zero frequency.
if mpoints is odd:
Channels with increasing positive frequencies come from
channels 1 through (N-1)/2.
Channel (N+1)/2 is the maximum negative frequency, and
frequency increases through N-1 which is one channel lower
than the zero frequency.
if mpoints is even:
Channels with increasing positive frequencies come from
channels 1 through (N/2)-1.
Channel (N/2) is evenly split between the max positive and
negative bins.
Channel (N/2)+1 is the maximum negative frequency, and
frequency increases through N-1 which is one channel lower
than the zero frequency.
Channels near the frequency extremes end up getting cut
off by subsequent filters and therefore have diminished
utility.
"""
item_size = gr.sizeof_gr_complex
gr.hier_block2.__init__(self, "synthesis_filterbank",
gr.io_signature(mpoints, mpoints, item_size), # Input signature
gr.io_signature(1, 1, item_size)) # Output signature
if taps is None:
taps = _generate_synthesis_taps(mpoints)
# pad taps to multiple of mpoints
r = len(taps) % mpoints
if r != 0:
taps = taps + (mpoints - r) * (0,)
# split in mpoints separate set of taps
sub_taps = _split_taps(taps, mpoints)
self.ss2v = blocks.streams_to_vector(item_size, mpoints)
self.ifft = fft.fft_vcc(mpoints, False, [])
self.v2ss = blocks.vector_to_streams(item_size, mpoints)
# mpoints filters go in here...
self.ss2s = blocks.streams_to_stream(item_size, mpoints)
for i in range(mpoints):
self.connect((self, i), (self.ss2v, i))
self.connect(self.ss2v, self.ifft, self.v2ss)
# build mpoints fir filters...
for i in range(mpoints):
f = fft_filter_ccc(1, sub_taps[i])
self.connect((self.v2ss, i), f)
self.connect(f, (self.ss2s, i))
self.connect(self.ss2s, self)
def __init__(self, source):
gr.top_block.__init__(self, "Vector To Streams")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate = 3e6
self.source = source
##################################################
# Blocks
##################################################
self.blocks_vector_to_streams_0 = blocks.vector_to_streams(
gr.sizeof_float * 1, 15)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_float * 15,
samp_rate, True)
self.blocks_file_source_0 = blocks.file_source(gr.sizeof_float * 15,
self.source, False)
self.blocks_file_sink_0_5 = blocks.file_sink(
gr.sizeof_float * 1,
'/home/rich/Desktop/testbed_measurements/automation/bin/tx11.bin',
False)
self.blocks_file_sink_0_5.set_unbuffered(False)
self.blocks_file_sink_0_4_1 = blocks.file_sink(
gr.sizeof_float * 1, '/home/rich/Desktop/repos/bin/tx12.bin',
False)
self.blocks_file_sink_0_4_1.set_unbuffered(False)
self.blocks_file_sink_0_4_0 = blocks.file_sink(
gr.sizeof_float * 1, '/home/rich/Desktop/repos/bin/tx7.bin', False)
self.blocks_file_sink_0_4_0.set_unbuffered(False)
self.blocks_file_sink_0_4 = blocks.file_sink(
gr.sizeof_float * 1, '/home/rich/Desktop/repos/tx2.bin', False)
self.blocks_file_sink_0_4.set_unbuffered(False)
self.blocks_file_sink_0_3_1 = blocks.file_sink(
gr.sizeof_float * 1, '/home/rich/Desktop/repos/bin/tx13.bin',
False)
self.blocks_file_sink_0_3_1.set_unbuffered(False)
self.blocks_file_sink_0_3_0 = blocks.file_sink(
gr.sizeof_float * 1, '/home/rich/Desktop/repos/bin/tx8.bin', False)
self.blocks_file_sink_0_3_0.set_unbuffered(False)
self.blocks_file_sink_0_3 = blocks.file_sink(
gr.sizeof_float * 1, '/home/rich/Desktop/repos/bin/tx3.bin', False)
self.blocks_file_sink_0_3.set_unbuffered(False)
self.blocks_file_sink_0_2_1 = blocks.file_sink(
gr.sizeof_float * 1, '/home/rich/Desktop/repos/bin/tx14.bin',
False)
self.blocks_file_sink_0_2_1.set_unbuffered(False)
self.blocks_file_sink_0_2_0 = blocks.file_sink(
gr.sizeof_float * 1, '/home/rich/Desktop/repos/bin/tx9.bin', False)
self.blocks_file_sink_0_2_0.set_unbuffered(False)
self.blocks_file_sink_0_2 = blocks.file_sink(
gr.sizeof_float * 1, '/home/rich/Desktop/repos/bin/tx4.bin', False)
self.blocks_file_sink_0_2.set_unbuffered(False)
self.blocks_file_sink_0_1 = blocks.file_sink(
gr.sizeof_float * 1, '/home/rich/Desktop/repos/bin/tx6.bin', False)
self.blocks_file_sink_0_1.set_unbuffered(False)
self.blocks_file_sink_0_0_1 = blocks.file_sink(
gr.sizeof_float * 1, '/home/rich/Desktop/repos/bin/tx15.bin',
False)
self.blocks_file_sink_0_0_1.set_unbuffered(False)
self.blocks_file_sink_0_0_0 = blocks.file_sink(
gr.sizeof_float * 1, '/home/rich/Desktop/repos/bin/tx10.bin',
False)
self.blocks_file_sink_0_0_0.set_unbuffered(False)
self.blocks_file_sink_0_0 = blocks.file_sink(
gr.sizeof_float * 1, '/home/rich/Desktop/repos/bin/tx5.bin', False)
self.blocks_file_sink_0_0.set_unbuffered(False)
self.blocks_file_sink_0 = blocks.file_sink(
gr.sizeof_float * 1, '/home/rich/Desktop/repos/bin/tx1.bin', False)
self.blocks_file_sink_0.set_unbuffered(False)
##################################################
# Connections
##################################################
self.connect((self.blocks_file_source_0, 0),
(self.blocks_throttle_0, 0))
self.connect((self.blocks_throttle_0, 0),
(self.blocks_vector_to_streams_0, 0))
self.connect((self.blocks_vector_to_streams_0, 0),
(self.blocks_file_sink_0, 0))
self.connect((self.blocks_vector_to_streams_0, 4),
(self.blocks_file_sink_0_0, 0))
self.connect((self.blocks_vector_to_streams_0, 9),
(self.blocks_file_sink_0_0_0, 0))
self.connect((self.blocks_vector_to_streams_0, 14),
(self.blocks_file_sink_0_0_1, 0))
self.connect((self.blocks_vector_to_streams_0, 5),
(self.blocks_file_sink_0_1, 0))
self.connect((self.blocks_vector_to_streams_0, 3),
(self.blocks_file_sink_0_2, 0))
self.connect((self.blocks_vector_to_streams_0, 8),
(self.blocks_file_sink_0_2_0, 0))
self.connect((self.blocks_vector_to_streams_0, 13),
(self.blocks_file_sink_0_2_1, 0))
self.connect((self.blocks_vector_to_streams_0, 2),
(self.blocks_file_sink_0_3, 0))
self.connect((self.blocks_vector_to_streams_0, 7),
(self.blocks_file_sink_0_3_0, 0))
self.connect((self.blocks_vector_to_streams_0, 12),
(self.blocks_file_sink_0_3_1, 0))
self.connect((self.blocks_vector_to_streams_0, 1),
(self.blocks_file_sink_0_4, 0))
self.connect((self.blocks_vector_to_streams_0, 6),
(self.blocks_file_sink_0_4_0, 0))
self.connect((self.blocks_vector_to_streams_0, 11),
(self.blocks_file_sink_0_4_1, 0))
self.connect((self.blocks_vector_to_streams_0, 10),
(self.blocks_file_sink_0_5, 0))
def __init__(self):
gr.top_block.__init__(self, "MIMO TOP FLOW")
##################################################
# Variables
##################################################
self.fftl = fftl = 128
self.samp_rate = samp_rate = fftl * 15e3
self.rxant = rxant = 2
self.resampler = resampler = 400
self.frame_key = frame_key = "slot"
self.N_rb_dl = N_rb_dl = 50
##################################################
# Blocks
##################################################
self.lte_mimo_sss_sync_0 = lte_mimo_sss_sync(
N_rb_dl=N_rb_dl,
rxant=rxant,
)
self.lte_mimo_pss_sync_0 = lte_mimo_pss_sync(
rxant=rxant,
synclen=5,
fftlen=fftl,
)
self.lte_mimo_pss_based_frey_sync_0 = lte_mimo_pss_based_frey_sync(
fftlen=fftl,
rxant=rxant,
)
self.lte_mimo_ofdm_rx_0 = lte_mimo_ofdm_rx(
N_rb_dl=N_rb_dl,
ofdm_key=frame_key,
fftlen=fftl,
rxant=rxant,
)
self.lte_mimo_estimator_0 = lte_mimo_estimator(
N_rb_dl=N_rb_dl,
estimator_key=frame_key,
initial_id=2,
rxant=rxant,
)
self.lte_mimo_decode_pbch_0 = lte_mimo_decode_pbch(
N_rb_dl=N_rb_dl,
rxant=rxant,
)
self.blocks_vector_to_streams_0 = blocks.vector_to_streams(
gr.sizeof_gr_complex * 1, 2)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_gr_complex * 2,
samp_rate, True)
self.blocks_streams_to_vector_0_0 = blocks.streams_to_vector(
gr.sizeof_gr_complex * 12 * N_rb_dl, 2)
self.blocks_file_source_0 = blocks.file_source(
gr.sizeof_gr_complex * 2,
"/home/johannes/src/gr-lte/tests/lte_test_data_RX2_NRBDL6.dat",
True)
self.bch_decode_bch_hier_gr37_0 = decode_bch_hier_gr37()
self.MIB = lte.mib_unpack_vbm("MIB")
##################################################
# Connections
##################################################
self.connect((self.lte_mimo_pss_sync_0, 1),
(self.lte_mimo_pss_based_frey_sync_0, 1))
self.connect((self.lte_mimo_pss_sync_0, 0),
(self.lte_mimo_pss_based_frey_sync_0, 0))
self.connect((self.lte_mimo_pss_based_frey_sync_0, 0),
(self.lte_mimo_ofdm_rx_0, 0))
self.connect((self.lte_mimo_pss_based_frey_sync_0, 1),
(self.lte_mimo_ofdm_rx_0, 1))
self.connect((self.blocks_throttle_0, 0),
(self.blocks_vector_to_streams_0, 0))
self.connect((self.blocks_file_source_0, 0),
(self.blocks_throttle_0, 0))
self.connect((self.blocks_vector_to_streams_0, 0),
(self.lte_mimo_pss_sync_0, 0))
self.connect((self.blocks_vector_to_streams_0, 1),
(self.lte_mimo_pss_sync_0, 1))
self.connect((self.lte_mimo_ofdm_rx_0, 0),
(self.lte_mimo_sss_sync_0, 0))
self.connect((self.lte_mimo_ofdm_rx_0, 1),
(self.lte_mimo_sss_sync_0, 1))
self.connect((self.lte_mimo_decode_pbch_0, 0),
(self.bch_decode_bch_hier_gr37_0, 0))
self.connect((self.lte_mimo_estimator_0, 0),
(self.lte_mimo_decode_pbch_0, 1))
self.connect((self.lte_mimo_estimator_0, 1),
(self.lte_mimo_decode_pbch_0, 2))
self.connect((self.bch_decode_bch_hier_gr37_0, 1), (self.MIB, 1))
self.connect((self.bch_decode_bch_hier_gr37_0, 0), (self.MIB, 0))
self.connect((self.lte_mimo_sss_sync_0, 1),
(self.blocks_streams_to_vector_0_0, 1))
self.connect((self.lte_mimo_sss_sync_0, 0),
(self.blocks_streams_to_vector_0_0, 0))
self.connect((self.blocks_streams_to_vector_0_0, 0),
(self.lte_mimo_estimator_0, 0))
self.connect((self.blocks_streams_to_vector_0_0, 0),
(self.lte_mimo_decode_pbch_0, 0))
##################################################
# Asynch Message Connections
##################################################
self.msg_connect(self.lte_mimo_sss_sync_0, "cell_id",
self.lte_mimo_estimator_0, "cell_id")
self.msg_connect(self.lte_mimo_pss_sync_0, "N_id_2",
self.lte_mimo_sss_sync_0, "N_id_2")
self.msg_connect(self.lte_mimo_sss_sync_0, "cell_id",
self.lte_mimo_decode_pbch_0, "cell_id")
def __init__(self):
gr.top_block.__init__(self, "Run Rootmusic Calib Lin Array Simulation")
Qt.QWidget.__init__(self)
self.setWindowTitle("Run Rootmusic Calib Lin Array Simulation")
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", "run_RootMUSIC_calib_lin_array_simulation")
self.restoreGeometry(self.settings.value("geometry").toByteArray())
##################################################
# Variables
##################################################
self.theta1_deg = theta1_deg = 123
self.theta0_deg = theta0_deg = 30
self.input_variables = input_variables = struct({
'SampleRate':
320000,
'ToneFreq1':
10000,
'ToneFreq2':
20000,
'NormSpacing':
0.44,
'NumTargets':
2,
'NumArrayElements':
4,
'PSpectrumLength':
2**10,
'SnapshotSize':
2**11,
'OverlapSize':
2**9,
'AntGains':
numpy.array([0.94984789, 0.4544107, 0.34649469, 0.25083929]),
'AntPhases':
numpy.array([0.28647672, 5.27248071, 2.71271102, 1.36970886]),
'DirectoryConfigFiles':
"/tmp",
'AntennaCalibration':
"calibration_lin_array_simulated.cfg",
})
self.theta1 = theta1 = numpy.pi * theta1_deg / 180
self.theta0 = theta0 = numpy.pi * theta0_deg / 180
self.ant_locs = ant_locs = numpy.dot(
input_variables.NormSpacing,
numpy.arange(input_variables.NumArrayElements /
2, -input_variables.NumArrayElements / 2, -1) if
(input_variables.NumArrayElements % 2 == 1) else numpy.arange(
input_variables.NumArrayElements / 2 -
0.5, -input_variables.NumArrayElements / 2 - 0.5, -1))
self.ant_coeffs = ant_coeffs = input_variables.AntGains * numpy.exp(
1j * input_variables.AntPhases)
self.amv1_true = amv1_true = numpy.exp(-1j * ant_locs * 2 * numpy.pi *
numpy.cos(theta1))
self.amv0_true = amv0_true = numpy.exp(-1j * ant_locs * 2 * numpy.pi *
numpy.cos(theta0))
self.amv1 = amv1 = numpy.multiply(ant_coeffs, amv1_true)
self.amv0 = amv0 = numpy.multiply(ant_coeffs, amv0_true)
self.array_manifold_matrix = array_manifold_matrix = numpy.array(
[amv0, amv1]).transpose()
self.antenna_calibration_file_name = antenna_calibration_file_name = os.path.join(
input_variables.DirectoryConfigFiles,
input_variables.AntennaCalibration)
##################################################
# Blocks
##################################################
self.tab = Qt.QTabWidget()
self.tab_widget_0 = Qt.QWidget()
self.tab_layout_0 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.tab_widget_0)
self.tab_grid_layout_0 = Qt.QGridLayout()
self.tab_layout_0.addLayout(self.tab_grid_layout_0)
self.tab.addTab(self.tab_widget_0, 'Direction of Arrival')
self.tab_widget_1 = Qt.QWidget()
self.tab_layout_1 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.tab_widget_1)
self.tab_grid_layout_1 = Qt.QGridLayout()
self.tab_layout_1.addLayout(self.tab_grid_layout_1)
self.tab.addTab(self.tab_widget_1, 'Direction of Arrival')
self.top_layout.addWidget(self.tab)
self._theta1_deg_range = Range(0, 180, 1, 123, 200)
self._theta1_deg_win = RangeWidget(self._theta1_deg_range,
self.set_theta1_deg, 'AoA',
"counter_slider", float)
self.top_layout.addWidget(self._theta1_deg_win)
self._theta0_deg_range = Range(0, 180, 1, 30, 200)
self._theta0_deg_win = RangeWidget(self._theta0_deg_range,
self.set_theta0_deg, 'AoA',
"counter_slider", float)
self.top_layout.addWidget(self._theta0_deg_win)
self.doa_rootMUSIC_linear_array_0 = doa.rootMUSIC_linear_array(
input_variables.NormSpacing, input_variables.NumTargets,
input_variables.NumArrayElements)
self.doa_compass_0 = doa.compass("", 0, 180, 10, 0)
self.tab_layout_1.addLayout(self.doa_compass_0.this_layout)
self.doa_compass = doa.compass("", 0, 180, 10, 0)
self.tab_layout_0.addLayout(self.doa_compass.this_layout)
self.doa_autocorrelate_0 = doa.autocorrelate(
input_variables.NumArrayElements, input_variables.SnapshotSize,
input_variables.OverlapSize, 1)
self.doa_antenna_correction_0 = doa.antenna_correction(
input_variables.NumArrayElements, antenna_calibration_file_name)
self.blocks_vector_to_streams_0 = blocks.vector_to_streams(
gr.sizeof_float * 1, input_variables.NumTargets)
self.blocks_throttle_0_0 = blocks.throttle(gr.sizeof_gr_complex * 1,
input_variables.SampleRate,
True)
self.blocks_multiply_matrix_xx_0 = blocks.multiply_matrix_cc(
array_manifold_matrix, gr.TPP_ALL_TO_ALL)
self.blocks_add_xx_0_0 = blocks.add_vcc(1)
self.blocks_add_xx_0 = blocks.add_vcc(1)
self.analog_sig_source_x_0_0 = analog.sig_source_c(
input_variables.SampleRate, analog.GR_COS_WAVE,
input_variables.ToneFreq2, 1, 0)
self.analog_sig_source_x_0 = analog.sig_source_c(
input_variables.SampleRate, analog.GR_COS_WAVE,
input_variables.ToneFreq1, 1, 0)
self.analog_noise_source_x_0_0_0 = analog.noise_source_c(
analog.GR_GAUSSIAN, 0.5, 0)
self.analog_noise_source_x_0_0 = analog.noise_source_c(
analog.GR_GAUSSIAN, 0.0005, 0)
##################################################
# Connections
##################################################
self.connect((self.analog_noise_source_x_0_0, 0),
(self.blocks_add_xx_0, 1))
self.connect((self.analog_noise_source_x_0_0_0, 0),
(self.blocks_add_xx_0_0, 1))
self.connect((self.analog_sig_source_x_0, 0),
(self.blocks_add_xx_0, 0))
self.connect((self.analog_sig_source_x_0_0, 0),
(self.blocks_add_xx_0_0, 0))
self.connect((self.blocks_add_xx_0, 0),
(self.blocks_multiply_matrix_xx_0, 0))
self.connect((self.blocks_add_xx_0_0, 0),
(self.blocks_throttle_0_0, 0))
self.connect((self.blocks_multiply_matrix_xx_0, 0),
(self.doa_antenna_correction_0, 0))
self.connect((self.blocks_multiply_matrix_xx_0, 1),
(self.doa_antenna_correction_0, 1))
self.connect((self.blocks_multiply_matrix_xx_0, 2),
(self.doa_antenna_correction_0, 2))
self.connect((self.blocks_multiply_matrix_xx_0, 3),
(self.doa_antenna_correction_0, 3))
self.connect((self.blocks_throttle_0_0, 0),
(self.blocks_multiply_matrix_xx_0, 1))
self.connect((self.blocks_vector_to_streams_0, 0),
(self.doa_compass, 0))
self.connect((self.blocks_vector_to_streams_0, 1),
(self.doa_compass_0, 0))
self.connect((self.doa_antenna_correction_0, 0),
(self.doa_autocorrelate_0, 0))
self.connect((self.doa_antenna_correction_0, 1),
(self.doa_autocorrelate_0, 1))
self.connect((self.doa_antenna_correction_0, 2),
(self.doa_autocorrelate_0, 2))
self.connect((self.doa_antenna_correction_0, 3),
(self.doa_autocorrelate_0, 3))
self.connect((self.doa_autocorrelate_0, 0),
(self.doa_rootMUSIC_linear_array_0, 0))
self.connect((self.doa_rootMUSIC_linear_array_0, 0),
(self.blocks_vector_to_streams_0, 0))
def __init__(self, mpoints, taps=None):
"""
Takes M complex streams in, produces single complex stream out
that runs at M times the input sample rate
Args:
mpoints: number of freq bins/interpolation factor/subbands
taps: filter taps for subband filter
The channel spacing is equal to the input sample rate.
The total bandwidth and output sample rate are equal the input
sample rate * nchannels.
Output stream to frequency mapping:
channel zero is at zero frequency.
if mpoints is odd:
Channels with increasing positive frequencies come from
channels 1 through (N-1)/2.
Channel (N+1)/2 is the maximum negative frequency, and
frequency increases through N-1 which is one channel lower
than the zero frequency.
if mpoints is even:
Channels with increasing positive frequencies come from
channels 1 through (N/2)-1.
Channel (N/2) is evenly split between the max positive and
negative bins.
Channel (N/2)+1 is the maximum negative frequency, and
frequency increases through N-1 which is one channel lower
than the zero frequency.
Channels near the frequency extremes end up getting cut
off by subsequent filters and therefore have diminished
utility.
"""
item_size = gr.sizeof_gr_complex
gr.hier_block2.__init__(self, "synthesis_filterbank",
gr.io_signature(mpoints, mpoints, item_size), # Input signature
gr.io_signature(1, 1, item_size)) # Output signature
if taps is None:
taps = _generate_synthesis_taps(mpoints)
# pad taps to multiple of mpoints
r = len(taps) % mpoints
if r != 0:
taps = taps + (mpoints - r) * (0,)
# split in mpoints separate set of taps
sub_taps = _split_taps(taps, mpoints)
self.ss2v = blocks.streams_to_vector(item_size, mpoints)
self.ifft = fft.fft_vcc(mpoints, False, [])
self.v2ss = blocks.vector_to_streams(item_size, mpoints)
# mpoints filters go in here...
self.ss2s = blocks.streams_to_stream(item_size, mpoints)
for i in range(mpoints):
self.connect((self, i), (self.ss2v, i))
self.connect(self.ss2v, self.ifft, self.v2ss)
# build mpoints fir filters...
for i in range(mpoints):
f = fft_filter_ccc(1, sub_taps[i])
self.connect((self.v2ss, i), f)
self.connect(f, (self.ss2s, i))
self.connect(self.ss2s, self)
def __init__(self, filenames, dev_addrs, dual,
onebit, iq, noise, mix, gain, fs, fc, unint, sync_pps):
gr.top_block.__init__(self)
if mix:
raise NotImplementedError("TODO: Hilbert remix mode not implemented.")
if dual:
channels = [0, 1]
else:
channels = [0]
uhd_sinks = [
uhd.usrp_sink(",".join(
[addr, "send_frame_size=32768,num_send_frames=128"]),
uhd.stream_args(
cpu_format="fc32",
otwformat="sc8",
channels=channels))
for addr in dev_addrs]
for sink in uhd_sinks:
a = sink.get_usrp_info()
for each in a.keys():
print each + " : " + a.get(each)
sink.set_clock_rate(fs, uhd.ALL_MBOARDS)
sink.set_samp_rate(fs)
sink.set_center_freq(fc, 0)
sink.set_gain(gain, 0)
if dual:
sink.set_center_freq(fc, 1)
sink.set_gain(gain, 1)
sink.set_subdev_spec("A:B A:A", 0)
# TODO Use offset tuning?
if sync_pps:
sink.set_clock_source("external") # 10 MHz
sink.set_time_source("external") # PPS
if unint:
if noise or onebit or not iq:
raise NotImplementedError("TODO: RX channel-interleaved mode only "
"supported for noiseless 8-bit complex.")
BLOCK_N = 16*1024*1024
demux = blocks.vector_to_streams(2, len(uhd_sinks))
self.connect(blocks.file_source(2*len(uhd_sinks)*BLOCK_N, filenames[0], False),
blocks.vector_to_stream(2*len(uhd_sinks), BLOCK_N),
demux)
for ix, sink in enumerate(uhd_sinks):
self.connect((demux, ix),
blocks.vector_to_stream(1, 2),
blocks.interleaved_char_to_complex(), # [-128.0, +127.0]
blocks.multiply_const_cc(1.0/1024), # [-0.125, 0.125)
# blocks.vector_to_stream(8, 16*1024),
sink)
else:
for i, filename in enumerate(filenames):
src = blocks.file_source(gr.sizeof_char*1, filename, False)
if dual:
channel = i % 2
sink = uhd_sinks[i/2]
else:
channel = 0
sink = uhd_sinks[i]
if iq:
node = blocks.multiply_const_cc(1.0/1024)
if onebit:
self.connect(src,
blocks.unpack_k_bits_bb(8),
blocks.char_to_short(), # [0, 1] -> [0, 256]
blocks.add_const_ss(-128), # [-128, +128],
blocks.interleaved_short_to_complex(), # [ -128.0, +128.0]
node) # [-0.125, +0.125]
else:
self.connect(src, # [-128..127]
blocks.interleaved_char_to_complex(), # [-128.0, +127.0]
node) # [-0.125, +0.125)
else:
node = blocks.float_to_complex(1)
if onebit:
self.connect(src,
blocks.unpack_k_bits_bb(8), # [0, 1] -> [-0.125, +0.125]
blocks.char_to_float(vlen=1, scale=4),
blocks.add_const_vff((-0.125, )),
node)
else:
self.connect(src, # [-128..127] -> [-0.125, +0.125)
blocks.char_to_float(vlen=1, scale=1024),
node)
if noise:
combiner = blocks.add_vcc(1)
self.connect((node, 0),
(combiner, 0),
(sink, channel))
self.connect(analog.fastnoise_source_c(analog.GR_GAUSSIAN, noise, -222, 8192),
(combiner, 1))
else:
self.connect((node, 0),
(sink, channel))
print "Setting clocks..."
if sync_pps:
time.sleep(1.1) # Ensure there's been an edge. TODO: necessary?
last_pps_time = uhd_sinks[0].get_time_last_pps()
while last_pps_time == uhd_sinks[0].get_time_last_pps():
time.sleep(0.1)
print "Got edge"
[sink.set_time_next_pps(uhd.time_spec(round(time.time())+1)) for sink in uhd_sinks]
time.sleep(1.0) # Wait for edge to set the clocks
else:
# No external PPS/10 MHz. Just set each clock and accept some skew.
t = time.time()
[sink.set_time_now(uhd.time_spec(time.time())) for sink in uhd_sinks]
if len(uhd_sinks) > 1:
print "Uncabled; loosely synced only. Initial skew ~ %.1f ms" % (
(time.time()-t) * 1000)
t_start = uhd.time_spec(time.time() + 1.5)
[sink.set_start_time(t_start) for sink in uhd_sinks]
print "ready"
