def __init__(self, freq_sample_delay_samps, freq_samps_to_avg,
mag_samps_to_avg, thresh):
gr.hier_block2.__init__(
self, "Sample and Hold Detector",
gr.io_signaturev(2, 2, [gr.sizeof_float * 1, gr.sizeof_float * 1]),
gr.io_signaturev(4, 4, [
gr.sizeof_float * 1, gr.sizeof_float * 1, gr.sizeof_float * 1,
gr.sizeof_float * 1
]))
'''
Constructor
@param freq_sample_delay_samps -
@param freq_samps_to_avg -
@param mag_samps_to_avg -
@param thresh -
'''
##################################################
# Parameters
##################################################
self.freq_sample_delay_samps = freq_sample_delay_samps
self.freq_samps_to_avg = freq_samps_to_avg
self.mag_samps_to_avg = mag_samps_to_avg
self.thresh = thresh
##################################################
# Blocks
##################################################
self.edge_detector = timing_utils.edge_detector_bb(
timing_utils.RISING_EDGE)
self.threshold = blocks.threshold_ff(thresh / 4.0, thresh, 0)
self.samp_hold = blocks.sample_and_hold_ff()
self.mag_avg = blocks.moving_average_ff(int(mag_samps_to_avg),
1.0 / (mag_samps_to_avg), 4000)
self.freq_avg = blocks.moving_average_ff(int(freq_samps_to_avg),
1.0 / (freq_samps_to_avg),
4000)
self.f2c = blocks.float_to_char(1, 1)
self.delay = blocks.delay(
gr.sizeof_float * 1,
int(freq_samps_to_avg - mag_samps_to_avg +
freq_sample_delay_samps))
##################################################
# Connections
##################################################
self.connect((self.delay, 0), (self.mag_avg, 0))
self.connect((self.f2c, 0), (self.edge_detector, 0))
self.connect((self.freq_avg, 0), (self.samp_hold, 0))
self.connect((self.freq_avg, 0), (self, 1))
self.connect((self.mag_avg, 0), (self.threshold, 0))
self.connect((self.mag_avg, 0), (self, 3))
self.connect((self.samp_hold, 0), (self, 0))
self.connect((self.threshold, 0), (self.f2c, 0))
self.connect((self.threshold, 0), (self, 2))
self.connect((self, 0), (self.delay, 0))
self.connect((self, 1), (self.freq_avg, 0))
self.connect((self.edge_detector, 0), (self.samp_hold, 1))
def _update_filtered(self, translated): if translated is not None and self._taps is not None: filtered = TimeData(numpy.complex64(scipy.signal.lfilter(self._taps, 1, translated.samples)), translated.sampling_rate) filtered_abs = filtered.abs data_source = filtered_abs.samples numpy_source = NumpySource(data_source) peak_detector = blocks.peak_detector_fb(1.0, 0.3, 10, 0.001) sample_and_hold = blocks.sample_and_hold_ff() multiply_const = blocks.multiply_const_vff((0.5, )) subtract = blocks.sub_ff(1) numpy_sink = NumpySink(numpy.float32) top = gr.top_block() top.connect((numpy_source, 0), (peak_detector, 0)) top.connect((numpy_source, 0), (sample_and_hold, 0)) top.connect((numpy_source, 0), (subtract, 0)) top.connect((peak_detector, 0), (sample_and_hold, 1)) top.connect((sample_and_hold, 0), (multiply_const, 0)) top.connect((multiply_const, 0), (subtract, 1)) top.connect((subtract, 0), (numpy_sink, 0)) top.run() filtered = TimeData(numpy_sink.data, translated.sampling_rate) self.filtered_view.data = filtered # abs_min = filtered.abs.min # abs_max = filtered.abs.max # abs_mid = (abs_min + abs_max) / 2.0 # self.burst.filtered = filtered.abs - abs_mid self.burst.filtered = filtered else: self.filtered_view.data = None self.burst.filtered = None
def _update_filtered(self, translated): if translated is not None and self._taps is not None: filtered = TimeData(numpy.complex64(scipy.signal.lfilter(self._taps, 1, translated.samples)), translated.sampling_rate) filtered_abs = filtered.abs data_source = filtered_abs.samples numpy_source = NumpySource(data_source) peak_detector = blocks.peak_detector_fb(1.0, 0.3, 10, 0.001) sample_and_hold = blocks.sample_and_hold_ff() multiply_const = blocks.multiply_const_vff((0.5, )) subtract = blocks.sub_ff(1) numpy_sink = NumpySink(numpy.float32) top = gr.top_block() top.connect((numpy_source, 0), (peak_detector, 0)) top.connect((numpy_source, 0), (sample_and_hold, 0)) top.connect((numpy_source, 0), (subtract, 0)) top.connect((peak_detector, 0), (sample_and_hold, 1)) top.connect((sample_and_hold, 0), (multiply_const, 0)) top.connect((multiply_const, 0), (subtract, 1)) top.connect((subtract, 0), (numpy_sink, 0)) top.run() filtered = TimeData(numpy_sink.data, translated.sampling_rate) self.filtered_view.data = filtered # abs_min = filtered.abs.min # abs_max = filtered.abs.max # abs_mid = (abs_min + abs_max) / 2.0 # self.burst.filtered = filtered.abs - abs_mid self.burst.filtered = filtered else: self.filtered_view.data = None self.burst.filtered = None
def __init__(self, ts, factor, alpha, samp_rate, freqs):
gr.hier_block2.__init__(
self, "freq_timing_estimator_hier",
gr.io_signature(1, 1, gr.sizeof_gr_complex*1),
gr.io_signaturev(3, 3, [gr.sizeof_char*1, gr.sizeof_float*1, gr.sizeof_float*1]),
)
##################################################
# Parameters
##################################################
self.ts = ts
self.factor = factor
self.alpha = alpha
self.samp_rate = samp_rate
self.freqs = freqs
self.n = n = len(freqs)
##################################################
# Blocks
##################################################
self._filter=[0]*self.n
self._c2mag2=[0]*self.n
for i in range(self.n):
self._filter[i]= filter.freq_xlating_fir_filter_ccc(1, (numpy.conjugate(self.ts[::-1])), self.freqs[i], self.samp_rate)
self._c2mag2[i] = blocks.complex_to_mag_squared(1)
self.blocks_max = blocks.max_ff(1)
self.blocks_peak_detector = blocks.peak_detector_fb(self.factor, self.factor, 0, self.alpha)
self.blocks_argmax = blocks.argmax_fs(1)
self.blocks_null_sink = blocks.null_sink(gr.sizeof_short*1)
self.digital_chunks_to_symbols = digital.chunks_to_symbols_sf((freqs), 1)
self.blocks_sample_and_hold = blocks.sample_and_hold_ff()
##################################################
# Connections
##################################################
for i in range(self.n):
self.connect((self, 0), (self._filter[i], 0))
self.connect((self._filter[i], 0), (self._c2mag2[i], 0))
self.connect((self._c2mag2[i], 0), (self.blocks_max, i))
self.connect((self._c2mag2[i], 0), (self.blocks_argmax, i))
self.connect((self.blocks_max, 0), (self.blocks_peak_detector, 0))
self.connect((self.blocks_peak_detector, 0), (self, 0))
self.connect((self.blocks_argmax, 0), (self.blocks_null_sink, 0))
self.connect((self.blocks_argmax, 1), (self.digital_chunks_to_symbols, 0))
self.connect((self.digital_chunks_to_symbols, 0), (self.blocks_sample_and_hold, 0))
self.connect((self.blocks_peak_detector, 0), (self.blocks_sample_and_hold, 1))
self.connect((self.blocks_sample_and_hold, 0), (self, 1))
self.connect((self.blocks_max, 0), (self, 2))
def test_001(self):
src_data = 10*[0,1,2,3,4,5,6,7,8,9,8,7,6,5,4,3,2,1]
ctrl_data = 10*[1,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0]
expected_result = 10*(0,0,0,0,4,5,6,7,8,9,9,9,9,9,9,9,9,9)
src = blocks.vector_source_f(src_data)
ctrl = blocks.vector_source_b(ctrl_data)
op = blocks.sample_and_hold_ff()
dst = blocks.vector_sink_f()
self.tb.connect(src, (op,0))
self.tb.connect(ctrl, (op,1))
self.tb.connect(op, dst)
self.tb.run()
result = dst.data()
self.assertFloatTuplesAlmostEqual(expected_result, result, places=6)
def __init__(self, fft_length, cp_length, logging=False):
"""
OFDM synchronization using PN Correlation:
T. M. Schmidl and D. C. Cox, "Robust Frequency and Timing
Synchronization for OFDM," IEEE Trans. Communications, vol. 45,
no. 12, 1997.
"""
gr.hier_block2.__init__(self, "ofdm_sync_pn",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature2(2, 2, gr.sizeof_float, gr.sizeof_char)) # Output signature
self.input = blocks.add_const_cc(0)
# PN Sync
# Create a delay line
self.delay = blocks.delay(gr.sizeof_gr_complex, fft_length/2)
# Correlation from ML Sync
self.conjg = blocks.conjugate_cc();
self.corr = blocks.multiply_cc();
# Create a moving sum filter for the corr output
self.moving_sum_filter = filter.fir_filter_ccf(1, [1.0] * (fft_length//2))
# Create a moving sum filter for the input
self.inputmag2 = blocks.complex_to_mag_squared()
self.inputmovingsum = filter.fir_filter_fff(1, [1.0] * (fft_length//2))
self.square = blocks.multiply_ff()
self.normalize = blocks.divide_ff()
# Get magnitude (peaks) and angle (phase/freq error)
self.c2mag = blocks.complex_to_mag_squared()
self.angle = blocks.complex_to_arg()
self.sample_and_hold = blocks.sample_and_hold_ff()
#ML measurements input to sampler block and detect
self.sub1 = blocks.add_const_ff(-1)
self.pk_detect = blocks.peak_detector_fb(0.20, 0.20, 30, 0.001)
self.connect(self, self.input)
# Calculate the frequency offset from the correlation of the preamble
self.connect(self.input, self.delay)
self.connect(self.input, (self.corr,0))
self.connect(self.delay, self.conjg)
self.connect(self.conjg, (self.corr,1))
self.connect(self.corr, self.moving_sum_filter)
self.connect(self.moving_sum_filter, self.c2mag)
self.connect(self.moving_sum_filter, self.angle)
self.connect(self.angle, (self.sample_and_hold,0))
# Get the power of the input signal to normalize the output of the correlation
self.connect(self.input, self.inputmag2, self.inputmovingsum)
self.connect(self.inputmovingsum, (self.square,0))
self.connect(self.inputmovingsum, (self.square,1))
self.connect(self.square, (self.normalize,1))
self.connect(self.c2mag, (self.normalize,0))
# Create a moving sum filter for the corr output
matched_filter_taps = [1.0/cp_length for i in range(cp_length)]
self.matched_filter = filter.fir_filter_fff(1,matched_filter_taps)
self.connect(self.normalize, self.matched_filter)
self.connect(self.matched_filter, self.sub1, self.pk_detect)
#self.connect(self.matched_filter, self.pk_detect)
self.connect(self.pk_detect, (self.sample_and_hold,1))
# Set output signals
# Output 0: fine frequency correction value
# Output 1: timing signal
self.connect(self.sample_and_hold, (self,0))
self.connect(self.pk_detect, (self,1))
if logging:
self.connect(self.matched_filter, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pn-mf_f.dat"))
self.connect(self.normalize, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pn-theta_f.dat"))
self.connect(self.angle, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pn-epsilon_f.dat"))
self.connect(self.pk_detect, blocks.file_sink(gr.sizeof_char, "ofdm_sync_pn-peaks_b.dat"))
self.connect(self.sample_and_hold, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pn-sample_and_hold_f.dat"))
self.connect(self.input, blocks.file_sink(gr.sizeof_gr_complex, "ofdm_sync_pn-input_c.dat"))
def __init__(self, seq1, seq2, factor, lookahead, alpha, freqs):
"""
Description:
frequency timing estimator class does frequency/timing acquisition from scratch.It uses a bank of parallel correlators at each specified frequency. It then takes the max abs value of all these and passes it through a peak detector to find timing.
Args:
seq1: sequence1 of kronecker filter, which is the given training sequence.
seq2: sequence2 of kronecker filter, which is the pulse for each training symbol.
factor: the rise and fall factors in peak detector, which is the factor determining when a peak has started and ended. In the peak detector, an average of the signal is calculated. When the value of the signal goes over factor*average, we start looking for a peak. When the value of the signal goes below factor*average, we stop looking for a peak.
alpha: the smoothing factor of a moving average filter used in the peak detector taking values in (0,1).
freqs: the vector of normalized center frequencies for each matched filter. Note that for a training sequence of length Nt, each matched filter can recover a sequence with normalized frequency offset ~ 1/(2Nt).
"""
gr.hier_block2.__init__(self,
"freq_timing_estimator",
gr.io_signature(1, 1, gr.sizeof_gr_complex*1),
gr.io_signaturev(3, 3, [gr.sizeof_char*1, gr.sizeof_float*1, gr.sizeof_float*1]),
)
##################################################
# Parameters
##################################################
self.seq1 = seq1
self.seq2 = seq2
self.factor = factor
self.lookahead = lookahead
self.alpha = alpha
self.freqs = freqs
self.n = n = len(freqs)
self.on = 1
##################################################
# Blocks
##################################################
self._filter=[0]*self.n
self._c2mag2=[0]*self.n
for i in range(self.n):
#self._filter[i]= cdma.kronecker_filter(seq1,seq2,1,self.freqs[i])
#self._filter[i]= filter.freq_xlating_fir_filter_ccc(1, numpy.kron(seq1,seq2), self.freqs[i], 1)
self._filter[i]= filter.freq_xlating_fft_filter_ccc(1, numpy.kron(seq1,seq2), self.freqs[i], 1)
self._c2mag2[i] = blocks.complex_to_mag_squared(1)
self.blocks_max = blocks.max_ff(1)
self.blocks_peak_detector = cdma.switched_peak_detector_fb(self.factor, self.factor, self.lookahead, self.alpha, self.on)
self.blocks_argmax = blocks.argmax_fs(1)
self.blocks_null_sink = blocks.null_sink(gr.sizeof_short*1)
self.digital_chunks_to_symbols = digital.chunks_to_symbols_sf((freqs), 1)
self.blocks_sample_and_hold = blocks.sample_and_hold_ff()
##################################################
# Connections
##################################################
for i in range(self.n):
self.connect((self, 0), (self._filter[i], 0))
self.connect((self._filter[i], 0), (self._c2mag2[i], 0))
self.connect((self._c2mag2[i], 0), (self.blocks_max, i))
self.connect((self._c2mag2[i], 0), (self.blocks_argmax, i))
self.connect((self.blocks_max, 0), (self.blocks_peak_detector, 0))
self.connect((self.blocks_peak_detector, 0), (self, 0))
self.connect((self.blocks_argmax, 0), (self.blocks_null_sink, 0))
self.connect((self.blocks_argmax, 1), (self.digital_chunks_to_symbols, 0))
self.connect((self.digital_chunks_to_symbols, 0), (self.blocks_sample_and_hold, 0))
self.connect((self.blocks_peak_detector, 0), (self.blocks_sample_and_hold, 1))
self.connect((self.blocks_sample_and_hold, 0), (self, 1))
self.connect((self.blocks_max, 0), (self, 2))
def __init__(self, fft_length, cp_length, kstime, logging=False):
"""
OFDM synchronization using PN Correlation and initial cross-correlation:
F. Tufvesson, O. Edfors, and M. Faulkner, "Time and Frequency Synchronization for OFDM using
PN-Sequency Preambles," IEEE Proc. VTC, 1999, pp. 2203-2207.
This implementation is meant to be a more robust version of the Schmidl and Cox receiver design.
By correlating against the preamble and using that as the input to the time-delayed correlation,
this circuit produces a very clean timing signal at the end of the preamble. The timing is
more accurate and does not have the problem associated with determining the timing from the
plateau structure in the Schmidl and Cox.
This implementation appears to require that the signal is received with a normalized power or signal
scaling factor to reduce ambiguities introduced from partial correlation of the cyclic prefix and
the peak detection. A better peak detection block might fix this.
Also, the cross-correlation falls apart as the frequency offset gets larger and completely fails
when an integer offset is introduced. Another thing to look at.
"""
gr.hier_block2.__init__(self, "ofdm_sync_pnac",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature2(2, 2, gr.sizeof_float, gr.sizeof_char)) # Output signature
self.input = blocks.add_const_cc(0)
symbol_length = fft_length + cp_length
# PN Sync with cross-correlation input
# cross-correlate with the known symbol
kstime = [k.conjugate() for k in kstime[0:fft_length//2]]
kstime.reverse()
self.crosscorr_filter = filter.fir_filter_ccc(1, kstime)
# Create a delay line
self.delay = blocks.delay(gr.sizeof_gr_complex, fft_length/2)
# Correlation from ML Sync
self.conjg = blocks.conjugate_cc();
self.corr = blocks.multiply_cc();
# Create a moving sum filter for the input
self.mag = blocks.complex_to_mag_squared()
self.power = filter.fir_filter_fff(1, [1.0] * int(fft_length))
# Get magnitude (peaks) and angle (phase/freq error)
self.c2mag = blocks.complex_to_mag_squared()
self.angle = blocks.complex_to_arg()
self.compare = blocks.sub_ff()
self.sample_and_hold = blocks.sample_and_hold_ff()
#ML measurements input to sampler block and detect
self.threshold = blocks.threshold_ff(0,0,0) # threshold detection might need to be tweaked
self.peaks = blocks.float_to_char()
self.connect(self, self.input)
# Cross-correlate input signal with known preamble
self.connect(self.input, self.crosscorr_filter)
# use the output of the cross-correlation as input time-shifted correlation
self.connect(self.crosscorr_filter, self.delay)
self.connect(self.crosscorr_filter, (self.corr,0))
self.connect(self.delay, self.conjg)
self.connect(self.conjg, (self.corr,1))
self.connect(self.corr, self.c2mag)
self.connect(self.corr, self.angle)
self.connect(self.angle, (self.sample_and_hold,0))
# Get the power of the input signal to compare against the correlation
self.connect(self.crosscorr_filter, self.mag, self.power)
# Compare the power to the correlator output to determine timing peak
# When the peak occurs, it peaks above zero, so the thresholder detects this
self.connect(self.c2mag, (self.compare,0))
self.connect(self.power, (self.compare,1))
self.connect(self.compare, self.threshold)
self.connect(self.threshold, self.peaks, (self.sample_and_hold,1))
# Set output signals
# Output 0: fine frequency correction value
# Output 1: timing signal
self.connect(self.sample_and_hold, (self,0))
self.connect(self.peaks, (self,1))
if logging:
self.connect(self.compare, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pnac-compare_f.dat"))
self.connect(self.c2mag, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pnac-theta_f.dat"))
self.connect(self.power, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pnac-inputpower_f.dat"))
self.connect(self.angle, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pnac-epsilon_f.dat"))
self.connect(self.threshold, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pnac-threshold_f.dat"))
self.connect(self.peaks, blocks.file_sink(gr.sizeof_char, "ofdm_sync_pnac-peaks_b.dat"))
self.connect(self.sample_and_hold, blocks.file_sink(gr.sizeof_float, "ofdm_sync_pnac-sample_and_hold_f.dat"))
self.connect(self.input, blocks.file_sink(gr.sizeof_gr_complex, "ofdm_sync_pnac-input_c.dat"))
def __init__(self, seq1, seq2, factor, alpha, samp_rate, freqs):
"""
Description:
This block is functionally equivalent to the frequency_timing_estimator block, except from the fact that each filter is matched to a sequence that can be written as the kronecker product of seq1 and seq2.
Args:
seq1: sequence1 of kronecker filter, which is the given training sequence.
seq2: sequence2 of kronecker filter, which is the pulse for each training symbol.
factor: the rise and fall factors in peak detector, which is the factor determining when a peak has started and ended. In the peak detector, an average of the signal is calculated. When the value of the signal goes over factor*average, we start looking for a peak. When the value of the signal goes below factor*average, we stop looking for a peak. factor takes values in (0,1).
alpha: the smoothing factor of a moving average filter used in the peak detector takeng values in (0,1).
samp_rate: the sample rate of the system, which is used in the kronecker_filter.
freqs: the vector of center frequencies for each matched filter. Note that for a training sequence of length Nt, each matched filter can recover a sequence with normalized frequency offset ~ 1/(2Nt).
"""
gr.hier_block2.__init__(self,
"freq_timing_estimator",
gr.io_signature(1, 1, gr.sizeof_gr_complex*1),
gr.io_signaturev(3, 3, [gr.sizeof_char*1, gr.sizeof_float*1, gr.sizeof_float*1]),
)
##################################################
# Parameters
##################################################
self.seq1 = seq1
self.seq2 = seq2
self.factor = factor
self.alpha = alpha
self.samp_rate = samp_rate
self.freqs = freqs
self.n = n = len(freqs)
##################################################
# Blocks
##################################################
self._filter=[0]*self.n
self._c2mag2=[0]*self.n
for i in range(self.n):
self._filter[i]= cdma.kronecker_filter(seq1,seq2,samp_rate,self.freqs[i])
#self._filter[i]= filter.freq_xlating_fir_filter_ccc(1, (numpy.conjugate(self.ts[::-1])), self.freqs[i], self.samp_rate)
self._c2mag2[i] = blocks.complex_to_mag_squared(1)
self.blocks_max = blocks.max_ff(1)
self.blocks_peak_detector = blocks.peak_detector_fb(self.factor, self.factor, 0, self.alpha)
self.blocks_argmax = blocks.argmax_fs(1)
self.blocks_null_sink = blocks.null_sink(gr.sizeof_short*1)
self.digital_chunks_to_symbols = digital.chunks_to_symbols_sf((freqs), 1)
self.blocks_sample_and_hold = blocks.sample_and_hold_ff()
##################################################
# Connections
##################################################
for i in range(self.n):
self.connect((self, 0), (self._filter[i], 0))
self.connect((self._filter[i], 0), (self._c2mag2[i], 0))
self.connect((self._c2mag2[i], 0), (self.blocks_max, i))
self.connect((self._c2mag2[i], 0), (self.blocks_argmax, i))
self.connect((self.blocks_max, 0), (self.blocks_peak_detector, 0))
self.connect((self.blocks_peak_detector, 0), (self, 0))
self.connect((self.blocks_argmax, 0), (self.blocks_null_sink, 0))
self.connect((self.blocks_argmax, 1), (self.digital_chunks_to_symbols, 0))
self.connect((self.digital_chunks_to_symbols, 0), (self.blocks_sample_and_hold, 0))
self.connect((self.blocks_peak_detector, 0), (self.blocks_sample_and_hold, 1))
self.connect((self.blocks_sample_and_hold, 0), (self, 1))
self.connect((self.blocks_max, 0), (self, 2))
def __init__(self, seq1, seq2, factor, alpha, freqs):
"""
Description:
frequency timing estimator class does frequency/timing acquisition from scratch.It uses a bank of parallel correlators at each specified frequency. It then takes the max abs value of all these and passes it through a peak detector to find timing.
Args:
seq1: sequence1 of kronecker filter, which is the given training sequence.
seq2: sequence2 of kronecker filter, which is the pulse for each training symbol.
factor: the rise and fall factors in peak detector, which is the factor determining when a peak has started and ended. In the peak detector, an average of the signal is calculated. When the value of the signal goes over factor*average, we start looking for a peak. When the value of the signal goes below factor*average, we stop looking for a peak.
alpha: the smoothing factor of a moving average filter used in the peak detector taking values in (0,1).
freqs: the vector of normalized center frequencies for each matched filter. Note that for a training sequence of length Nt, each matched filter can recover a sequence with normalized frequency offset ~ 1/(2Nt).
"""
gr.hier_block2.__init__(
self,
"freq_timing_estimator",
gr.io_signature(1, 1, gr.sizeof_gr_complex * 1),
gr.io_signaturev(
3, 3,
[gr.sizeof_char * 1, gr.sizeof_float * 1, gr.sizeof_float * 1
]),
)
##################################################
# Parameters
##################################################
self.seq1 = seq1
self.seq2 = seq2
self.factor = factor
self.alpha = alpha
self.freqs = freqs
self.n = n = len(freqs)
self.on = 1
##################################################
# Blocks
##################################################
self._filter = [0] * self.n
self._c2mag2 = [0] * self.n
for i in range(self.n):
#self._filter[i]= cdma.kronecker_filter(seq1,seq2,1,self.freqs[i])
#self._filter[i]= filter.freq_xlating_fir_filter_ccc(1, numpy.kron(seq1,seq2), self.freqs[i], 1)
self._filter[i] = filter.freq_xlating_fft_filter_ccc(
1, numpy.kron(seq1, seq2), self.freqs[i], 1)
self._c2mag2[i] = blocks.complex_to_mag_squared(1)
self.blocks_max = blocks.max_ff(1)
self.blocks_peak_detector = cdma.switched_peak_detector_fb(
self.factor, self.factor, 0, self.alpha, self.on)
self.blocks_argmax = blocks.argmax_fs(1)
self.blocks_null_sink = blocks.null_sink(gr.sizeof_short * 1)
self.digital_chunks_to_symbols = digital.chunks_to_symbols_sf((freqs),
1)
self.blocks_sample_and_hold = blocks.sample_and_hold_ff()
##################################################
# Connections
##################################################
for i in range(self.n):
self.connect((self, 0), (self._filter[i], 0))
self.connect((self._filter[i], 0), (self._c2mag2[i], 0))
self.connect((self._c2mag2[i], 0), (self.blocks_max, i))
self.connect((self._c2mag2[i], 0), (self.blocks_argmax, i))
self.connect((self.blocks_max, 0), (self.blocks_peak_detector, 0))
self.connect((self.blocks_peak_detector, 0), (self, 0))
self.connect((self.blocks_argmax, 0), (self.blocks_null_sink, 0))
self.connect((self.blocks_argmax, 1),
(self.digital_chunks_to_symbols, 0))
self.connect((self.digital_chunks_to_symbols, 0),
(self.blocks_sample_and_hold, 0))
self.connect((self.blocks_peak_detector, 0),
(self.blocks_sample_and_hold, 1))
self.connect((self.blocks_sample_and_hold, 0), (self, 1))
self.connect((self.blocks_max, 0), (self, 2))
def __init__(self, seq1, seq2, factor, alpha, freqs, debug_onoff, debug_port, prefix):
"""
Description:
frequency timing estimator class does frequency/timing acquisition from scratch.It uses a bank of parallel correlators at each specified frequency. It then takes the max abs value of all these and passes it through a peak detector to find timing.
Args:
seq1: sequence1 of kronecker filter, which is the given training sequence.
seq2: sequence2 of kronecker filter, which is the pulse for each training symbol.
factor: the rise and fall factors in peak detector, which is the factor determining when a peak has started and ended. In the peak detector, an average of the signal is calculated. When the value of the signal goes over factor*average, we start looking for a peak. When the value of the signal goes below factor*average, we stop looking for a peak.
alpha: the smoothing factor of a moving average filter used in the peak detector taking values in (0,1).
freqs: the vector of normalized center frequencies for each matched filter. Note that for a training sequence of length Nt, each matched filter can recover a sequence with normalized frequency offset ~ 1/(2Nt).
"""
gr.hier_block2.__init__(self,
"freq_timing_estimator",
gr.io_signature(1, 1, gr.sizeof_gr_complex*1),
gr.io_signaturev(3, 3, [gr.sizeof_char*1, gr.sizeof_float*1, gr.sizeof_float*1]),
)
##################################################
# Parameters
##################################################
self.seq1 = seq1
self.seq2 = seq2
self.factor = factor
self.alpha = alpha
self.freqs = freqs
self.n = n = len(freqs)
self.on = 1
self.debug_onoff = debug_onoff # 1: dump ports info to file 0: no debug output
self.debug_port = debug_port # 0-n_filt-1 is the output of each filter branck; n_filter is the output of maximum
self.prefix = prefix
##################################################
# Blocks
##################################################
self._filter=[0]*self.n
self._c2mag2=[0]*self.n
for i in range(self.n):
#self._filter[i]= cdma.kronecker_filter(seq1,seq2,1,self.freqs[i])
#self._filter[i]= filter.freq_xlating_fir_filter_ccc(1, numpy.kron(seq1,seq2), self.freqs[i], 1)
self._filter[i]= filter.freq_xlating_fft_filter_ccc(1, numpy.kron(seq1,seq2), self.freqs[i], 1)
self._c2mag2[i] = blocks.complex_to_mag_squared(1)
self.blocks_max = blocks.max_ff(1)
self.blocks_peak_detector = cdma.switched_peak_detector_fb(self.factor, self.factor, 0, self.alpha, self.on)
self.blocks_argmax = blocks.argmax_fs(1)
self.blocks_null_sink = blocks.null_sink(gr.sizeof_short*1)
self.digital_chunks_to_symbols = digital.chunks_to_symbols_sf((freqs), 1)
self.blocks_sample_and_hold = blocks.sample_and_hold_ff()
if self.debug_onoff == True:
num_of_file_sinks = len(self.debug_port)
self._filesink = [0]*num_of_file_sinks
for i in range(num_of_file_sinks):
if self.debug_port[i] == self.n:
filename = prefix+"max.dat"
else:
filename = prefix+"filter"+str(i)+".dat"
print filename
self._filesink[i] = blocks.file_sink(gr.sizeof_float*1, filename, False)
self._filesink[i].set_unbuffered(False)
# this is the block for bundling the outputs of each branch of filters and the input of peak detector
##################################################
# Connections
##################################################
for i in range(self.n):
self.connect((self, 0), (self._filter[i], 0))
self.connect((self._filter[i], 0), (self._c2mag2[i], 0))
self.connect((self._c2mag2[i], 0), (self.blocks_max, i))
self.connect((self._c2mag2[i], 0), (self.blocks_argmax, i))
self.connect((self.blocks_max, 0), (self.blocks_peak_detector, 0))
self.connect((self.blocks_peak_detector, 0), (self, 0))
self.connect((self.blocks_argmax, 0), (self.blocks_null_sink, 0))
self.connect((self.blocks_argmax, 1), (self.digital_chunks_to_symbols, 0))
self.connect((self.digital_chunks_to_symbols, 0), (self.blocks_sample_and_hold, 0))
self.connect((self.blocks_peak_detector, 0), (self.blocks_sample_and_hold, 1))
self.connect((self.blocks_sample_and_hold, 0), (self, 1))
self.connect((self.blocks_max, 0), (self, 2))
if self.debug_onoff == True:
for i in range(num_of_file_sinks):
port_index = self.debug_port[i]
if port_index == self.n:
self.connect((self.blocks_max, 0), (self._filesink[i], 0))
else:
self.connect((self._c2mag2[port_index], 0), (self._filesink[i], 0))
def __init__(self, fft_length, cp_length, kstime, logging=False):
"""
OFDM synchronization using PN Correlation and initial cross-correlation:
F. Tufvesson, O. Edfors, and M. Faulkner, "Time and Frequency Synchronization for OFDM using
PN-Sequency Preambles," IEEE Proc. VTC, 1999, pp. 2203-2207.
This implementation is meant to be a more robust version of the Schmidl and Cox receiver design.
By correlating against the preamble and using that as the input to the time-delayed correlation,
this circuit produces a very clean timing signal at the end of the preamble. The timing is
more accurate and does not have the problem associated with determining the timing from the
plateau structure in the Schmidl and Cox.
This implementation appears to require that the signal is received with a normalized power or signal
scalling factor to reduce ambiguities intorduced from partial correlation of the cyclic prefix and
the peak detection. A better peak detection block might fix this.
Also, the cross-correlation falls apart as the frequency offset gets larger and completely fails
when an integer offset is introduced. Another thing to look at.
"""
gr.hier_block2.__init__(
self,
"ofdm_sync_pnac",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature2(2, 2, gr.sizeof_float,
gr.sizeof_char)) # Output signature
self.input = blocks.add_const_cc(0)
symbol_length = fft_length + cp_length
# PN Sync with cross-correlation input
# cross-correlate with the known symbol
kstime = [k.conjugate() for k in kstime[0:fft_length // 2]]
kstime.reverse()
self.crosscorr_filter = filter.fir_filter_ccc(1, kstime)
# Create a delay line
self.delay = blocks.delay(gr.sizeof_gr_complex, fft_length / 2)
# Correlation from ML Sync
self.conjg = blocks.conjugate_cc()
self.corr = blocks.multiply_cc()
# Create a moving sum filter for the input
self.mag = blocks.complex_to_mag_squared()
movingsum_taps = (fft_length // 1) * [
1.0,
]
self.power = filter.fir_filter_fff(1, movingsum_taps)
# Get magnitude (peaks) and angle (phase/freq error)
self.c2mag = blocks.complex_to_mag_squared()
self.angle = blocks.complex_to_arg()
self.compare = blocks.sub_ff()
self.sample_and_hold = blocks.sample_and_hold_ff()
#ML measurements input to sampler block and detect
self.threshold = blocks.threshold_ff(
0, 0, 0) # threshold detection might need to be tweaked
self.peaks = blocksx.float_to_char()
self.connect(self, self.input)
# Cross-correlate input signal with known preamble
self.connect(self.input, self.crosscorr_filter)
# use the output of the cross-correlation as input time-shifted correlation
self.connect(self.crosscorr_filter, self.delay)
self.connect(self.crosscorr_filter, (self.corr, 0))
self.connect(self.delay, self.conjg)
self.connect(self.conjg, (self.corr, 1))
self.connect(self.corr, self.c2mag)
self.connect(self.corr, self.angle)
self.connect(self.angle, (self.sample_and_hold, 0))
# Get the power of the input signal to compare against the correlation
self.connect(self.crosscorr_filter, self.mag, self.power)
# Compare the power to the correlator output to determine timing peak
# When the peak occurs, it peaks above zero, so the thresholder detects this
self.connect(self.c2mag, (self.compare, 0))
self.connect(self.power, (self.compare, 1))
self.connect(self.compare, self.threshold)
self.connect(self.threshold, self.peaks, (self.sample_and_hold, 1))
# Set output signals
# Output 0: fine frequency correction value
# Output 1: timing signal
self.connect(self.sample_and_hold, (self, 0))
self.connect(self.peaks, (self, 1))
if logging:
self.connect(
self.compare,
blocks.file_sink(gr.sizeof_float,
"ofdm_sync_pnac-compare_f.dat"))
self.connect(
self.c2mag,
blocks.file_sink(gr.sizeof_float,
"ofdm_sync_pnac-theta_f.dat"))
self.connect(
self.power,
blocks.file_sink(gr.sizeof_float,
"ofdm_sync_pnac-inputpower_f.dat"))
self.connect(
self.angle,
blocks.file_sink(gr.sizeof_float,
"ofdm_sync_pnac-epsilon_f.dat"))
self.connect(
self.threshold,
blocks.file_sink(gr.sizeof_float,
"ofdm_sync_pnac-threshold_f.dat"))
self.connect(
self.peaks,
blocks.file_sink(gr.sizeof_char, "ofdm_sync_pnac-peaks_b.dat"))
self.connect(
self.sample_and_hold,
blocks.file_sink(gr.sizeof_float,
"ofdm_sync_pnac-sample_and_hold_f.dat"))
self.connect(
self.input,
blocks.file_sink(gr.sizeof_gr_complex,
"ofdm_sync_pnac-input_c.dat"))
def __init__(self, fft_length, cp_length, logging=False):
"""
OFDM synchronization using PN Correlation:
T. M. Schmidl and D. C. Cox, "Robust Frequency and Timing
Synchronization for OFDM," IEEE Trans. Communications, vol. 45,
no. 12, 1997.
"""
gr.hier_block2.__init__(
self,
"ofdm_sync_pn",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature2(2, 2, gr.sizeof_float,
gr.sizeof_char)) # Output signature
self.input = blocks.add_const_cc(0)
# PN Sync
# Create a delay line
self.delay = blocks.delay(gr.sizeof_gr_complex, fft_length / 2)
# Correlation from ML Sync
self.conjg = blocks.conjugate_cc()
self.corr = blocks.multiply_cc()
# Create a moving sum filter for the corr output
self.moving_sum_filter = filter.fir_filter_ccf(1, [1.0] *
(fft_length // 2))
# Create a moving sum filter for the input
self.inputmag2 = blocks.complex_to_mag_squared()
self.inputmovingsum = filter.fir_filter_fff(1,
[1.0] * (fft_length // 2))
self.square = blocks.multiply_ff()
self.normalize = blocks.divide_ff()
# Get magnitude (peaks) and angle (phase/freq error)
self.c2mag = blocks.complex_to_mag_squared()
self.angle = blocks.complex_to_arg()
self.sample_and_hold = blocks.sample_and_hold_ff()
#ML measurements input to sampler block and detect
self.sub1 = blocks.add_const_ff(-1)
self.pk_detect = blocks.peak_detector_fb(0.20, 0.20, 30, 0.001)
self.connect(self, self.input)
# Calculate the frequency offset from the correlation of the preamble
self.connect(self.input, self.delay)
self.connect(self.input, (self.corr, 0))
self.connect(self.delay, self.conjg)
self.connect(self.conjg, (self.corr, 1))
self.connect(self.corr, self.moving_sum_filter)
self.connect(self.moving_sum_filter, self.c2mag)
self.connect(self.moving_sum_filter, self.angle)
self.connect(self.angle, (self.sample_and_hold, 0))
# Get the power of the input signal to normalize the output of the correlation
self.connect(self.input, self.inputmag2, self.inputmovingsum)
self.connect(self.inputmovingsum, (self.square, 0))
self.connect(self.inputmovingsum, (self.square, 1))
self.connect(self.square, (self.normalize, 1))
self.connect(self.c2mag, (self.normalize, 0))
# Create a moving sum filter for the corr output
matched_filter_taps = [1.0 / cp_length for i in range(cp_length)]
self.matched_filter = filter.fir_filter_fff(1, matched_filter_taps)
self.connect(self.normalize, self.matched_filter)
self.connect(self.matched_filter, self.sub1, self.pk_detect)
#self.connect(self.matched_filter, self.pk_detect)
self.connect(self.pk_detect, (self.sample_and_hold, 1))
# Set output signals
# Output 0: fine frequency correction value
# Output 1: timing signal
self.connect(self.sample_and_hold, (self, 0))
self.connect(self.pk_detect, (self, 1))
if logging:
self.connect(
self.matched_filter,
blocks.file_sink(gr.sizeof_float, "ofdm_sync_pn-mf_f.dat"))
self.connect(
self.normalize,
blocks.file_sink(gr.sizeof_float, "ofdm_sync_pn-theta_f.dat"))
self.connect(
self.angle,
blocks.file_sink(gr.sizeof_float,
"ofdm_sync_pn-epsilon_f.dat"))
self.connect(
self.pk_detect,
blocks.file_sink(gr.sizeof_char, "ofdm_sync_pn-peaks_b.dat"))
self.connect(
self.sample_and_hold,
blocks.file_sink(gr.sizeof_float,
"ofdm_sync_pn-sample_and_hold_f.dat"))
self.connect(
self.input,
blocks.file_sink(gr.sizeof_gr_complex,
"ofdm_sync_pn-input_c.dat"))
def __init__(self):
gr.top_block.__init__(self, "Top Block")
Qt.QWidget.__init__(self)
self.setWindowTitle("Top Block")
qtgui.util.check_set_qss()
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.mod_index0 = mod_index0 = 0.5
self.fs0 = fs0 = 100000
self.freq0 = freq0 = 2500
self.fpor0 = fpor0 = 30000
self.fmod0 = fmod0 = 2000
self.dutycycle0 = dutycycle0 = 0.5
self.amplitud0 = amplitud0 = 1
self.syh_on = syh_on = True
self.switch_on = switch_on = True
self.seniales_control_iguales = seniales_control_iguales = 0
self.samp_rate = samp_rate = 300000
self.mod_index = mod_index = mod_index0
self.input_signal = input_signal = 0
self.input_freq = input_freq = freq0
self.fs = fs = fs0
self.fpor = fpor = fpor0
self.fmod = fmod = fmod0
self.filtro_recuperador_on = filtro_recuperador_on = True
self.filtro_antialiasing_on = filtro_antialiasing_on = True
self.dutycycle = dutycycle = dutycycle0
self.amplitud = amplitud = amplitud0
##################################################
# Blocks
##################################################
self.main_tab = Qt.QTabWidget()
self.main_tab_widget_0 = Qt.QWidget()
self.main_tab_layout_0 = Qt.QBoxLayout(Qt.QBoxLayout.TopToBottom,
self.main_tab_widget_0)
self.main_tab_grid_layout_0 = Qt.QGridLayout()
self.main_tab_layout_0.addLayout(self.main_tab_grid_layout_0)
self.main_tab.addTab(self.main_tab_widget_0, '')
self.top_grid_layout.addWidget(self.main_tab)
self.gui_tab_configuracion = Qt.QTabWidget()
self.gui_tab_configuracion_widget_0 = Qt.QWidget()
self.gui_tab_configuracion_layout_0 = Qt.QBoxLayout(
Qt.QBoxLayout.TopToBottom, self.gui_tab_configuracion_widget_0)
self.gui_tab_configuracion_grid_layout_0 = Qt.QGridLayout()
self.gui_tab_configuracion_layout_0.addLayout(
self.gui_tab_configuracion_grid_layout_0)
self.gui_tab_configuracion.addTab(self.gui_tab_configuracion_widget_0,
'Streamline')
self.gui_tab_configuracion_widget_1 = Qt.QWidget()
self.gui_tab_configuracion_layout_1 = Qt.QBoxLayout(
Qt.QBoxLayout.TopToBottom, self.gui_tab_configuracion_widget_1)
self.gui_tab_configuracion_grid_layout_1 = Qt.QGridLayout()
self.gui_tab_configuracion_layout_1.addLayout(
self.gui_tab_configuracion_grid_layout_1)
self.gui_tab_configuracion.addTab(self.gui_tab_configuracion_widget_1,
'Inputs')
self.main_tab_grid_layout_0.addWidget(self.gui_tab_configuracion, 0, 0,
1, 1)
for r in range(0, 1):
self.main_tab_grid_layout_0.setRowStretch(r, 1)
for c in range(0, 1):
self.main_tab_grid_layout_0.setColumnStretch(c, 1)
_syh_on_check_box = Qt.QCheckBox("Sample and hold on")
self._syh_on_choices = {True: 1, False: 0}
self._syh_on_choices_inv = dict(
(v, k) for k, v in self._syh_on_choices.iteritems())
self._syh_on_callback = lambda i: Qt.QMetaObject.invokeMethod(
_syh_on_check_box, "setChecked",
Qt.Q_ARG("bool", self._syh_on_choices_inv[i]))
self._syh_on_callback(self.syh_on)
_syh_on_check_box.stateChanged.connect(
lambda i: self.set_syh_on(self._syh_on_choices[bool(i)]))
self.gui_tab_configuracion_grid_layout_0.addWidget(
_syh_on_check_box, 0, 0, 1, 1)
for r in range(0, 1):
self.gui_tab_configuracion_grid_layout_0.setRowStretch(r, 1)
for c in range(0, 1):
self.gui_tab_configuracion_grid_layout_0.setColumnStretch(c, 1)
_switch_on_check_box = Qt.QCheckBox("Llave analogica on")
self._switch_on_choices = {True: 1, False: 0}
self._switch_on_choices_inv = dict(
(v, k) for k, v in self._switch_on_choices.iteritems())
self._switch_on_callback = lambda i: Qt.QMetaObject.invokeMethod(
_switch_on_check_box, "setChecked",
Qt.Q_ARG("bool", self._switch_on_choices_inv[i]))
self._switch_on_callback(self.switch_on)
_switch_on_check_box.stateChanged.connect(
lambda i: self.set_switch_on(self._switch_on_choices[bool(i)]))
self.gui_tab_configuracion_grid_layout_0.addWidget(
_switch_on_check_box, 0, 1, 1, 1)
for r in range(0, 1):
self.gui_tab_configuracion_grid_layout_0.setRowStretch(r, 1)
for c in range(1, 2):
self.gui_tab_configuracion_grid_layout_0.setColumnStretch(c, 1)
self._seniales_control_iguales_options = (
0,
1,
)
self._seniales_control_iguales_labels = (
'Iguales',
'Invertidas',
)
self._seniales_control_iguales_tool_bar = Qt.QToolBar(self)
self._seniales_control_iguales_tool_bar.addWidget(
Qt.QLabel('Relacion seniales control' + ": "))
self._seniales_control_iguales_combo_box = Qt.QComboBox()
self._seniales_control_iguales_tool_bar.addWidget(
self._seniales_control_iguales_combo_box)
for label in self._seniales_control_iguales_labels:
self._seniales_control_iguales_combo_box.addItem(label)
self._seniales_control_iguales_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._seniales_control_iguales_combo_box, "setCurrentIndex",
Qt.Q_ARG("int", self._seniales_control_iguales_options.index(i)))
self._seniales_control_iguales_callback(self.seniales_control_iguales)
self._seniales_control_iguales_combo_box.currentIndexChanged.connect(
lambda i: self.set_seniales_control_iguales(
self._seniales_control_iguales_options[i]))
self.gui_tab_configuracion_grid_layout_1.addWidget(
self._seniales_control_iguales_tool_bar, 0, 1, 1, 1)
for r in range(0, 1):
self.gui_tab_configuracion_grid_layout_1.setRowStretch(r, 1)
for c in range(1, 2):
self.gui_tab_configuracion_grid_layout_1.setColumnStretch(c, 1)
self._mod_index_range = Range(0, 1, 0.05, mod_index0, 200)
self._mod_index_win = RangeWidget(self._mod_index_range,
self.set_mod_index,
'Indice de modulacion (solo AM)',
"counter_slider", float)
self.gui_tab_configuracion_grid_layout_1.addWidget(
self._mod_index_win, 3, 1, 1, 1)
for r in range(3, 4):
self.gui_tab_configuracion_grid_layout_1.setRowStretch(r, 1)
for c in range(1, 2):
self.gui_tab_configuracion_grid_layout_1.setColumnStretch(c, 1)
self._input_signal_options = (
0,
1,
2,
3,
)
self._input_signal_labels = (
'Seno',
'Diente de sierra',
'Seno 3/2',
'Senial AM',
)
self._input_signal_tool_bar = Qt.QToolBar(self)
self._input_signal_tool_bar.addWidget(Qt.QLabel("input_signal" + ": "))
self._input_signal_combo_box = Qt.QComboBox()
self._input_signal_tool_bar.addWidget(self._input_signal_combo_box)
for label in self._input_signal_labels:
self._input_signal_combo_box.addItem(label)
self._input_signal_callback = lambda i: Qt.QMetaObject.invokeMethod(
self._input_signal_combo_box, "setCurrentIndex",
Qt.Q_ARG("int", self._input_signal_options.index(i)))
self._input_signal_callback(self.input_signal)
self._input_signal_combo_box.currentIndexChanged.connect(
lambda i: self.set_input_signal(self._input_signal_options[i]))
self.gui_tab_configuracion_grid_layout_1.addWidget(
self._input_signal_tool_bar, 0, 0, 1, 1)
for r in range(0, 1):
self.gui_tab_configuracion_grid_layout_1.setRowStretch(r, 1)
for c in range(0, 1):
self.gui_tab_configuracion_grid_layout_1.setColumnStretch(c, 1)
self._input_freq_range = Range(freq0 / 10, freq0 * 10, freq0 / 100,
freq0, 200)
self._input_freq_win = RangeWidget(
self._input_freq_range, self.set_input_freq,
'Frecuencia senial de entrada (no AM ni sen32)', "counter_slider",
float)
self.gui_tab_configuracion_grid_layout_1.addWidget(
self._input_freq_win, 1, 0, 1, 1)
for r in range(1, 2):
self.gui_tab_configuracion_grid_layout_1.setRowStretch(r, 1)
for c in range(0, 1):
self.gui_tab_configuracion_grid_layout_1.setColumnStretch(c, 1)
self._fs_range = Range(400, 130000, 100, fs0, 200)
self._fs_win = RangeWidget(self._fs_range, self.set_fs,
'Frecuencia de muestreo ', "counter_slider",
float)
self.gui_tab_configuracion_grid_layout_1.addWidget(
self._fs_win, 3, 0, 1, 1)
for r in range(3, 4):
self.gui_tab_configuracion_grid_layout_1.setRowStretch(r, 1)
for c in range(0, 1):
self.gui_tab_configuracion_grid_layout_1.setColumnStretch(c, 1)
self._fpor_range = Range(100, 130000, 100, fpor0, 200)
self._fpor_win = RangeWidget(self._fpor_range, self.set_fpor,
'Frecuencia portadora (solo AM)',
"counter_slider", float)
self.gui_tab_configuracion_grid_layout_1.addWidget(
self._fpor_win, 2, 1, 1, 1)
for r in range(2, 3):
self.gui_tab_configuracion_grid_layout_1.setRowStretch(r, 1)
for c in range(1, 2):
self.gui_tab_configuracion_grid_layout_1.setColumnStretch(c, 1)
self._fmod_range = Range(100, 130000, 100, fmod0, 200)
self._fmod_win = RangeWidget(self._fmod_range, self.set_fmod,
'Frecuencia moduladora (solo AM)',
"counter_slider", float)
self.gui_tab_configuracion_grid_layout_1.addWidget(
self._fmod_win, 1, 1, 1, 1)
for r in range(1, 2):
self.gui_tab_configuracion_grid_layout_1.setRowStretch(r, 1)
for c in range(1, 2):
self.gui_tab_configuracion_grid_layout_1.setColumnStretch(c, 1)
_filtro_recuperador_on_check_box = Qt.QCheckBox(
"Filtro recuperador on")
self._filtro_recuperador_on_choices = {True: 1, False: 0}
self._filtro_recuperador_on_choices_inv = dict(
(v, k) for k, v in self._filtro_recuperador_on_choices.iteritems())
self._filtro_recuperador_on_callback = lambda i: Qt.QMetaObject.invokeMethod(
_filtro_recuperador_on_check_box, "setChecked",
Qt.Q_ARG("bool", self._filtro_recuperador_on_choices_inv[i]))
self._filtro_recuperador_on_callback(self.filtro_recuperador_on)
_filtro_recuperador_on_check_box.stateChanged.connect(
lambda i: self.set_filtro_recuperador_on(
self._filtro_recuperador_on_choices[bool(i)]))
self.gui_tab_configuracion_grid_layout_0.addWidget(
_filtro_recuperador_on_check_box, 0, 2, 1, 1)
for r in range(0, 1):
self.gui_tab_configuracion_grid_layout_0.setRowStretch(r, 1)
for c in range(2, 3):
self.gui_tab_configuracion_grid_layout_0.setColumnStretch(c, 1)
_filtro_antialiasing_on_check_box = Qt.QCheckBox(
"Filtro antialiasing on")
self._filtro_antialiasing_on_choices = {True: 1, False: 0}
self._filtro_antialiasing_on_choices_inv = dict(
(v, k)
for k, v in self._filtro_antialiasing_on_choices.iteritems())
self._filtro_antialiasing_on_callback = lambda i: Qt.QMetaObject.invokeMethod(
_filtro_antialiasing_on_check_box, "setChecked",
Qt.Q_ARG("bool", self._filtro_antialiasing_on_choices_inv[i]))
self._filtro_antialiasing_on_callback(self.filtro_antialiasing_on)
_filtro_antialiasing_on_check_box.stateChanged.connect(
lambda i: self.set_filtro_antialiasing_on(
self._filtro_antialiasing_on_choices[bool(i)]))
self.gui_tab_configuracion_grid_layout_0.addWidget(
_filtro_antialiasing_on_check_box, 0, 3, 1, 1)
for r in range(0, 1):
self.gui_tab_configuracion_grid_layout_0.setRowStretch(r, 1)
for c in range(3, 4):
self.gui_tab_configuracion_grid_layout_0.setColumnStretch(c, 1)
self._dutycycle_range = Range(0.05, 0.95, 0.05, dutycycle0, 200)
self._dutycycle_win = RangeWidget(self._dutycycle_range,
self.set_dutycycle, 'Duty cycle',
"counter_slider", float)
self.gui_tab_configuracion_grid_layout_1.addWidget(
self._dutycycle_win, 2, 0, 1, 1)
for r in range(2, 3):
self.gui_tab_configuracion_grid_layout_1.setRowStretch(r, 1)
for c in range(0, 1):
self.gui_tab_configuracion_grid_layout_1.setColumnStretch(c, 1)
self._amplitud_range = Range(0, 5, 0.2, amplitud0, 200)
self._amplitud_win = RangeWidget(self._amplitud_range,
self.set_amplitud, 'Amplitud',
"counter_slider", float)
self.gui_tab_configuracion_grid_layout_1.addWidget(
self._amplitud_win, 4, 1, 1, 1)
for r in range(4, 5):
self.gui_tab_configuracion_grid_layout_1.setRowStretch(r, 1)
for c in range(1, 2):
self.gui_tab_configuracion_grid_layout_1.setColumnStretch(c, 1)
self.senoidal = analog.sig_source_f(samp_rate, analog.GR_SIN_WAVE,
input_freq, 1, 0)
self.sen32 = blocks.wavfile_source('sen32.wav', True)
self.qtgui_time_sink_x_0 = qtgui.time_sink_f(
1024, #size
samp_rate, #samp_rate
"Output", #name
6 #number of inputs
)
self.qtgui_time_sink_x_0.set_update_time(0.10)
self.qtgui_time_sink_x_0.set_y_axis(-1, 1)
self.qtgui_time_sink_x_0.set_y_label('Amplitude', "")
self.qtgui_time_sink_x_0.enable_tags(-1, True)
self.qtgui_time_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE,
qtgui.TRIG_SLOPE_POS, 0.1, 0,
0, "")
self.qtgui_time_sink_x_0.enable_autoscale(False)
self.qtgui_time_sink_x_0.enable_grid(True)
self.qtgui_time_sink_x_0.enable_axis_labels(True)
self.qtgui_time_sink_x_0.enable_control_panel(True)
self.qtgui_time_sink_x_0.enable_stem_plot(False)
if not True:
self.qtgui_time_sink_x_0.disable_legend()
labels = [
'Salida filtro antialias', 'Salida sample and hold',
'Salida llave analogica', 'Salida filtro recuperador', 'Entrada',
'Output', '', '', '', ''
]
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
"blue", "red", "green", "magenta", "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(6):
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.main_tab_grid_layout_0.addWidget(self._qtgui_time_sink_x_0_win, 1,
0, 1, 1)
for r in range(1, 2):
self.main_tab_grid_layout_0.setRowStretch(r, 1)
for c in range(0, 1):
self.main_tab_grid_layout_0.setColumnStretch(c, 1)
self.qtgui_freq_sink_x_0 = qtgui.freq_sink_f(
1024, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
samp_rate, #bw
"", #name
6 #number of inputs
)
self.qtgui_freq_sink_x_0.set_update_time(0.10)
self.qtgui_freq_sink_x_0.set_y_axis(-140, 10)
self.qtgui_freq_sink_x_0.set_y_label('Relative Gain', 'dB')
self.qtgui_freq_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0,
"")
self.qtgui_freq_sink_x_0.enable_autoscale(True)
self.qtgui_freq_sink_x_0.enable_grid(True)
self.qtgui_freq_sink_x_0.set_fft_average(1.0)
self.qtgui_freq_sink_x_0.enable_axis_labels(True)
self.qtgui_freq_sink_x_0.enable_control_panel(True)
if not True:
self.qtgui_freq_sink_x_0.disable_legend()
if "float" == "float" or "float" == "msg_float":
self.qtgui_freq_sink_x_0.set_plot_pos_half(not False)
labels = [
'Salida filtro antialias', 'Salida sample and hold',
'Salida llave analogica', 'Salida filtro recuperador', 'Entrada',
'Output', '', '', '', ''
]
widths = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
colors = [
"blue", "red", "green", "magenta", "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(6):
if len(labels[i]) == 0:
self.qtgui_freq_sink_x_0.set_line_label(
i, "Data {0}".format(i))
else:
self.qtgui_freq_sink_x_0.set_line_label(i, labels[i])
self.qtgui_freq_sink_x_0.set_line_width(i, widths[i])
self.qtgui_freq_sink_x_0.set_line_color(i, colors[i])
self.qtgui_freq_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_freq_sink_x_0_win = sip.wrapinstance(
self.qtgui_freq_sink_x_0.pyqwidget(), Qt.QWidget)
self.main_tab_grid_layout_0.addWidget(self._qtgui_freq_sink_x_0_win, 2,
0, 1, 1)
for r in range(2, 3):
self.main_tab_grid_layout_0.setRowStretch(r, 1)
for c in range(0, 1):
self.main_tab_grid_layout_0.setColumnStretch(c, 1)
self.portadora = analog.sig_source_f(samp_rate, analog.GR_SIN_WAVE,
fpor, 1, 0)
self.moduladora = analog.sig_source_f(samp_rate, analog.GR_SIN_WAVE,
fmod, 1, 0)
self.filtro_recuperador = filter.fir_filter_fff(
1,
firdes.low_pass(1, samp_rate, freq0 * 18, freq0 * 18 * 0.5,
firdes.WIN_HAMMING, 6.76))
self.filtro_antialiasing = filter.fir_filter_fff(
1,
firdes.low_pass(1, samp_rate, freq0 * 18, freq0 * 18 * 0.5,
firdes.WIN_HAMMING, 6.76))
self.diente_de_sierra = analog.sig_source_f(samp_rate,
analog.GR_SAW_WAVE,
input_freq, 1, 0)
self.blocks_throttle_0 = blocks.throttle(gr.sizeof_float * 1,
samp_rate, True)
self.blocks_threshold_ff_0 = blocks.threshold_ff(
dutycycle, dutycycle, 0)
self.blocks_sample_and_hold_xx_0 = blocks.sample_and_hold_ff()
self.blocks_multiply_xx_1 = blocks.multiply_vff(1)
self.blocks_multiply_xx_0 = blocks.multiply_vff(1)
self.blocks_multiply_const_vxx_0_0_0 = blocks.multiply_const_vff(
(amplitud, ))
self.blocks_multiply_const_vxx_0_0 = blocks.multiply_const_vff(
(mod_index, ))
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff(
(seniales_control_iguales, ))
self.blocks_float_to_char_0 = blocks.float_to_char(1, 1)
self.blocks_add_const_vxx_1 = blocks.add_const_vff((1, ))
self.blocks_add_const_vxx_0 = blocks.add_const_vff((-1, ))
self.blks2_selector_1 = grc_blks2.selector(
item_size=gr.sizeof_float * 1,
num_inputs=2,
num_outputs=1,
input_index=seniales_control_iguales,
output_index=0,
)
self.blks2_selector_0_1 = grc_blks2.selector(
item_size=gr.sizeof_float * 1,
num_inputs=4,
num_outputs=1,
input_index=input_signal,
output_index=0,
)
self.blks2_selector_0_0_0_0 = grc_blks2.selector(
item_size=gr.sizeof_float * 1,
num_inputs=2,
num_outputs=1,
input_index=filtro_antialiasing_on,
output_index=0,
)
self.blks2_selector_0_0_0 = grc_blks2.selector(
item_size=gr.sizeof_float * 1,
num_inputs=2,
num_outputs=1,
input_index=filtro_recuperador_on,
output_index=0,
)
self.blks2_selector_0_0 = grc_blks2.selector(
item_size=gr.sizeof_float * 1,
num_inputs=2,
num_outputs=1,
input_index=switch_on,
output_index=0,
)
self.blks2_selector_0 = grc_blks2.selector(
item_size=gr.sizeof_float * 1,
num_inputs=2,
num_outputs=1,
input_index=syh_on,
output_index=0,
)
self.analog_sig_source_x_0_0 = analog.sig_source_f(
samp_rate, analog.GR_SAW_WAVE, fs, 1, 0)
##################################################
# Connections
##################################################
self.connect((self.analog_sig_source_x_0_0, 0),
(self.blocks_threshold_ff_0, 0))
self.connect((self.blks2_selector_0, 0), (self.blks2_selector_0_0, 0))
self.connect((self.blks2_selector_0, 0),
(self.blocks_multiply_xx_0, 0))
self.connect((self.blks2_selector_0_0, 0),
(self.blks2_selector_0_0_0, 0))
self.connect((self.blks2_selector_0_0, 0),
(self.filtro_recuperador, 0))
self.connect((self.blks2_selector_0_0_0, 0),
(self.qtgui_freq_sink_x_0, 5))
self.connect((self.blks2_selector_0_0_0, 0),
(self.qtgui_time_sink_x_0, 5))
self.connect((self.blks2_selector_0_0_0_0, 0),
(self.blks2_selector_0, 0))
self.connect((self.blks2_selector_0_0_0_0, 0),
(self.blocks_sample_and_hold_xx_0, 0))
self.connect((self.blks2_selector_0_1, 0),
(self.blocks_multiply_const_vxx_0_0_0, 0))
self.connect((self.blks2_selector_1, 0),
(self.blocks_float_to_char_0, 0))
self.connect((self.blocks_add_const_vxx_0, 0),
(self.blocks_multiply_const_vxx_0, 0))
self.connect((self.blocks_add_const_vxx_1, 0),
(self.blocks_multiply_xx_1, 1))
self.connect((self.blocks_float_to_char_0, 0),
(self.blocks_sample_and_hold_xx_0, 1))
self.connect((self.blocks_multiply_const_vxx_0, 0),
(self.blks2_selector_1, 1))
self.connect((self.blocks_multiply_const_vxx_0_0, 0),
(self.blocks_add_const_vxx_1, 0))
self.connect((self.blocks_multiply_const_vxx_0_0_0, 0),
(self.blocks_throttle_0, 0))
self.connect((self.blocks_multiply_xx_0, 0),
(self.blks2_selector_0_0, 1))
self.connect((self.blocks_multiply_xx_0, 0),
(self.qtgui_freq_sink_x_0, 2))
self.connect((self.blocks_multiply_xx_0, 0),
(self.qtgui_time_sink_x_0, 2))
self.connect((self.blocks_multiply_xx_1, 0),
(self.blks2_selector_0_1, 3))
self.connect((self.blocks_sample_and_hold_xx_0, 0),
(self.blks2_selector_0, 1))
self.connect((self.blocks_sample_and_hold_xx_0, 0),
(self.qtgui_freq_sink_x_0, 1))
self.connect((self.blocks_sample_and_hold_xx_0, 0),
(self.qtgui_time_sink_x_0, 1))
self.connect((self.blocks_threshold_ff_0, 0),
(self.blks2_selector_1, 0))
self.connect((self.blocks_threshold_ff_0, 0),
(self.blocks_add_const_vxx_0, 0))
self.connect((self.blocks_threshold_ff_0, 0),
(self.blocks_multiply_xx_0, 1))
self.connect((self.blocks_throttle_0, 0),
(self.blks2_selector_0_0_0_0, 0))
self.connect((self.blocks_throttle_0, 0),
(self.filtro_antialiasing, 0))
self.connect((self.blocks_throttle_0, 0),
(self.qtgui_freq_sink_x_0, 4))
self.connect((self.blocks_throttle_0, 0),
(self.qtgui_time_sink_x_0, 4))
self.connect((self.diente_de_sierra, 0), (self.blks2_selector_0_1, 1))
self.connect((self.filtro_antialiasing, 0),
(self.blks2_selector_0_0_0_0, 1))
self.connect((self.filtro_antialiasing, 0),
(self.qtgui_freq_sink_x_0, 0))
self.connect((self.filtro_antialiasing, 0),
(self.qtgui_time_sink_x_0, 0))
self.connect((self.filtro_recuperador, 0),
(self.blks2_selector_0_0_0, 1))
self.connect((self.filtro_recuperador, 0),
(self.qtgui_freq_sink_x_0, 3))
self.connect((self.filtro_recuperador, 0),
(self.qtgui_time_sink_x_0, 3))
self.connect((self.moduladora, 0),
(self.blocks_multiply_const_vxx_0_0, 0))
self.connect((self.portadora, 0), (self.blocks_multiply_xx_1, 0))
self.connect((self.sen32, 0), (self.blks2_selector_0_1, 2))
self.connect((self.senoidal, 0), (self.blks2_selector_0_1, 0))
def __init__(self, ts, factor, alpha, samp_rate, freqs):
"""
Description:
This block is designed to perform frequency and timing acquisition for a known training sequence in the presense of frequency and timing offset and noise. Its input is a complex stream. It has three outputs:
1) a stream of flags (bytes) indicating the begining of the training sequence (to be used from subsequent blocks to "chop" the incoming stream,
2) a stream with the current acquired frequency offset, and
3) a stream with the current acquired peak of the matched filter
Internally, it consists of a user defined number of parallel matched filters (as many as the size of the freqs vector), each consistng of a frequency Xlating FIR filter with sample rate samp_rate, filter taps matched to the training sequence ts, and center frequency freqs[i]. The filter outputs are magnitude squared and passed through a max block and then through a peak detector.
Args:
ts: the training sequence. For example, in DSSS system, it's the chip-based spread training sequence.
factor: the rise and fall factors in peak detector, which is the factor determining when a peak has started and ended. In the peak detector, an average of the signal is calculated. When the value of the signal goes over factor*average, we start looking for a peak. When the value of the signal goes below factor*average, we stop looking for a peak. factor takes values in (0,1).
alpha: the smoothing factor of a moving average filter used in the peak detector takeng values in (0,1).
samp_rate: the sample rate of the system, which is used in the freq_xlating_fir_filter.
freqs: the vector of center frequencies for each matched filter. Note that for a training sequence of length Nt, each matched filter can recover a sequence with normalized frequency offset ~ 1/(2Nt).
"""
gr.hier_block2.__init__(
self, "freq_timing_estimator",
gr.io_signature(1, 1, gr.sizeof_gr_complex*1),
gr.io_signaturev(3, 3, [gr.sizeof_char*1, gr.sizeof_float*1, gr.sizeof_float*1]),
)
##################################################
# Parameters
##################################################
self.ts = ts
self.factor = factor
self.alpha = alpha
self.samp_rate = samp_rate
self.freqs = freqs
self.n = n = len(freqs)
##################################################
# Blocks
##################################################
self._filter=[0]*self.n
self._c2mag2=[0]*self.n
for i in range(self.n):
self._filter[i]= filter.freq_xlating_fir_filter_ccc(1, (numpy.conjugate(self.ts[::-1])), self.freqs[i], self.samp_rate)
self._c2mag2[i] = blocks.complex_to_mag_squared(1)
self.blocks_max = blocks.max_ff(1)
self.blocks_peak_detector = blocks.peak_detector_fb(self.factor, self.factor, 0, self.alpha)
self.blocks_argmax = blocks.argmax_fs(1)
self.blocks_null_sink = blocks.null_sink(gr.sizeof_short*1)
self.digital_chunks_to_symbols = digital.chunks_to_symbols_sf((freqs), 1)
self.blocks_sample_and_hold = blocks.sample_and_hold_ff()
##################################################
# Connections
##################################################
for i in range(self.n):
self.connect((self, 0), (self._filter[i], 0))
self.connect((self._filter[i], 0), (self._c2mag2[i], 0))
self.connect((self._c2mag2[i], 0), (self.blocks_max, i))
self.connect((self._c2mag2[i], 0), (self.blocks_argmax, i))
self.connect((self.blocks_max, 0), (self.blocks_peak_detector, 0))
self.connect((self.blocks_peak_detector, 0), (self, 0))
self.connect((self.blocks_argmax, 0), (self.blocks_null_sink, 0))
self.connect((self.blocks_argmax, 1), (self.digital_chunks_to_symbols, 0))
self.connect((self.digital_chunks_to_symbols, 0), (self.blocks_sample_and_hold, 0))
self.connect((self.blocks_peak_detector, 0), (self.blocks_sample_and_hold, 1))
self.connect((self.blocks_sample_and_hold, 0), (self, 1))
self.connect((self.blocks_max, 0), (self, 2))
def __init__(self):
gr.top_block.__init__(self, "Simulation G3")
Qt.QWidget.__init__(self)
self.setWindowTitle("Simulation G3")
qtgui.util.check_set_qss()
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.variable_qtgui_chooser_0 = variable_qtgui_chooser_0 = 0
self.samplenholdcheck = samplenholdcheck = True
self.samp_rate = samp_rate = 300000
self.m = m = 0.5
self.llaveAnalcheck = llaveAnalcheck = True
self.fportadora = fportadora = 3000
self.fp = fp = 10500
self.fmoduladora = fmoduladora = 300
self.faacheck = faacheck = True
self.dutycycle = dutycycle = 0.5
self.UIF = UIF = 1500
self.SR = SR = 20000
self.FR = FR = True
self.AMPLITUD = AMPLITUD = 1
##################################################
# Blocks
##################################################
self._variable_qtgui_chooser_0_options = (0, 1, 2, 3, )
self._variable_qtgui_chooser_0_labels = ('Sine', 'Triangle', 'SIN3/2', 'AM', )
self._variable_qtgui_chooser_0_tool_bar = Qt.QToolBar(self)
self._variable_qtgui_chooser_0_tool_bar.addWidget(Qt.QLabel('Signal'+": "))
self._variable_qtgui_chooser_0_combo_box = Qt.QComboBox()
self._variable_qtgui_chooser_0_tool_bar.addWidget(self._variable_qtgui_chooser_0_combo_box)
for label in self._variable_qtgui_chooser_0_labels: self._variable_qtgui_chooser_0_combo_box.addItem(label)
self._variable_qtgui_chooser_0_callback = lambda i: Qt.QMetaObject.invokeMethod(self._variable_qtgui_chooser_0_combo_box, "setCurrentIndex", Qt.Q_ARG("int", self._variable_qtgui_chooser_0_options.index(i)))
self._variable_qtgui_chooser_0_callback(self.variable_qtgui_chooser_0)
self._variable_qtgui_chooser_0_combo_box.currentIndexChanged.connect(
lambda i: self.set_variable_qtgui_chooser_0(self._variable_qtgui_chooser_0_options[i]))
self.top_grid_layout.addWidget(self._variable_qtgui_chooser_0_tool_bar, 0, 0, 1, 1)
for r in range(0, 1):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(0, 1):
self.top_grid_layout.setColumnStretch(c, 1)
_samplenholdcheck_check_box = Qt.QCheckBox('Sample and Hold')
self._samplenholdcheck_choices = {True: True, False: False}
self._samplenholdcheck_choices_inv = dict((v,k) for k,v in self._samplenholdcheck_choices.iteritems())
self._samplenholdcheck_callback = lambda i: Qt.QMetaObject.invokeMethod(_samplenholdcheck_check_box, "setChecked", Qt.Q_ARG("bool", self._samplenholdcheck_choices_inv[i]))
self._samplenholdcheck_callback(self.samplenholdcheck)
_samplenholdcheck_check_box.stateChanged.connect(lambda i: self.set_samplenholdcheck(self._samplenholdcheck_choices[bool(i)]))
self.top_grid_layout.addWidget(_samplenholdcheck_check_box, 2, 0, 1, 1)
for r in range(2, 3):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(0, 1):
self.top_grid_layout.setColumnStretch(c, 1)
self._m_range = Range(0, 1, 0.05, 0.5, 200)
self._m_win = RangeWidget(self._m_range, self.set_m, 'Modulation coefficient', "counter", float)
self.top_grid_layout.addWidget(self._m_win, 5, 4, 1, 1)
for r in range(5, 6):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(4, 5):
self.top_grid_layout.setColumnStretch(c, 1)
_llaveAnalcheck_check_box = Qt.QCheckBox('Analog Switch')
self._llaveAnalcheck_choices = {True: True, False: False}
self._llaveAnalcheck_choices_inv = dict((v,k) for k,v in self._llaveAnalcheck_choices.iteritems())
self._llaveAnalcheck_callback = lambda i: Qt.QMetaObject.invokeMethod(_llaveAnalcheck_check_box, "setChecked", Qt.Q_ARG("bool", self._llaveAnalcheck_choices_inv[i]))
self._llaveAnalcheck_callback(self.llaveAnalcheck)
_llaveAnalcheck_check_box.stateChanged.connect(lambda i: self.set_llaveAnalcheck(self._llaveAnalcheck_choices[bool(i)]))
self.top_grid_layout.addWidget(_llaveAnalcheck_check_box, 3, 0, 1, 1)
for r in range(3, 4):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(0, 1):
self.top_grid_layout.setColumnStretch(c, 1)
self._fportadora_range = Range(500, 3000, 100, 3000, 200)
self._fportadora_win = RangeWidget(self._fportadora_range, self.set_fportadora, 'Carrier frequency', "counter_slider", float)
self.top_grid_layout.addWidget(self._fportadora_win, 4, 4, 1, 1)
for r in range(4, 5):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(4, 5):
self.top_grid_layout.setColumnStretch(c, 1)
self._fmoduladora_range = Range(1, 500, 10, 300, 200)
self._fmoduladora_win = RangeWidget(self._fmoduladora_range, self.set_fmoduladora, 'Modulator frequency', "counter_slider", float)
self.top_grid_layout.addWidget(self._fmoduladora_win, 3, 4, 1, 1)
for r in range(3, 4):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(4, 5):
self.top_grid_layout.setColumnStretch(c, 1)
_faacheck_check_box = Qt.QCheckBox('Anti-Alias Filter')
self._faacheck_choices = {True: True, False: False}
self._faacheck_choices_inv = dict((v,k) for k,v in self._faacheck_choices.iteritems())
self._faacheck_callback = lambda i: Qt.QMetaObject.invokeMethod(_faacheck_check_box, "setChecked", Qt.Q_ARG("bool", self._faacheck_choices_inv[i]))
self._faacheck_callback(self.faacheck)
_faacheck_check_box.stateChanged.connect(lambda i: self.set_faacheck(self._faacheck_choices[bool(i)]))
self.top_grid_layout.addWidget(_faacheck_check_box, 1, 0, 1, 1)
for r in range(1, 2):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(0, 1):
self.top_grid_layout.setColumnStretch(c, 1)
self._dutycycle_range = Range(0.05, 0.95, 0.05, 0.5, 50)
self._dutycycle_win = RangeWidget(self._dutycycle_range, self.set_dutycycle, 'Duty cycle', "counter_slider", float)
self.top_grid_layout.addWidget(self._dutycycle_win, 0, 1, 1, 1)
for r in range(0, 1):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(1, 2):
self.top_grid_layout.setColumnStretch(c, 1)
self._UIF_range = Range(100, 20000, 10, 1500, 200)
self._UIF_win = RangeWidget(self._UIF_range, self.set_UIF, 'Frequency', "counter_slider", float)
self.top_grid_layout.addWidget(self._UIF_win, 3, 1, 2, 3)
for r in range(3, 5):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(1, 4):
self.top_grid_layout.setColumnStretch(c, 1)
self._SR_range = Range(100, 50000, 100, 20000, 200)
self._SR_win = RangeWidget(self._SR_range, self.set_SR, 'Sample Rate', "counter_slider", float)
self.top_grid_layout.addWidget(self._SR_win, 1, 1, 2, 3)
for r in range(1, 3):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(1, 4):
self.top_grid_layout.setColumnStretch(c, 1)
_FR_check_box = Qt.QCheckBox('Recover Filter')
self._FR_choices = {True: True, False: False}
self._FR_choices_inv = dict((v,k) for k,v in self._FR_choices.iteritems())
self._FR_callback = lambda i: Qt.QMetaObject.invokeMethod(_FR_check_box, "setChecked", Qt.Q_ARG("bool", self._FR_choices_inv[i]))
self._FR_callback(self.FR)
_FR_check_box.stateChanged.connect(lambda i: self.set_FR(self._FR_choices[bool(i)]))
self.top_grid_layout.addWidget(_FR_check_box, 4, 0, 1, 1)
for r in range(4, 5):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(0, 1):
self.top_grid_layout.setColumnStretch(c, 1)
self._AMPLITUD_range = Range(1, 15, 1, 1, 200)
self._AMPLITUD_win = RangeWidget(self._AMPLITUD_range, self.set_AMPLITUD, 'Amplitude', "counter", float)
self.top_grid_layout.addWidget(self._AMPLITUD_win, 0, 3, 1, 1)
for r in range(0, 1):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(3, 4):
self.top_grid_layout.setColumnStretch(c, 1)
self.sen32 = blocks.wavfile_source('sen32.wav', True)
self.qtgui_time_sink_x_0 = qtgui.time_sink_f(
1024, #size
samp_rate, #samp_rate
"", #name
5 #number of inputs
)
self.qtgui_time_sink_x_0.set_update_time(0.10)
self.qtgui_time_sink_x_0.set_y_axis(-1, 1)
self.qtgui_time_sink_x_0.set_y_label('Amplitude', "")
self.qtgui_time_sink_x_0.enable_tags(-1, False)
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(False)
self.qtgui_time_sink_x_0.enable_grid(False)
self.qtgui_time_sink_x_0.enable_axis_labels(True)
self.qtgui_time_sink_x_0.enable_control_panel(True)
self.qtgui_time_sink_x_0.enable_stem_plot(False)
if not True:
self.qtgui_time_sink_x_0.disable_legend()
labels = ['Input', 'AAF', 'Sample and Hold', 'Analog Switch', 'RF',
'poronga', 'Poronga Char', '', '', '']
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(5):
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_grid_layout.addWidget(self._qtgui_time_sink_x_0_win, 6, 0, 1, 4)
for r in range(6, 7):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(0, 4):
self.top_grid_layout.setColumnStretch(c, 1)
self.qtgui_freq_sink_x_0 = qtgui.freq_sink_f(
1024, #size
firdes.WIN_BLACKMAN_hARRIS, #wintype
0, #fc
samp_rate, #bw
"", #name
5 #number of inputs
)
self.qtgui_freq_sink_x_0.set_update_time(0.10)
self.qtgui_freq_sink_x_0.set_y_axis(-140, 10)
self.qtgui_freq_sink_x_0.set_y_label('Relative Gain', 'dB')
self.qtgui_freq_sink_x_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, 0.0, 0, "")
self.qtgui_freq_sink_x_0.enable_autoscale(False)
self.qtgui_freq_sink_x_0.enable_grid(False)
self.qtgui_freq_sink_x_0.set_fft_average(1.0)
self.qtgui_freq_sink_x_0.enable_axis_labels(True)
self.qtgui_freq_sink_x_0.enable_control_panel(True)
if not True:
self.qtgui_freq_sink_x_0.disable_legend()
if "float" == "float" or "float" == "msg_float":
self.qtgui_freq_sink_x_0.set_plot_pos_half(not True)
labels = ['Input', 'AAF', 'Sample and Hold', 'Analog Switch', 'FR',
'', '', '', '', '']
widths = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
colors = ["blue", "red", "black", "magenta", "dark red",
"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(5):
if len(labels[i]) == 0:
self.qtgui_freq_sink_x_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_freq_sink_x_0.set_line_label(i, labels[i])
self.qtgui_freq_sink_x_0.set_line_width(i, widths[i])
self.qtgui_freq_sink_x_0.set_line_color(i, colors[i])
self.qtgui_freq_sink_x_0.set_line_alpha(i, alphas[i])
self._qtgui_freq_sink_x_0_win = sip.wrapinstance(self.qtgui_freq_sink_x_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_freq_sink_x_0_win, 8, 0, 1, 4)
for r in range(8, 9):
self.top_grid_layout.setRowStretch(r, 1)
for c in range(0, 4):
self.top_grid_layout.setColumnStretch(c, 1)
self.low_pass_filter_0 = filter.interp_fir_filter_fff(1, firdes.low_pass(
1, samp_rate, fp, 2500, firdes.WIN_HAMMING, 6.76))
self.filtro_antialiasing = filter.fir_filter_fff(1, firdes.low_pass(
1, samp_rate, fp, 2500, firdes.WIN_HAMMING, 6.76))
self.blocks_throttle_0_0_0 = blocks.throttle(gr.sizeof_float*1, samp_rate,True)
self.blocks_throttle_0_0 = blocks.throttle(gr.sizeof_float*1, samp_rate,True)
self.blocks_threshold_ff_0 = blocks.threshold_ff(1-dutycycle, 1-dutycycle, 0)
self.blocks_sample_and_hold_xx_0 = blocks.sample_and_hold_ff()
self.blocks_multiply_xx_0 = blocks.multiply_vff(1)
self.blocks_multiply_const_vxx_0_2 = blocks.multiply_const_vff((AMPLITUD, ))
self.blocks_multiply_const_vxx_0_1_0 = blocks.multiply_const_vff((-1, ))
self.blocks_multiply_const_vxx_0_1 = blocks.multiply_const_vff((m/2, ))
self.blocks_multiply_const_vxx_0_0 = blocks.multiply_const_vff((m/2, ))
self.blocks_multiply_const_vxx_0 = blocks.multiply_const_vff((2, ))
self.blocks_float_to_char_0_2 = blocks.float_to_char(1, 1)
self.blocks_add_xx_0 = blocks.add_vff(1)
self.blocks_add_const_vxx_0 = blocks.add_const_vff((1, ))
self.blks2_selector_0_1_0_0_0_0 = grc_blks2.selector(
item_size=gr.sizeof_float*1,
num_inputs=2,
num_outputs=1,
input_index=FR,
output_index=0,
)
self.blks2_selector_0_1_0_0_0 = grc_blks2.selector(
item_size=gr.sizeof_float*1,
num_inputs=2,
num_outputs=1,
input_index=llaveAnalcheck,
output_index=0,
)
self.blks2_selector_0_1_0_0 = grc_blks2.selector(
item_size=gr.sizeof_float*1,
num_inputs=2,
num_outputs=1,
input_index=samplenholdcheck,
output_index=0,
)
self.blks2_selector_0_1_0 = grc_blks2.selector(
item_size=gr.sizeof_float*1,
num_inputs=2,
num_outputs=1,
input_index=faacheck,
output_index=0,
)
self.blks2_selector_0_1 = grc_blks2.selector(
item_size=gr.sizeof_float*1,
num_inputs=4,
num_outputs=1,
input_index=variable_qtgui_chooser_0,
output_index=0,
)
self.analog_sig_source_x_0_2_1 = analog.sig_source_f(samp_rate, analog.GR_SIN_WAVE, fportadora-fmoduladora, AMPLITUD, 0)
self.analog_sig_source_x_0_2_0 = analog.sig_source_f(samp_rate, analog.GR_SIN_WAVE, fportadora + fmoduladora, AMPLITUD, 0)
self.analog_sig_source_x_0_2 = analog.sig_source_f(samp_rate, analog.GR_SIN_WAVE, fportadora, AMPLITUD, 0)
self.analog_sig_source_x_0_0_0_0 = analog.sig_source_f(samp_rate, analog.GR_SAW_WAVE, SR, 1, 0)
self.analog_sig_source_x_0_0 = analog.sig_source_f(samp_rate, analog.GR_TRI_WAVE, UIF, AMPLITUD, -AMPLITUD/2)
self.analog_sig_source_x_0 = analog.sig_source_f(samp_rate, analog.GR_SIN_WAVE, UIF, AMPLITUD, 0)
##################################################
# Connections
##################################################
self.connect((self.analog_sig_source_x_0, 0), (self.blks2_selector_0_1, 0))
self.connect((self.analog_sig_source_x_0_0, 0), (self.blocks_multiply_const_vxx_0, 0))
self.connect((self.analog_sig_source_x_0_0_0_0, 0), (self.blocks_threshold_ff_0, 0))
self.connect((self.analog_sig_source_x_0_2, 0), (self.blocks_add_xx_0, 0))
self.connect((self.analog_sig_source_x_0_2_0, 0), (self.blocks_multiply_const_vxx_0_0, 0))
self.connect((self.analog_sig_source_x_0_2_1, 0), (self.blocks_multiply_const_vxx_0_1, 0))
self.connect((self.blks2_selector_0_1, 0), (self.blks2_selector_0_1_0, 0))
self.connect((self.blks2_selector_0_1, 0), (self.filtro_antialiasing, 0))
self.connect((self.blks2_selector_0_1, 0), (self.qtgui_freq_sink_x_0, 0))
self.connect((self.blks2_selector_0_1, 0), (self.qtgui_time_sink_x_0, 0))
self.connect((self.blks2_selector_0_1_0, 0), (self.blocks_throttle_0_0, 0))
self.connect((self.blks2_selector_0_1_0_0, 0), (self.blks2_selector_0_1_0_0_0, 0))
self.connect((self.blks2_selector_0_1_0_0, 0), (self.blocks_throttle_0_0_0, 0))
self.connect((self.blks2_selector_0_1_0_0_0, 0), (self.blks2_selector_0_1_0_0_0_0, 0))
self.connect((self.blks2_selector_0_1_0_0_0, 0), (self.low_pass_filter_0, 0))
self.connect((self.blks2_selector_0_1_0_0_0, 0), (self.qtgui_freq_sink_x_0, 3))
self.connect((self.blks2_selector_0_1_0_0_0, 0), (self.qtgui_time_sink_x_0, 3))
self.connect((self.blks2_selector_0_1_0_0_0_0, 0), (self.qtgui_freq_sink_x_0, 4))
self.connect((self.blks2_selector_0_1_0_0_0_0, 0), (self.qtgui_time_sink_x_0, 4))
self.connect((self.blocks_add_const_vxx_0, 0), (self.blocks_float_to_char_0_2, 0))
self.connect((self.blocks_add_xx_0, 0), (self.blks2_selector_0_1, 3))
self.connect((self.blocks_float_to_char_0_2, 0), (self.blocks_sample_and_hold_xx_0, 1))
self.connect((self.blocks_multiply_const_vxx_0, 0), (self.blks2_selector_0_1, 1))
self.connect((self.blocks_multiply_const_vxx_0_0, 0), (self.blocks_add_xx_0, 1))
self.connect((self.blocks_multiply_const_vxx_0_1, 0), (self.blocks_add_xx_0, 2))
self.connect((self.blocks_multiply_const_vxx_0_1_0, 0), (self.blocks_add_const_vxx_0, 0))
self.connect((self.blocks_multiply_const_vxx_0_2, 0), (self.blks2_selector_0_1, 2))
self.connect((self.blocks_multiply_xx_0, 0), (self.blks2_selector_0_1_0_0_0, 1))
self.connect((self.blocks_sample_and_hold_xx_0, 0), (self.blks2_selector_0_1_0_0, 1))
self.connect((self.blocks_sample_and_hold_xx_0, 0), (self.blocks_multiply_xx_0, 0))
self.connect((self.blocks_threshold_ff_0, 0), (self.blocks_multiply_const_vxx_0_1_0, 0))
self.connect((self.blocks_threshold_ff_0, 0), (self.blocks_multiply_xx_0, 1))
self.connect((self.blocks_throttle_0_0, 0), (self.qtgui_freq_sink_x_0, 1))
self.connect((self.blocks_throttle_0_0, 0), (self.qtgui_time_sink_x_0, 1))
self.connect((self.blocks_throttle_0_0_0, 0), (self.qtgui_freq_sink_x_0, 2))
self.connect((self.blocks_throttle_0_0_0, 0), (self.qtgui_time_sink_x_0, 2))
self.connect((self.filtro_antialiasing, 0), (self.blks2_selector_0_1_0, 1))
self.connect((self.filtro_antialiasing, 0), (self.blks2_selector_0_1_0_0, 0))
self.connect((self.filtro_antialiasing, 0), (self.blocks_sample_and_hold_xx_0, 0))
self.connect((self.low_pass_filter_0, 0), (self.blks2_selector_0_1_0_0_0_0, 1))
self.connect((self.sen32, 0), (self.blocks_multiply_const_vxx_0_2, 0))
def __init__(self, fft_length, cp_length, snr, kstime, logging):
''' Maximum Likelihood OFDM synchronizer:
J. van de Beek, M. Sandell, and P. O. Borjesson, "ML Estimation
of Time and Frequency Offset in OFDM Systems," IEEE Trans.
Signal Processing, vol. 45, no. 7, pp. 1800-1805, 1997.
'''
gr.hier_block2.__init__(self, "ofdm_sync_ml",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature2(2, 2, gr.sizeof_float, gr.sizeof_char)) # Output signature
self.input = blocks.add_const_cc(0)
SNR = 10.0**(snr / 10.0)
rho = SNR / (SNR + 1.0)
symbol_length = fft_length + cp_length
# ML Sync
# Energy Detection from ML Sync
self.connect(self, self.input)
# Create a delay line
self.delay = blocks.delay(gr.sizeof_gr_complex, fft_length)
self.connect(self.input, self.delay)
# magnitude squared blocks
self.magsqrd1 = blocks.complex_to_mag_squared()
self.magsqrd2 = blocks.complex_to_mag_squared()
self.adder = blocks.add_ff()
moving_sum_taps = [rho / 2 for i in range(cp_length)]
self.moving_sum_filter = filter.fir_filter_fff(1,moving_sum_taps)
self.connect(self.input,self.magsqrd1)
self.connect(self.delay,self.magsqrd2)
self.connect(self.magsqrd1,(self.adder,0))
self.connect(self.magsqrd2,(self.adder,1))
self.connect(self.adder,self.moving_sum_filter)
# Correlation from ML Sync
self.conjg = blocks.conjugate_cc();
self.mixer = blocks.multiply_cc();
movingsum2_taps = [1.0 for i in range(cp_length)]
self.movingsum2 = filter.fir_filter_ccf(1,movingsum2_taps)
# Correlator data handler
self.c2mag = blocks.complex_to_mag()
self.angle = blocks.complex_to_arg()
self.connect(self.input,(self.mixer,1))
self.connect(self.delay,self.conjg,(self.mixer,0))
self.connect(self.mixer,self.movingsum2,self.c2mag)
self.connect(self.movingsum2,self.angle)
# ML Sync output arg, need to find maximum point of this
self.diff = blocks.sub_ff()
self.connect(self.c2mag,(self.diff,0))
self.connect(self.moving_sum_filter,(self.diff,1))
#ML measurements input to sampler block and detect
self.f2c = blocks.float_to_complex()
self.pk_detect = blocks.peak_detector_fb(0.2, 0.25, 30, 0.0005)
self.sample_and_hold = blocks.sample_and_hold_ff()
# use the sync loop values to set the sampler and the NCO
# self.diff = theta
# self.angle = epsilon
self.connect(self.diff, self.pk_detect)
# The DPLL corrects for timing differences between CP correlations
use_dpll = 0
if use_dpll:
self.dpll = gr.dpll_bb(float(symbol_length),0.01)
self.connect(self.pk_detect, self.dpll)
self.connect(self.dpll, (self.sample_and_hold,1))
else:
self.connect(self.pk_detect, (self.sample_and_hold,1))
self.connect(self.angle, (self.sample_and_hold,0))
################################
# correlate against known symbol
# This gives us the same timing signal as the PN sync block only on the preamble
# we don't use the signal generated from the CP correlation because we don't want
# to readjust the timing in the middle of the packet or we ruin the equalizer settings.
kstime = [k.conjugate() for k in kstime]
kstime.reverse()
self.kscorr = filter.fir_filter_ccc(1, kstime)
self.corrmag = blocks.complex_to_mag_squared()
self.div = blocks.divide_ff()
# The output signature of the correlation has a few spikes because the rest of the
# system uses the repeated preamble symbol. It needs to work that generically if
# anyone wants to use this against a WiMAX-like signal since it, too, repeats.
# The output theta of the correlator above is multiplied with this correlation to
# identify the proper peak and remove other products in this cross-correlation
self.threshold_factor = 0.1
self.slice = blocks.threshold_ff(self.threshold_factor, self.threshold_factor, 0)
self.f2b = blocks.float_to_char()
self.b2f = blocks.char_to_float()
self.mul = blocks.multiply_ff()
# Normalize the power of the corr output by the energy. This is not really needed
# and could be removed for performance, but it makes for a cleaner signal.
# if this is removed, the threshold value needs adjustment.
self.connect(self.input, self.kscorr, self.corrmag, (self.div,0))
self.connect(self.moving_sum_filter, (self.div,1))
self.connect(self.div, (self.mul,0))
self.connect(self.pk_detect, self.b2f, (self.mul,1))
self.connect(self.mul, self.slice)
# Set output signals
# Output 0: fine frequency correction value
# Output 1: timing signal
self.connect(self.sample_and_hold, (self,0))
self.connect(self.slice, self.f2b, (self,1))
if logging:
self.connect(self.moving_sum_filter, blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-energy_f.dat"))
self.connect(self.diff, blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-theta_f.dat"))
self.connect(self.angle, blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-epsilon_f.dat"))
self.connect(self.corrmag, blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-corrmag_f.dat"))
self.connect(self.kscorr, blocks.file_sink(gr.sizeof_gr_complex, "ofdm_sync_ml-kscorr_c.dat"))
self.connect(self.div, blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-div_f.dat"))
self.connect(self.mul, blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-mul_f.dat"))
self.connect(self.slice, blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-slice_f.dat"))
self.connect(self.pk_detect, blocks.file_sink(gr.sizeof_char, "ofdm_sync_ml-peaks_b.dat"))
if use_dpll:
self.connect(self.dpll, blocks.file_sink(gr.sizeof_char, "ofdm_sync_ml-dpll_b.dat"))
self.connect(self.sample_and_hold, blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-sample_and_hold_f.dat"))
self.connect(self.input, blocks.file_sink(gr.sizeof_gr_complex, "ofdm_sync_ml-input_c.dat"))
def __init__(self, fft_length, cp_length, snr, kstime, logging):
''' Maximum Likelihood OFDM synchronizer:
J. van de Beek, M. Sandell, and P. O. Borjesson, "ML Estimation
of Time and Frequency Offset in OFDM Systems," IEEE Trans.
Signal Processing, vol. 45, no. 7, pp. 1800-1805, 1997.
'''
gr.hier_block2.__init__(
self,
"ofdm_sync_ml",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature2(2, 2, gr.sizeof_float,
gr.sizeof_char)) # Output signature
self.input = blocks.add_const_cc(0)
SNR = 10.0**(snr / 10.0)
rho = SNR / (SNR + 1.0)
symbol_length = fft_length + cp_length
# ML Sync
# Energy Detection from ML Sync
self.connect(self, self.input)
# Create a delay line
self.delay = blocks.delay(gr.sizeof_gr_complex, fft_length)
self.connect(self.input, self.delay)
# magnitude squared blocks
self.magsqrd1 = blocks.complex_to_mag_squared()
self.magsqrd2 = blocks.complex_to_mag_squared()
self.adder = blocks.add_ff()
moving_sum_taps = [rho / 2 for i in range(cp_length)]
self.moving_sum_filter = filter.fir_filter_fff(1, moving_sum_taps)
self.connect(self.input, self.magsqrd1)
self.connect(self.delay, self.magsqrd2)
self.connect(self.magsqrd1, (self.adder, 0))
self.connect(self.magsqrd2, (self.adder, 1))
self.connect(self.adder, self.moving_sum_filter)
# Correlation from ML Sync
self.conjg = blocks.conjugate_cc()
self.mixer = blocks.multiply_cc()
movingsum2_taps = [1.0 for i in range(cp_length)]
self.movingsum2 = filter.fir_filter_ccf(1, movingsum2_taps)
# Correlator data handler
self.c2mag = blocks.complex_to_mag()
self.angle = blocks.complex_to_arg()
self.connect(self.input, (self.mixer, 1))
self.connect(self.delay, self.conjg, (self.mixer, 0))
self.connect(self.mixer, self.movingsum2, self.c2mag)
self.connect(self.movingsum2, self.angle)
# ML Sync output arg, need to find maximum point of this
self.diff = blocks.sub_ff()
self.connect(self.c2mag, (self.diff, 0))
self.connect(self.moving_sum_filter, (self.diff, 1))
#ML measurements input to sampler block and detect
self.f2c = blocks.float_to_complex()
self.pk_detect = blocks.peak_detector_fb(0.2, 0.25, 30, 0.0005)
self.sample_and_hold = blocks.sample_and_hold_ff()
# use the sync loop values to set the sampler and the NCO
# self.diff = theta
# self.angle = epsilon
self.connect(self.diff, self.pk_detect)
# The DPLL corrects for timing differences between CP correlations
use_dpll = 0
if use_dpll:
self.dpll = gr.dpll_bb(float(symbol_length), 0.01)
self.connect(self.pk_detect, self.dpll)
self.connect(self.dpll, (self.sample_and_hold, 1))
else:
self.connect(self.pk_detect, (self.sample_and_hold, 1))
self.connect(self.angle, (self.sample_and_hold, 0))
################################
# correlate against known symbol
# This gives us the same timing signal as the PN sync block only on the preamble
# we don't use the signal generated from the CP correlation because we don't want
# to readjust the timing in the middle of the packet or we ruin the equalizer settings.
kstime = [k.conjugate() for k in kstime]
kstime.reverse()
self.kscorr = filter.fir_filter_ccc(1, kstime)
self.corrmag = blocks.complex_to_mag_squared()
self.div = blocks.divide_ff()
# The output signature of the correlation has a few spikes because the rest of the
# system uses the repeated preamble symbol. It needs to work that generically if
# anyone wants to use this against a WiMAX-like signal since it, too, repeats.
# The output theta of the correlator above is multiplied with this correlation to
# identify the proper peak and remove other products in this cross-correlation
self.threshold_factor = 0.1
self.slice = blocks.threshold_ff(self.threshold_factor,
self.threshold_factor, 0)
self.f2b = blocks.float_to_char()
self.b2f = blocks.char_to_float()
self.mul = blocks.multiply_ff()
# Normalize the power of the corr output by the energy. This is not really needed
# and could be removed for performance, but it makes for a cleaner signal.
# if this is removed, the threshold value needs adjustment.
self.connect(self.input, self.kscorr, self.corrmag, (self.div, 0))
self.connect(self.moving_sum_filter, (self.div, 1))
self.connect(self.div, (self.mul, 0))
self.connect(self.pk_detect, self.b2f, (self.mul, 1))
self.connect(self.mul, self.slice)
# Set output signals
# Output 0: fine frequency correction value
# Output 1: timing signal
self.connect(self.sample_and_hold, (self, 0))
self.connect(self.slice, self.f2b, (self, 1))
if logging:
self.connect(
self.moving_sum_filter,
blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-energy_f.dat"))
self.connect(
self.diff,
blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-theta_f.dat"))
self.connect(
self.angle,
blocks.file_sink(gr.sizeof_float,
"ofdm_sync_ml-epsilon_f.dat"))
self.connect(
self.corrmag,
blocks.file_sink(gr.sizeof_float,
"ofdm_sync_ml-corrmag_f.dat"))
self.connect(
self.kscorr,
blocks.file_sink(gr.sizeof_gr_complex,
"ofdm_sync_ml-kscorr_c.dat"))
self.connect(
self.div,
blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-div_f.dat"))
self.connect(
self.mul,
blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-mul_f.dat"))
self.connect(
self.slice,
blocks.file_sink(gr.sizeof_float, "ofdm_sync_ml-slice_f.dat"))
self.connect(
self.pk_detect,
blocks.file_sink(gr.sizeof_char, "ofdm_sync_ml-peaks_b.dat"))
if use_dpll:
self.connect(
self.dpll,
blocks.file_sink(gr.sizeof_char,
"ofdm_sync_ml-dpll_b.dat"))
self.connect(
self.sample_and_hold,
blocks.file_sink(gr.sizeof_float,
"ofdm_sync_ml-sample_and_hold_f.dat"))
self.connect(
self.input,
blocks.file_sink(gr.sizeof_gr_complex,
"ofdm_sync_ml-input_c.dat"))
def __init__(self, fft_length, cp_length, kstime, overrate, logging=True):
"""
OFDM synchronization using PN Correlation:
T. M. Schmidl and D. C. Cox, "Robust Frequency and Timing
Synchonization for OFDM," IEEE Trans. Communications, vol. 45,
no. 12, 1997.
"""
gr.hier_block2.__init__(
self,
"ofdm_sync_pn",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature2(2, 2, gr.sizeof_float,
gr.sizeof_char)) # Output signature
self.input = blocks.add_const_cc(0)
# cross-correlate with the known symbol
kstime = [k.conjugate() for k in kstime]
kstime.reverse()
self.crosscorr_filter = filter.fir_filter_ccc(1, kstime)
# PN Sync
self.corrmag = blocks.complex_to_mag_squared()
self.delay = blocks.delay(gr.sizeof_gr_complex,
fft_length * overrate / 2)
# Correlation from ML Sync
self.conjg = blocks.conjugate_cc()
self.corr = blocks.multiply_cc()
#self.sub = blocks.add_const_ff(-1)
self.pk_detect = blocks.peak_detector_fb(0.40, 0.25,
fft_length * overrate,
0.00000000000)
self.connect(self, self.input)
self.connect(self.input, self.crosscorr_filter)
self.connect(self.crosscorr_filter, self.corrmag)
#self.inputmag = blocks.complex_to_mag_squared()
#self.normalize = blocks.divide_ff()
#self.inputmovingsum = filter.fir_filter_fff(1, [1.0] * (fft_length//2))
self.square = blocks.multiply_ff()
#self.connect(self.input,self.inputmag,self.inputmovingsum)
self.connect(self.corrmag, (self.square, 0))
self.connect(self.corrmag, (self.square, 1))
self.dsquare = blocks.multiply_ff()
self.connect(self.square, (self.dsquare, 0))
self.connect(self.square, (self.dsquare, 1))
self.connect(self.dsquare, self.pk_detect)
# Create a moving sum filter for the corr output
self.moving_sum_filter = filter.fir_filter_ccf(
1, [1.0] * (fft_length * overrate // 2))
# Get magnitude (peaks) and angle (phase/freq error)
self.angle = blocks.complex_to_arg()
self.sample_and_hold = blocks.sample_and_hold_ff()
# Calculate the frequency offset from the correlation of the preamble
self.connect(self.input, self.delay)
self.connect(self.input, (self.corr, 0))
self.connect(self.delay, self.conjg)
self.connect(self.conjg, (self.corr, 1))
self.connect(self.corr, self.moving_sum_filter)
self.connect(self.moving_sum_filter, self.angle)
self.connect(self.angle, (self.sample_and_hold, 0))
self.connect(self.pk_detect, (self.sample_and_hold, 1))
# Set output signals
# Output 0: fine frequency correction value
# Output 1: timing signal
self.connect(self.sample_and_hold, (self, 0))
self.connect(self.pk_detect, (self, 1))
if logging:
self.connect(
self.dsquare,
blocks.file_sink(gr.sizeof_float, "ofdm_sync_pn-dsquare.dat"))
self.connect(
self.corrmag,
blocks.file_sink(gr.sizeof_float, "ofdm_sync_pn-corrmag.dat"))
self.connect(
self.angle,
blocks.file_sink(gr.sizeof_float,
"ofdm_sync_pn-epsilon_f.dat"))
self.connect(
self.pk_detect,
blocks.file_sink(gr.sizeof_char, "ofdm_sync_pn-peaks_b.dat"))
self.connect(
self.sample_and_hold,
blocks.file_sink(gr.sizeof_float,
"ofdm_sync_pn-sample_and_hold_f.dat"))
self.connect(
self.input,
blocks.file_sink(gr.sizeof_gr_complex,
"ofdm_sync_pn-input_c.dat"))
def __init__(self):
gr.top_block.__init__(self, "Adxl345 Sound Effect Attempt 1")
Qt.QWidget.__init__(self)
self.setWindowTitle("Adxl345 Sound Effect Attempt 1")
qtgui.util.check_set_qss()
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", "adxl345_sound_effect_attempt_1")
try:
if StrictVersion(Qt.qVersion()) < StrictVersion("5.0.0"):
self.restoreGeometry(self.settings.value("geometry").toByteArray())
else:
self.restoreGeometry(self.settings.value("geometry"))
except:
pass
##################################################
# Variables
##################################################
self.variable_0 = variable_0 = 0
self.samp_rate = samp_rate = 32000
##################################################
# Blocks
##################################################
self.qtgui_time_sink_x_0_0 = qtgui.time_sink_f(
1028, #size
samp_rate, #samp_rate
"Audio", #name
2 #number of inputs
)
self.qtgui_time_sink_x_0_0.set_update_time(0.250)
self.qtgui_time_sink_x_0_0.set_y_axis(-2, 2)
self.qtgui_time_sink_x_0_0.set_y_label("Acceleration", "g")
self.qtgui_time_sink_x_0_0.enable_tags(True)
self.qtgui_time_sink_x_0_0.set_trigger_mode(qtgui.TRIG_MODE_FREE, qtgui.TRIG_SLOPE_POS, 0.0, 0, 0, "")
self.qtgui_time_sink_x_0_0.enable_autoscale(False)
self.qtgui_time_sink_x_0_0.enable_grid(False)
self.qtgui_time_sink_x_0_0.enable_axis_labels(True)
self.qtgui_time_sink_x_0_0.enable_control_panel(True)
self.qtgui_time_sink_x_0_0.enable_stem_plot(False)
labels = ['X Accel', 'Y Accel', 'Z Accel', '', '',
'', '', '', '', '']
widths = [1, 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]
styles = [1, 1, 1, 1, 1,
1, 1, 1, 1, 1]
markers = [-1, -1, -1, -1, -1,
-1, -1, -1, -1, -1]
for i in range(2):
if len(labels[i]) == 0:
self.qtgui_time_sink_x_0_0.set_line_label(i, "Data {0}".format(i))
else:
self.qtgui_time_sink_x_0_0.set_line_label(i, labels[i])
self.qtgui_time_sink_x_0_0.set_line_width(i, widths[i])
self.qtgui_time_sink_x_0_0.set_line_color(i, colors[i])
self.qtgui_time_sink_x_0_0.set_line_style(i, styles[i])
self.qtgui_time_sink_x_0_0.set_line_marker(i, markers[i])
self.qtgui_time_sink_x_0_0.set_line_alpha(i, alphas[i])
self._qtgui_time_sink_x_0_0_win = sip.wrapinstance(self.qtgui_time_sink_x_0_0.pyqwidget(), Qt.QWidget)
self.top_grid_layout.addWidget(self._qtgui_time_sink_x_0_0_win)
self.iio_attr_source_0_0 = iio.attr_source("local:", "adxl345", "accel_y", "raw", 10, 32, 1, 0, False, int("0x123",0), False)
self.blocks_vco_f_0_0 = blocks.vco_f(samp_rate, 50, 1)
self.blocks_vco_f_0 = blocks.vco_f(samp_rate, 50, 1)
self.blocks_sample_and_hold_xx_0 = blocks.sample_and_hold_ff()
self.audio_sink_0 = audio.sink(samp_rate, '', True)
self.analog_sig_source_x_1 = analog.sig_source_b(100, analog.GR_SQR_WAVE, 10, 1, 0, 0)
##################################################
# Connections
##################################################
self.connect((self.analog_sig_source_x_1, 0), (self.blocks_sample_and_hold_xx_0, 1))
self.connect((self.blocks_sample_and_hold_xx_0, 0), (self.blocks_vco_f_0, 0))
self.connect((self.blocks_sample_and_hold_xx_0, 0), (self.blocks_vco_f_0_0, 0))
self.connect((self.blocks_vco_f_0, 0), (self.audio_sink_0, 0))
self.connect((self.blocks_vco_f_0, 0), (self.qtgui_time_sink_x_0_0, 0))
self.connect((self.blocks_vco_f_0_0, 0), (self.audio_sink_0, 1))
self.connect((self.blocks_vco_f_0_0, 0), (self.qtgui_time_sink_x_0_0, 1))
self.connect((self.iio_attr_source_0_0, 0), (self.blocks_sample_and_hold_xx_0, 0))
