def test01 (self):
sps = 4
rolloff = 0.35
bw = 2*math.pi/100.0
ntaps = 45
# Create pulse shape filter
#rrc_taps = gr.firdes.root_raised_cosine(
# sps, sps, 1.0, rolloff, ntaps)
rrc_taps = taps
# The frequency offset to correct
foffset = 0.2 / (2.0*math.pi)
# Create a set of 1's and -1's, pulse shape and interpolate to sps
random.seed(0)
data = [2.0*random.randint(0, 2) - 1.0 for i in xrange(200)]
self.src = gr.vector_source_c(data, False)
self.rrc = gr.interp_fir_filter_ccf(sps, rrc_taps)
# Mix symbols with a complex sinusoid to spin them
self.nco = gr.sig_source_c(1, gr.GR_SIN_WAVE, foffset, 1)
self.mix = gr.multiply_cc()
# FLL will despin the symbols to an arbitrary phase
self.fll = digital_swig.fll_band_edge_cc(sps, rolloff, ntaps, bw)
# Create sinks for all outputs of the FLL
# we will only care about the freq and error outputs
self.vsnk_frq = gr.vector_sink_f()
self.nsnk_fll = gr.null_sink(gr.sizeof_gr_complex)
self.nsnk_phs = gr.null_sink(gr.sizeof_float)
self.nsnk_err = gr.null_sink(gr.sizeof_float)
# Connect the blocks
self.tb.connect(self.nco, (self.mix,1))
self.tb.connect(self.src, self.rrc, (self.mix,0))
self.tb.connect(self.mix, self.fll, self.nsnk_fll)
self.tb.connect((self.fll,1), self.vsnk_frq)
self.tb.connect((self.fll,2), self.nsnk_phs)
self.tb.connect((self.fll,3), self.nsnk_err)
self.tb.run()
N = 700
dst_data = self.vsnk_frq.data()[N:]
expected_result = len(dst_data)* [-0.20,]
self.assertFloatTuplesAlmostEqual (expected_result, dst_data, 4)
def __init__(self, constellation,
samples_per_symbol=_def_samples_per_symbol,
differential=_def_differential,
excess_bw=_def_excess_bw,
gray_coded=True,
freq_bw=_def_freq_bw,
timing_bw=_def_timing_bw,
phase_bw=_def_phase_bw,
verbose=_def_verbose,
log=_def_log):
"""
Hierarchical block for RRC-filtered differential generic demodulation.
The input is the complex modulated signal at baseband.
The output is a stream of bits packed 1 bit per byte (LSB)
@param constellation: determines the modulation type
@type constellation: gnuradio.digital.gr_constellation
@param samples_per_symbol: samples per symbol >= 2
@type samples_per_symbol: float
@param excess_bw: Root-raised cosine filter excess bandwidth
@type excess_bw: float
@param gray_coded: turn gray coding on/off
@type gray_coded: bool
@param freq_bw: loop filter lock-in bandwidth
@type freq_bw: float
@param timing_bw: timing recovery loop lock-in bandwidth
@type timing_bw: float
@param phase_bw: phase recovery loop bandwidth
@type phase_bw: float
@param verbose: Print information about modulator?
@type verbose: bool
@param debug: Print modualtion data to files?
@type debug: bool
"""
gr.hier_block2.__init__(self, "generic_demod",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1, 1, gr.sizeof_char)) # Output signature
self._constellation = constellation.base()
self._samples_per_symbol = samples_per_symbol
self._excess_bw = excess_bw
self._phase_bw = phase_bw
self._freq_bw = freq_bw
self._timing_bw = timing_bw
self._timing_max_dev= _def_timing_max_dev
self._differential = differential
if self._samples_per_symbol < 2:
raise TypeError, ("sbp must be >= 2, is %d" % self._samples_per_symbol)
arity = pow(2,self.bits_per_symbol())
nfilts = 32
ntaps = 11 * int(self._samples_per_symbol*nfilts)
# Automatic gain control
self.agc = gr.agc2_cc(0.6e-1, 1e-3, 1, 1, 100)
# Frequency correction
fll_ntaps = 55
self.freq_recov = digital_swig.fll_band_edge_cc(self._samples_per_symbol, self._excess_bw,
fll_ntaps, self._freq_bw)
# symbol timing recovery with RRC data filter
taps = gr.firdes.root_raised_cosine(nfilts, nfilts*self._samples_per_symbol,
1.0, self._excess_bw, ntaps)
self.time_recov = gr.pfb_clock_sync_ccf(self._samples_per_symbol,
self._timing_bw, taps,
nfilts, nfilts//2, self._timing_max_dev)
fmin = -0.25
fmax = 0.25
self.receiver = digital_swig.constellation_receiver_cb(
self._constellation, self._phase_bw,
fmin, fmax)
# Do differential decoding based on phase change of symbols
if differential:
self.diffdec = gr.diff_decoder_bb(arity)
if gray_coded:
self.symbol_mapper = gr.map_bb(
mod_codes.invert_code(self._constellation.pre_diff_code()))
# unpack the k bit vector into a stream of bits
self.unpack = gr.unpack_k_bits_bb(self.bits_per_symbol())
if verbose:
self._print_verbage()
if log:
self._setup_logging()
# Connect and Initialize base class
blocks = [self, self.agc, self.freq_recov,
self.time_recov, self.receiver]
if differential:
blocks.append(self.diffdec)
if self._constellation.apply_pre_diff_code():
blocks.append(self.symbol_mapper)
blocks += [self.unpack, self]
self.connect(*blocks)
def __init__(self, constellation,
differential=_def_differential,
samples_per_symbol=_def_samples_per_symbol,
pre_diff_code=True,
excess_bw=_def_excess_bw,
freq_bw=_def_freq_bw,
timing_bw=_def_timing_bw,
phase_bw=_def_phase_bw,
verbose=_def_verbose,
log=_def_log):
gr.hier_block2.__init__(self, "generic_demod",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1, 1, gr.sizeof_char)) # Output signature
self._constellation = constellation
self._samples_per_symbol = samples_per_symbol
self._excess_bw = excess_bw
self._phase_bw = phase_bw
self._freq_bw = freq_bw
self._timing_bw = timing_bw
self._timing_max_dev= _def_timing_max_dev
self._differential = differential
if self._samples_per_symbol < 2:
raise TypeError, ("sbp must be >= 2, is %d" % self._samples_per_symbol)
# Only apply a predifferential coding if the constellation also supports it.
self.pre_diff_code = pre_diff_code and self._constellation.apply_pre_diff_code()
arity = pow(2,self.bits_per_symbol())
nfilts = 32
ntaps = 11 * int(self._samples_per_symbol*nfilts)
# Automatic gain control
self.agc = analog.agc2_cc(0.6e-1, 1e-3, 1, 1, 100)
# Frequency correction
fll_ntaps = 55
self.freq_recov = digital.fll_band_edge_cc(self._samples_per_symbol, self._excess_bw,
fll_ntaps, self._freq_bw)
# symbol timing recovery with RRC data filter
taps = filter.firdes.root_raised_cosine(nfilts, nfilts*self._samples_per_symbol,
1.0, self._excess_bw, ntaps)
self.time_recov = digital.pfb_clock_sync_ccf(self._samples_per_symbol,
self._timing_bw, taps,
nfilts, nfilts//2, self._timing_max_dev)
fmin = -0.25
fmax = 0.25
self.receiver = digital.constellation_receiver_cb(
self._constellation.base(), self._phase_bw,
fmin, fmax)
# Do differential decoding based on phase change of symbols
if differential:
self.diffdec = digital.diff_decoder_bb(arity)
if self.pre_diff_code:
self.symbol_mapper = digital.map_bb(
mod_codes.invert_code(self._constellation.pre_diff_code()))
# unpack the k bit vector into a stream of bits
self.unpack = blocks.unpack_k_bits_bb(self.bits_per_symbol())
if verbose:
self._print_verbage()
if log:
self._setup_logging()
# Connect and Initialize base class
self._blocks = [self, self.agc, self.freq_recov,
self.time_recov, self.receiver]
if differential:
self._blocks.append(self.diffdec)
if self.pre_diff_code:
self._blocks.append(self.symbol_mapper)
self._blocks += [self.unpack, self]
self.connect(*self._blocks)
def __init__(self,
constellation,
samples_per_symbol=_def_samples_per_symbol,
differential=_def_differential,
excess_bw=_def_excess_bw,
gray_coded=True,
freq_bw=_def_freq_bw,
timing_bw=_def_timing_bw,
phase_bw=_def_phase_bw,
verbose=_def_verbose,
log=_def_log):
"""
Hierarchical block for RRC-filtered differential generic demodulation.
The input is the complex modulated signal at baseband.
The output is a stream of bits packed 1 bit per byte (LSB)
@param constellation: determines the modulation type
@type constellation: gnuradio.digital.gr_constellation
@param samples_per_symbol: samples per symbol >= 2
@type samples_per_symbol: float
@param excess_bw: Root-raised cosine filter excess bandwidth
@type excess_bw: float
@param gray_coded: turn gray coding on/off
@type gray_coded: bool
@param freq_bw: loop filter lock-in bandwidth
@type freq_bw: float
@param timing_bw: timing recovery loop lock-in bandwidth
@type timing_bw: float
@param phase_bw: phase recovery loop bandwidth
@type phase_bw: float
@param verbose: Print information about modulator?
@type verbose: bool
@param debug: Print modualtion data to files?
@type debug: bool
"""
gr.hier_block2.__init__(
self,
"generic_demod",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1, 1, gr.sizeof_char)) # Output signature
self._constellation = constellation.base()
self._samples_per_symbol = samples_per_symbol
self._excess_bw = excess_bw
self._phase_bw = phase_bw
self._freq_bw = freq_bw
self._timing_bw = timing_bw
self._timing_max_dev = _def_timing_max_dev
self._differential = differential
if self._samples_per_symbol < 2:
raise TypeError, ("sbp must be >= 2, is %d" %
self._samples_per_symbol)
arity = pow(2, self.bits_per_symbol())
nfilts = 32
ntaps = 11 * int(self._samples_per_symbol * nfilts)
# Automatic gain control
self.agc = gr.agc2_cc(0.6e-1, 1e-3, 1, 1, 100)
# Frequency correction
fll_ntaps = 55
self.freq_recov = digital.fll_band_edge_cc(self._samples_per_symbol,
self._excess_bw, fll_ntaps,
self._freq_bw)
# symbol timing recovery with RRC data filter
taps = gr.firdes.root_raised_cosine(nfilts,
nfilts * self._samples_per_symbol,
1.0, self._excess_bw, ntaps)
self.time_recov = digital.pfb_clock_sync_ccf(self._samples_per_symbol,
self._timing_bw, taps,
nfilts, nfilts // 2,
self._timing_max_dev)
fmin = -0.25
fmax = 0.25
self.receiver = digital.constellation_receiver_cb(
self._constellation, self._phase_bw, fmin, fmax)
# Do differential decoding based on phase change of symbols
if differential:
self.diffdec = digital.diff_decoder_bb(arity)
if gray_coded:
self.symbol_mapper = digital.map_bb(
mod_codes.invert_code(self._constellation.pre_diff_code()))
# unpack the k bit vector into a stream of bits
self.unpack = gr.unpack_k_bits_bb(self.bits_per_symbol())
if verbose:
self._print_verbage()
if log:
self._setup_logging()
# Connect and Initialize base class
blocks = [
self, self.agc, self.freq_recov, self.time_recov, self.receiver
]
if differential:
blocks.append(self.diffdec)
if self._constellation.apply_pre_diff_code():
blocks.append(self.symbol_mapper)
blocks += [self.unpack, self]
self.connect(*blocks)
def __init__(self,
constellation,
differential=_def_differential,
samples_per_symbol=_def_samples_per_symbol,
pre_diff_code=True,
excess_bw=_def_excess_bw,
freq_bw=_def_freq_bw,
timing_bw=_def_timing_bw,
phase_bw=_def_phase_bw,
verbose=_def_verbose,
log=_def_log):
gr.hier_block2.__init__(
self,
"generic_demod",
gr.io_signature(1, 1, gr.sizeof_gr_complex), # Input signature
gr.io_signature(1, 1, gr.sizeof_char)) # Output signature
self._constellation = constellation
self._samples_per_symbol = samples_per_symbol
self._excess_bw = excess_bw
self._phase_bw = phase_bw
self._freq_bw = freq_bw
self._timing_bw = timing_bw
self._timing_max_dev = _def_timing_max_dev
self._differential = differential
if self._samples_per_symbol < 2:
raise TypeError, ("sps must be >= 2, is %d" %
self._samples_per_symbol)
# Only apply a predifferential coding if the constellation also supports it.
self.pre_diff_code = pre_diff_code and self._constellation.apply_pre_diff_code(
)
arity = pow(2, self.bits_per_symbol())
nfilts = 32
ntaps = 11 * int(self._samples_per_symbol * nfilts)
# Automatic gain control
self.agc = analog.agc2_cc(0.6e-1, 1e-3, 1, 1)
# Frequency correction
fll_ntaps = 55
self.freq_recov = digital.fll_band_edge_cc(self._samples_per_symbol,
self._excess_bw, fll_ntaps,
self._freq_bw)
# symbol timing recovery with RRC data filter
taps = filter.firdes.root_raised_cosine(
nfilts, nfilts * self._samples_per_symbol, 1.0, self._excess_bw,
ntaps)
self.time_recov = digital.pfb_clock_sync_ccf(self._samples_per_symbol,
self._timing_bw, taps,
nfilts, nfilts // 2,
self._timing_max_dev)
fmin = -0.25
fmax = 0.25
self.receiver = digital.constellation_receiver_cb(
self._constellation.base(), self._phase_bw, fmin, fmax)
# Do differential decoding based on phase change of symbols
if differential:
self.diffdec = digital.diff_decoder_bb(arity)
if self.pre_diff_code:
self.symbol_mapper = digital.map_bb(
mod_codes.invert_code(self._constellation.pre_diff_code()))
# unpack the k bit vector into a stream of bits
self.unpack = blocks.unpack_k_bits_bb(self.bits_per_symbol())
if verbose:
self._print_verbage()
if log:
self._setup_logging()
# Connect and Initialize base class
self._blocks = [
self, self.agc, self.freq_recov, self.time_recov, self.receiver
]
if differential:
self._blocks.append(self.diffdec)
if self.pre_diff_code:
self._blocks.append(self.symbol_mapper)
self._blocks += [self.unpack, self]
self.connect(*self._blocks)
