diff options
Diffstat (limited to 'gnuradio-core')
| -rw-r--r-- | gnuradio-core/src/python/gnuradio/Makefile.am | 2 | ||||
| -rw-r--r-- | gnuradio-core/src/python/gnuradio/blks2impl/Makefile.am | 5 | ||||
| -rw-r--r-- | gnuradio-core/src/python/gnuradio/blks2impl/bpsk.py | 98 | ||||
| -rw-r--r-- | gnuradio-core/src/python/gnuradio/blks2impl/generic_mod_demod.py | 395 | ||||
| -rw-r--r-- | gnuradio-core/src/python/gnuradio/blks2impl/psk2.py | 121 | ||||
| -rw-r--r-- | gnuradio-core/src/python/gnuradio/blks2impl/qam.py | 226 | ||||
| -rw-r--r-- | gnuradio-core/src/python/gnuradio/blks2impl/qpsk.py | 79 | ||||
| -rw-r--r-- | gnuradio-core/src/python/gnuradio/utils/Makefile.am | 35 | ||||
| -rw-r--r-- | gnuradio-core/src/python/gnuradio/utils/__init__.py | 21 | ||||
| -rw-r--r-- | gnuradio-core/src/python/gnuradio/utils/alignment.py | 139 | ||||
| -rw-r--r-- | gnuradio-core/src/python/gnuradio/utils/gray_code.py | 66 | ||||
| -rw-r--r-- | gnuradio-core/src/python/gnuradio/utils/mod_codes.py | 33 | ||||
| -rw-r--r-- | gnuradio-core/src/python/gnuradio/utils/run_tests.in | 11 |
13 files changed, 1 insertions, 1230 deletions
diff --git a/gnuradio-core/src/python/gnuradio/Makefile.am b/gnuradio-core/src/python/gnuradio/Makefile.am index 1bec7dd19..eff35e95c 100644 --- a/gnuradio-core/src/python/gnuradio/Makefile.am +++ b/gnuradio-core/src/python/gnuradio/Makefile.am @@ -22,7 +22,7 @@ include $(top_srcdir)/Makefile.common if PYTHON -SUBDIRS = gr gru gruimpl blks2 blks2impl vocoder utils +SUBDIRS = gr gru gruimpl blks2 blks2impl vocoder grpython_PYTHON = \ __init__.py \ diff --git a/gnuradio-core/src/python/gnuradio/blks2impl/Makefile.am b/gnuradio-core/src/python/gnuradio/blks2impl/Makefile.am index 6a2e7d5f7..34e246b36 100644 --- a/gnuradio-core/src/python/gnuradio/blks2impl/Makefile.am +++ b/gnuradio-core/src/python/gnuradio/blks2impl/Makefile.am @@ -29,7 +29,6 @@ grblkspythondir = $(grpythondir)/blks2impl grblkspython_PYTHON = \ __init__.py \ am_demod.py \ - bpsk.py \ channel_model.py \ dbpsk.py \ dbpsk2.py \ @@ -39,7 +38,6 @@ grblkspython_PYTHON = \ filterbank.py \ fm_demod.py \ fm_emph.py \ - generic_mod_demod.py \ generic_usrp.py \ gmsk.py \ cpm.py \ @@ -58,9 +56,6 @@ grblkspython_PYTHON = \ pfb_interpolator.py \ pkt.py \ psk.py \ - psk2.py \ - qam.py \ - qpsk.py \ rational_resampler.py \ standard_squelch.py \ stream_to_vector_decimator.py \ diff --git a/gnuradio-core/src/python/gnuradio/blks2impl/bpsk.py b/gnuradio-core/src/python/gnuradio/blks2impl/bpsk.py deleted file mode 100644 index 16524de94..000000000 --- a/gnuradio-core/src/python/gnuradio/blks2impl/bpsk.py +++ /dev/null @@ -1,98 +0,0 @@ -# -# Copyright 2005,2006,2011 Free Software Foundation, Inc. -# -# This file is part of GNU Radio -# -# GNU Radio is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 3, or (at your option) -# any later version. -# -# GNU Radio is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with GNU Radio; see the file COPYING. If not, write to -# the Free Software Foundation, Inc., 51 Franklin Street, -# Boston, MA 02110-1301, USA. -# - -""" -BPSK modulation and demodulation. -""" - -from math import pi, log -from cmath import exp - -from gnuradio import gr, modulation_utils2 -from gnuradio.blks2impl.generic_mod_demod import generic_mod, generic_demod - -# Default number of points in constellation. -_def_constellation_points = 2 -# Whether differential coding is used. -_def_differential = True - -# ///////////////////////////////////////////////////////////////////////////// -# BPSK constellation -# ///////////////////////////////////////////////////////////////////////////// - -def bpsk_constellation(m=_def_constellation_points): - if m != _def_constellation_points: - raise ValueError("BPSK can only have 2 constellation points.") - return gr.constellation_bpsk() - -# ///////////////////////////////////////////////////////////////////////////// -# BPSK modulator -# ///////////////////////////////////////////////////////////////////////////// - -class bpsk_mod(generic_mod): - - def __init__(self, constellation_points=_def_constellation_points, - *args, **kwargs): - - """ - Hierarchical block for RRC-filtered BPSK modulation. - - The input is a byte stream (unsigned char) and the - output is the complex modulated signal at baseband. - - See generic_mod block for list of parameters. - """ - - constellation = gr.constellation_bpsk() - if constellation_points != 2: - raise ValueError('Number of constellation points must be 2 for BPSK.') - super(bpsk_mod, self).__init__(constellation, *args, **kwargs) - -# ///////////////////////////////////////////////////////////////////////////// -# BPSK demodulator -# -# ///////////////////////////////////////////////////////////////////////////// - -class bpsk_demod(generic_demod): - - def __init__(self, constellation_points=_def_constellation_points, - *args, **kwargs): - - """ - Hierarchical block for RRC-filtered BPSK modulation. - - The input is a byte stream (unsigned char) and the - output is the complex modulated signal at baseband. - - See generic_demod block for list of parameters. - """ - - constellation = gr.constellation_bpsk() - if constellation_points != 2: - raise ValueError('Number of constellation points must be 2 for BPSK.') - super(bpsk_demod, self).__init__(constellation, *args, **kwargs) - -# -# Add these to the mod/demod registry -# -modulation_utils2.add_type_1_mod('bpsk', bpsk_mod) -modulation_utils2.add_type_1_demod('bpsk', bpsk_demod) -modulation_utils2.add_type_1_constellation('bpsk', bpsk_constellation) diff --git a/gnuradio-core/src/python/gnuradio/blks2impl/generic_mod_demod.py b/gnuradio-core/src/python/gnuradio/blks2impl/generic_mod_demod.py deleted file mode 100644 index 44779754b..000000000 --- a/gnuradio-core/src/python/gnuradio/blks2impl/generic_mod_demod.py +++ /dev/null @@ -1,395 +0,0 @@ -# -# Copyright 2005,2006,2007,2009,2011 Free Software Foundation, Inc. -# -# This file is part of GNU Radio -# -# GNU Radio is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 3, or (at your option) -# any later version. -# -# GNU Radio is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with GNU Radio; see the file COPYING. If not, write to -# the Free Software Foundation, Inc., 51 Franklin Street, -# Boston, MA 02110-1301, USA. -# - -# See gnuradio-examples/python/digital for examples - -""" -Generic modulation and demodulation. -""" - -from gnuradio import gr -from gnuradio.modulation_utils2 import extract_kwargs_from_options_for_class -from gnuradio.utils import mod_codes - -# default values (used in __init__ and add_options) -_def_samples_per_symbol = 2 -_def_excess_bw = 0.35 -_def_verbose = False -_def_log = False - -# Frequency correction -_def_freq_alpha = 0.010 -# Symbol timing recovery -_def_timing_alpha = 0.100 -_def_timing_beta = 0.010 -_def_timing_max_dev = 1.5 -# Fine frequency / Phase correction -_def_phase_alpha = 0.1 -# Number of points in constellation -_def_constellation_points = 16 -# Whether differential coding is used. -_def_differential = True - -def add_common_options(parser): - """ - Sets options common to both modulator and demodulator. - """ - parser.add_option("-p", "--constellation-points", type="int", default=_def_constellation_points, - help="set the number of constellation points (must be a power of 2 (power of 4 for QAM) [default=%default]") - parser.add_option("", "--differential", action="store_true", dest="differential", default=True, - help="use differential encoding [default=%default]") - parser.add_option("", "--not-differential", action="store_false", dest="differential", - help="do not use differential encoding [default=%default]") - parser.add_option("", "--mod-code", type="choice", choices=mod_codes.codes, - default=mod_codes.NO_CODE, - help="Select modulation code from: %s [default=%%default]" - % (', '.join(mod_codes.codes),)) - parser.add_option("", "--excess-bw", type="float", default=_def_excess_bw, - help="set RRC excess bandwith factor [default=%default]") - - -# ///////////////////////////////////////////////////////////////////////////// -# Generic modulator -# ///////////////////////////////////////////////////////////////////////////// - -class generic_mod(gr.hier_block2): - - def __init__(self, constellation, - differential=_def_differential, - samples_per_symbol=_def_samples_per_symbol, - excess_bw=_def_excess_bw, - verbose=_def_verbose, - log=_def_log): - """ - Hierarchical block for RRC-filtered differential generic modulation. - - The input is a byte stream (unsigned char) and the - output is the complex modulated signal at baseband. - - @param constellation: determines the modulation type - @type constellation: gnuradio.gr.gr_constellation - @param samples_per_symbol: samples per baud >= 2 - @type samples_per_symbol: integer - @param excess_bw: Root-raised cosine filter excess bandwidth - @type excess_bw: float - @param verbose: Print information about modulator? - @type verbose: bool - @param log: Log modulation data to files? - @type log: bool - """ - - gr.hier_block2.__init__(self, "generic_mod", - gr.io_signature(1, 1, gr.sizeof_char), # Input signature - gr.io_signature(1, 1, gr.sizeof_gr_complex)) # Output signature - - self._constellation = constellation.base() - self._samples_per_symbol = samples_per_symbol - self._excess_bw = excess_bw - self._differential = differential - - if not isinstance(self._samples_per_symbol, int) or self._samples_per_symbol < 2: - raise TypeError, ("sbp must be an integer >= 2, is %d" % self._samples_per_symbol) - - ntaps = 11 * self._samples_per_symbol - - arity = pow(2,self.bits_per_symbol()) - - # turn bytes into k-bit vectors - self.bytes2chunks = \ - gr.packed_to_unpacked_bb(self.bits_per_symbol(), gr.GR_MSB_FIRST) - - if self._constellation.apply_pre_diff_code(): - self.symbol_mapper = gr.map_bb(self._constellation.pre_diff_code()) - - if differential: - self.diffenc = gr.diff_encoder_bb(arity) - - self.chunks2symbols = gr.chunks_to_symbols_bc(self._constellation.points()) - - # pulse shaping filter - self.rrc_taps = gr.firdes.root_raised_cosine( - self._samples_per_symbol, # gain (samples_per_symbol since we're - # interpolating by samples_per_symbol) - self._samples_per_symbol, # sampling rate - 1.0, # symbol rate - self._excess_bw, # excess bandwidth (roll-off factor) - ntaps) - self.rrc_filter = gr.interp_fir_filter_ccf(self._samples_per_symbol, - self.rrc_taps) - - # Connect - blocks = [self, self.bytes2chunks] - if self._constellation.apply_pre_diff_code(): - blocks.append(self.symbol_mapper) - if differential: - blocks.append(self.diffenc) - blocks += [self.chunks2symbols, self.rrc_filter, self] - self.connect(*blocks) - - if verbose: - self._print_verbage() - - if log: - self._setup_logging() - - - def samples_per_symbol(self): - return self._samples_per_symbol - - def bits_per_symbol(self): # static method that's also callable on an instance - return self._constellation.bits_per_symbol() - - def add_options(parser): - """ - Adds generic modulation options to the standard parser - """ - add_common_options(parser) - add_options=staticmethod(add_options) - - def extract_kwargs_from_options(cls, options): - """ - Given command line options, create dictionary suitable for passing to __init__ - """ - return extract_kwargs_from_options_for_class(cls, options) - extract_kwargs_from_options=classmethod(extract_kwargs_from_options) - - - def _print_verbage(self): - print "\nModulator:" - print "bits per symbol: %d" % self.bits_per_symbol() - print "RRC roll-off factor: %.2f" % self._excess_bw - - def _setup_logging(self): - print "Modulation logging turned on." - self.connect(self.bytes2chunks, - gr.file_sink(gr.sizeof_char, "tx_bytes2chunks.dat")) - if self._constellation.apply_pre_diff_code(): - self.connect(self.symbol_mapper, - gr.file_sink(gr.sizeof_char, "tx_symbol_mapper.dat")) - if self._differential: - self.connect(self.diffenc, - gr.file_sink(gr.sizeof_char, "tx_diffenc.dat")) - self.connect(self.chunks2symbols, - gr.file_sink(gr.sizeof_gr_complex, "tx_chunks2symbols.dat")) - self.connect(self.rrc_filter, - gr.file_sink(gr.sizeof_gr_complex, "tx_rrc_filter.dat")) - - -# ///////////////////////////////////////////////////////////////////////////// -# Generic demodulator -# -# Differentially coherent detection of differentially encoded generically -# modulated signal. -# ///////////////////////////////////////////////////////////////////////////// - -class generic_demod(gr.hier_block2): - - def __init__(self, constellation, - samples_per_symbol=_def_samples_per_symbol, - differential=_def_differential, - excess_bw=_def_excess_bw, - freq_alpha=_def_freq_alpha, - timing_alpha=_def_timing_alpha, - timing_max_dev=_def_timing_max_dev, - phase_alpha=_def_phase_alpha, - 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.gr.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 freq_alpha: loop filter gain for frequency recovery - @type freq_alpha: float - @param timing_alpha: loop alpha gain for timing recovery - @type timing_alpha: float - @param timing_max_dev: timing loop maximum rate deviations - @type timing_max_dev: float - @param phase_alpha: loop filter gain in phase loop - @type phase_alphas: 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_alpha = phase_alpha - self._freq_alpha = freq_alpha - self._freq_beta = 0.10*self._freq_alpha - self._timing_alpha = timing_alpha - self._timing_beta = _def_timing_beta - self._timing_max_dev=timing_max_dev - self._differential = differential - - if not isinstance(self._samples_per_symbol, int) or self._samples_per_symbol < 2: - raise TypeError, ("sbp must be an integer >= 2, is %d" % self._samples_per_symbol) - - arity = pow(2,self.bits_per_symbol()) - - # Automatic gain control - self.agc = gr.agc2_cc(0.6e-1, 1e-3, 1, 1, 100) - - # Frequency correction - self.freq_recov = gr.fll_band_edge_cc(self._samples_per_symbol, self._excess_bw, - 11*int(self._samples_per_symbol), - self._freq_alpha, self._freq_beta) - - # symbol timing recovery with RRC data filter - nfilts = 32 - ntaps = 11 * int(self._samples_per_symbol*nfilts) - taps = gr.firdes.root_raised_cosine(nfilts, nfilts, - 1.0/float(self._samples_per_symbol), - self._excess_bw, ntaps) - self.time_recov = gr.pfb_clock_sync_ccf(self._samples_per_symbol, - self._timing_alpha, - taps, nfilts, nfilts/2, self._timing_max_dev) - self.time_recov.set_beta(self._timing_beta) - - #self._phase_beta = 0.25 * self._phase_alpha * self._phase_alpha - self._phase_beta = 0.25 * self._phase_alpha * self._phase_alpha - fmin = -0.25 - fmax = 0.25 - - self.receiver = gr.constellation_receiver_cb( - self._constellation, - self._phase_alpha, self._phase_beta, - fmin, fmax) - - # Do differential decoding based on phase change of symbols - if differential: - self.diffdec = gr.diff_decoder_bb(arity) - - if self._constellation.apply_pre_diff_code(): - 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 samples_per_symbol(self): - return self._samples_per_symbol - - def bits_per_symbol(self): # staticmethod that's also callable on an instance - return self._constellation.bits_per_symbol() - - def _print_verbage(self): - print "\nDemodulator:" - print "bits per symbol: %d" % self.bits_per_symbol() - print "RRC roll-off factor: %.2f" % self._excess_bw - print "FLL gain: %.2e" % self._freq_alpha - print "Timing alpha gain: %.2e" % self._timing_alpha - print "Timing beta gain: %.2e" % self._timing_beta - print "Timing max dev: %.2f" % self._timing_max_dev - print "Phase track alpha: %.2e" % self._phase_alpha - print "Phase track beta: %.2e" % self._phase_beta - - def _setup_logging(self): - print "Modulation logging turned on." - self.connect(self.agc, - gr.file_sink(gr.sizeof_gr_complex, "rx_agc.dat")) - self.connect((self.freq_recov, 0), - gr.file_sink(gr.sizeof_gr_complex, "rx_freq_recov.dat")) - self.connect((self.freq_recov, 1), - gr.file_sink(gr.sizeof_float, "rx_freq_recov_freq.dat")) - self.connect((self.freq_recov, 2), - gr.file_sink(gr.sizeof_float, "rx_freq_recov_phase.dat")) - self.connect((self.freq_recov, 3), - gr.file_sink(gr.sizeof_gr_complex, "rx_freq_recov_error.dat")) - self.connect((self.time_recov, 0), - gr.file_sink(gr.sizeof_gr_complex, "rx_time_recov.dat")) - self.connect((self.time_recov, 1), - gr.file_sink(gr.sizeof_float, "rx_time_recov_error.dat")) - self.connect((self.time_recov, 2), - gr.file_sink(gr.sizeof_float, "rx_time_recov_rate.dat")) - self.connect((self.time_recov, 3), - gr.file_sink(gr.sizeof_float, "rx_time_recov_phase.dat")) - self.connect((self.receiver, 0), - gr.file_sink(gr.sizeof_char, "rx_receiver.dat")) - self.connect((self.receiver, 1), - gr.file_sink(gr.sizeof_float, "rx_receiver_error.dat")) - self.connect((self.receiver, 2), - gr.file_sink(gr.sizeof_float, "rx_receiver_phase.dat")) - self.connect((self.receiver, 3), - gr.file_sink(gr.sizeof_float, "rx_receiver_freq.dat")) - if self._differential: - self.connect(self.diffdec, - gr.file_sink(gr.sizeof_char, "rx_diffdec.dat")) - if self._constellation.apply_pre_diff_code(): - self.connect(self.symbol_mapper, - gr.file_sink(gr.sizeof_char, "rx_symbol_mapper.dat")) - self.connect(self.unpack, - gr.file_sink(gr.sizeof_char, "rx_unpack.dat")) - - def add_options(parser): - """ - Adds generic demodulation options to the standard parser - """ - # Add options shared with modulator. - add_common_options(parser) - # Add options specific to demodulator. - parser.add_option("", "--freq-alpha", type="float", default=_def_freq_alpha, - help="set frequency lock loop alpha gain value [default=%default]") - parser.add_option("", "--phase-alpha", type="float", default=_def_phase_alpha, - help="set phase tracking loop alpha value [default=%default]") - parser.add_option("", "--timing-alpha", type="float", default=_def_timing_alpha, - help="set timing symbol sync loop gain alpha value [default=%default]") - parser.add_option("", "--timing-beta", type="float", default=_def_timing_beta, - help="set timing symbol sync loop gain beta value [default=%default]") - parser.add_option("", "--timing-max-dev", type="float", default=_def_timing_max_dev, - help="set timing symbol sync loop maximum deviation [default=%default]") - add_options=staticmethod(add_options) - - def extract_kwargs_from_options(cls, options): - """ - Given command line options, create dictionary suitable for passing to __init__ - """ - return extract_kwargs_from_options_for_class(cls, options) - extract_kwargs_from_options=classmethod(extract_kwargs_from_options) - diff --git a/gnuradio-core/src/python/gnuradio/blks2impl/psk2.py b/gnuradio-core/src/python/gnuradio/blks2impl/psk2.py deleted file mode 100644 index aaa9659a4..000000000 --- a/gnuradio-core/src/python/gnuradio/blks2impl/psk2.py +++ /dev/null @@ -1,121 +0,0 @@ -# -# Copyright 2005,2006,2011 Free Software Foundation, Inc. -# -# This file is part of GNU Radio -# -# GNU Radio is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 3, or (at your option) -# any later version. -# -# GNU Radio is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with GNU Radio; see the file COPYING. If not, write to -# the Free Software Foundation, Inc., 51 Franklin Street, -# Boston, MA 02110-1301, USA. -# - -""" -PSK modulation and demodulation. -""" - -from math import pi, log -from cmath import exp - -from gnuradio import gr, modulation_utils2 -from gnuradio.blks2impl.generic_mod_demod import generic_mod, generic_demod -from gnuradio.utils import mod_codes, gray_code - -# Default number of points in constellation. -_def_constellation_points = 4 -# The default encoding (e.g. gray-code, set-partition) -_def_mod_code = mod_codes.GRAY_CODE - -def create_encodings(mod_code, arity): - post_diff_code = None - if mod_code not in mod_codes.codes: - raise ValueError('That modulation code does not exist.') - if mod_code == mod_codes.GRAY_CODE: - pre_diff_code = gray_code.gray_code(arity) - elif mod_code == mod_codes.SET_PARTITION_CODE: - pre_diff_code = set_partition_code.set_partition_code(arity) - elif mod_code == mod_codes.NO_CODE: - pre_diff_code = [] - else: - raise ValueError('That modulation code is not implemented for this constellation.') - return (pre_diff_code, post_diff_code) - -# ///////////////////////////////////////////////////////////////////////////// -# PSK constellation -# ///////////////////////////////////////////////////////////////////////////// - -def psk_constellation(m=_def_constellation_points, mod_code=_def_mod_code): - """ - Creates a PSK constellation object. - """ - k = log(m) / log(2.0) - if (k != int(k)): - raise StandardError('Number of constellation points must be a power of two.') - points = [exp(2*pi*(0+1j)*i/m) for i in range(0,m)] - pre_diff_code, post_diff_code = create_encodings(mod_code, m) - if post_diff_code is not None: - inverse_post_diff_code = mod_codes.invert_code(post_diff_code) - points = [points[x] for x in inverse_post_diff_code] - constellation = gr.constellation_psk(points, pre_diff_code, m) - return constellation - -# ///////////////////////////////////////////////////////////////////////////// -# PSK modulator -# ///////////////////////////////////////////////////////////////////////////// - -class psk_mod(generic_mod): - - def __init__(self, constellation_points=_def_constellation_points, - mod_code=_def_mod_code, - *args, **kwargs): - - """ - Hierarchical block for RRC-filtered PSK modulation. - - The input is a byte stream (unsigned char) and the - output is the complex modulated signal at baseband. - - See generic_mod block for list of parameters. - """ - - constellation = psk_constellation(constellation_points, mod_code) - super(psk_mod, self).__init__(constellation, *args, **kwargs) - -# ///////////////////////////////////////////////////////////////////////////// -# PSK demodulator -# -# ///////////////////////////////////////////////////////////////////////////// - -class psk_demod(generic_demod): - - def __init__(self, constellation_points=_def_constellation_points, - mod_code=_def_mod_code, - *args, **kwargs): - - """ - Hierarchical block for RRC-filtered PSK modulation. - - The input is a byte stream (unsigned char) and the - output is the complex modulated signal at baseband. - - See generic_demod block for list of parameters. - """ - - constellation = psk_constellation(constellation_points, mod_code) - super(psk_demod, self).__init__(constellation, *args, **kwargs) - -# -# Add these to the mod/demod registry -# -modulation_utils2.add_type_1_mod('psk', psk_mod) -modulation_utils2.add_type_1_demod('psk', psk_demod) -modulation_utils2.add_type_1_constellation('psk', psk_constellation) diff --git a/gnuradio-core/src/python/gnuradio/blks2impl/qam.py b/gnuradio-core/src/python/gnuradio/blks2impl/qam.py deleted file mode 100644 index 9c135b25a..000000000 --- a/gnuradio-core/src/python/gnuradio/blks2impl/qam.py +++ /dev/null @@ -1,226 +0,0 @@ -# -# Copyright 2005,2006,2011 Free Software Foundation, Inc. -# -# This file is part of GNU Radio -# -# GNU Radio is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 3, or (at your option) -# any later version. -# -# GNU Radio is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with GNU Radio; see the file COPYING. If not, write to -# the Free Software Foundation, Inc., 51 Franklin Street, -# Boston, MA 02110-1301, USA. -# - -""" -QAM modulation and demodulation. -""" - -from math import pi, sqrt, log - -from gnuradio import gr, modulation_utils2 -from gnuradio.blks2impl.generic_mod_demod import generic_mod, generic_demod -from gnuradio.utils.gray_code import gray_code -from gnuradio.utils import mod_codes - -# Default number of points in constellation. -_def_constellation_points = 16 -# Whether the quadrant bits are coded differentially. -_def_differential = True -# Whether gray coding is used. If differential is True then gray -# coding is used within but not between each quadrant. -_def_mod_code = mod_codes.NO_CODE - -def is_power_of_four(x): - v = log(x)/log(4) - return int(v) == v - -def get_bit(x, n): - """ Get the n'th bit of integer x (from little end).""" - return (x&(0x01 << n)) >> n - -def get_bits(x, n, k): - """ Get the k bits of integer x starting at bit n(from little end).""" - # Remove the n smallest bits - v = x >> n - # Remove all bits bigger than n+k-1 - return v % pow(2, k) - -def make_differential_constellation(m, gray_coded): - """ - Create a constellation with m possible symbols where m must be - a power of 4. - - Points are laid out in a square grid. - - Bits referring to the quadrant are differentilly encoded, - remaining bits are gray coded. - - """ - sqrtm = pow(m, 0.5) - if (not isinstance(m, int) or m < 4 or not is_power_of_four(m)): - raise ValueError("m must be a power of 4 integer.") - # Each symbol holds k bits. - k = int(log(m) / log(2.0)) - # First create a constellation for one quadrant containing m/4 points. - # The quadrant has 'side' points along each side of a quadrant. - side = int(sqrtm/2) - if gray_coded: - # Number rows and columns using gray codes. - gcs = gray_code(side) - # Get inverse gray codes. - i_gcs = dict([(v, key) for key, v in enumerate(gcs)]) - else: - i_gcs = dict([(i, i) for i in range(0, side)]) - # The distance between points is found. - step = 1/(side-0.5) - - gc_to_x = [(i_gcs[gc]+0.5)*step for gc in range(0, side)] - - # Takes the (x, y) location of the point with the quadrant along - # with the quadrant number. (x, y) are integers referring to which - # point within the quadrant it is. - # A complex number representing this location of this point is returned. - def get_c(gc_x, gc_y, quad): - if quad == 0: - return complex(gc_to_x[gc_x], gc_to_x[gc_y]) - if quad == 1: - return complex(-gc_to_x[gc_y], gc_to_x[gc_x]) - if quad == 2: - return complex(-gc_to_x[gc_x], -gc_to_x[gc_y]) - if quad == 3: - return complex(gc_to_x[gc_y], -gc_to_x[gc_x]) - raise StandardError("Impossible!") - - # First two bits determine quadrant. - # Next (k-2)/2 bits determine x position. - # Following (k-2)/2 bits determine y position. - # How x and y relate to real and imag depends on quadrant (see get_c function). - const_map = [] - for i in range(m): - y = get_bits(i, 0, (k-2)/2) - x = get_bits(i, (k-2)/2, (k-2)/2) - quad = get_bits(i, k-2, 2) - const_map.append(get_c(x, y, quad)) - - return const_map - -def make_not_differential_constellation(m, gray_coded): - side = int(pow(m, 0.5)) - if (not isinstance(m, int) or m < 4 or not is_power_of_four(m)): - raise ValueError("m must be a power of 4 integer.") - # Each symbol holds k bits. - k = int(log(m) / log(2.0)) - if gray_coded: - # Number rows and columns using gray codes. - gcs = gray_code(side) - # Get inverse gray codes. - i_gcs = mod_codes.invert_code(gcs) - else: - i_gcs = range(0, side) - # The distance between points is found. - step = 2.0/(side-1) - - gc_to_x = [-1 + i_gcs[gc]*step for gc in range(0, side)] - # First k/2 bits determine x position. - # Following k/2 bits determine y position. - const_map = [] - for i in range(m): - y = gc_to_x[get_bits(i, 0, k/2)] - x = gc_to_x[get_bits(i, k/2, k/2)] - const_map.append(complex(x,y)) - return const_map - -# ///////////////////////////////////////////////////////////////////////////// -# QAM constellation -# ///////////////////////////////////////////////////////////////////////////// - -def qam_constellation(constellation_points=_def_constellation_points, - differential=_def_differential, - mod_code=_def_mod_code): - """ - Creates a QAM constellation object. - """ - if mod_code == mod_codes.GRAY_CODE: - gray_coded = True - elif mod_code == mod_codes.NO_CODE: - gray_coded = False - else: - raise ValueError("Mod code is not implemented for QAM") - if differential: - points = make_differential_constellation(constellation_points, gray_coded) - else: - points = make_not_differential_constellation(constellation_points, gray_coded) - side = int(sqrt(constellation_points)) - width = 2.0/(side-1) - # No pre-diff code - # Should add one so that we can gray-code the quadrant bits too. - pre_diff_code = [] - constellation = gr.constellation_rect(points, pre_diff_code, 4, side, side, width, width) - return constellation - -# ///////////////////////////////////////////////////////////////////////////// -# QAM modulator -# ///////////////////////////////////////////////////////////////////////////// - -class qam_mod(generic_mod): - - def __init__(self, constellation_points=_def_constellation_points, - differential=_def_differential, - mod_code=_def_mod_code, - *args, **kwargs): - - """ - Hierarchical block for RRC-filtered QAM modulation. - - The input is a byte stream (unsigned char) and the - output is the complex modulated signal at baseband. - - See generic_mod block for list of parameters. - """ - - constellation = qam_constellation(constellation_points, differential, mod_code) - # We take care of the gray coding in the constellation generation so it doesn't - # need to be done in the block. - super(qam_mod, self).__init__(constellation, differential=differential, - *args, **kwargs) - -# ///////////////////////////////////////////////////////////////////////////// -# QAM demodulator -# -# ///////////////////////////////////////////////////////////////////////////// - -class qam_demod(generic_demod): - - def __init__(self, constellation_points=_def_constellation_points, - differential=_def_differential, - mod_code=_def_mod_code, - *args, **kwargs): - - """ - Hierarchical block for RRC-filtered QAM modulation. - - The input is a byte stream (unsigned char) and the - output is the complex modulated signal at baseband. - - See generic_demod block for list of parameters. - """ - constellation = qam_constellation(constellation_points, differential, mod_code) - # We take care of the gray coding in the constellation generation so it doesn't - # need to be done in the block. - super(qam_demod, self).__init__(constellation, differential=differential, - *args, **kwargs) - -# -# Add these to the mod/demod registry -# -modulation_utils2.add_type_1_mod('qam', qam_mod) -modulation_utils2.add_type_1_demod('qam', qam_demod) -modulation_utils2.add_type_1_constellation('qam', qam_constellation) diff --git a/gnuradio-core/src/python/gnuradio/blks2impl/qpsk.py b/gnuradio-core/src/python/gnuradio/blks2impl/qpsk.py deleted file mode 100644 index 4af8d0018..000000000 --- a/gnuradio-core/src/python/gnuradio/blks2impl/qpsk.py +++ /dev/null @@ -1,79 +0,0 @@ -# -# Copyright 2005,2006,2011 Free Software Foundation, Inc. -# -# This file is part of GNU Radio -# -# GNU Radio is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 3, or (at your option) -# any later version. -# -# GNU Radio is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with GNU Radio; see the file COPYING. If not, write to -# the Free Software Foundation, Inc., 51 Franklin Street, -# Boston, MA 02110-1301, USA. -# - -""" -QPSK modulation. - -Demodulation is not included since the generic_mod_demod -doesn't work for non-differential encodings. -""" - -from gnuradio import gr, modulation_utils2 -from gnuradio.blks2impl.generic_mod_demod import generic_mod - - -# Default number of points in constellation. -_def_constellation_points = 4 -# Whether differential coding is used. -_def_differential = False -_def_gray_coded = True - -# ///////////////////////////////////////////////////////////////////////////// -# QPSK constellation -# ///////////////////////////////////////////////////////////////////////////// - -def qpsk_constellation(m=_def_constellation_points): - if m != _def_constellation_points: - raise ValueError("QPSK can only have 4 constellation points.") - return gr.constellation_qpsk() - -# ///////////////////////////////////////////////////////////////////////////// -# QPSK modulator -# ///////////////////////////////////////////////////////////////////////////// - -class qpsk_mod(generic_mod): - - def __init__(self, constellation_points=_def_constellation_points, - differential=_def_differential, - gray_coded=_def_gray_coded, - *args, **kwargs): - - """ - Hierarchical block for RRC-filtered QPSK modulation. - - The input is a byte stream (unsigned char) and the - output is the complex modulated signal at baseband. - - See generic_mod block for list of parameters. - """ - - constellation = gr.constellation_qpsk() - if constellation_points != 4: - raise ValueError("QPSK can only have 4 constellation points.") - if differential or not gray_coded: - raise ValueError("This QPSK mod/demod works only for gray-coded, non-differential.") - super(qpsk_mod, self).__init__(constellation, differential, gray_coded, *args, **kwargs) - -# -# Add these to the mod/demod registry -# -modulation_utils2.add_type_1_mod('qpsk', qpsk_mod) -modulation_utils2.add_type_1_constellation('qpsk', qpsk_constellation) diff --git a/gnuradio-core/src/python/gnuradio/utils/Makefile.am b/gnuradio-core/src/python/gnuradio/utils/Makefile.am deleted file mode 100644 index c35951b44..000000000 --- a/gnuradio-core/src/python/gnuradio/utils/Makefile.am +++ /dev/null @@ -1,35 +0,0 @@ -# -# Copyright 2007,2009 Free Software Foundation, Inc. -# -# This file is part of GNU Radio -# -# GNU Radio is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 3, or (at your option) -# any later version. -# -# GNU Radio is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with GNU Radio; see the file COPYING. If not, write to -# the Free Software Foundation, Inc., 51 Franklin Street, -# Boston, MA 02110-1301, USA. -# - -include $(top_srcdir)/Makefile.common - -if PYTHON -utilspythondir = $(grpythondir)/utils - -TESTS = \ - run_tests - -nobase_utilspython_PYTHON = \ - __init__.py \ - gray_code.py \ - mod_codes.py \ - alignment.py -endif
\ No newline at end of file diff --git a/gnuradio-core/src/python/gnuradio/utils/__init__.py b/gnuradio-core/src/python/gnuradio/utils/__init__.py deleted file mode 100644 index b3e997f9f..000000000 --- a/gnuradio-core/src/python/gnuradio/utils/__init__.py +++ /dev/null @@ -1,21 +0,0 @@ -#!/usr/bin/env python -# -# Copyright 2011 Free Software Foundation, Inc. -# -# This file is part of GNU Radio -# -# GNU Radio is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 3, or (at your option) -# any later version. -# -# GNU Radio is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with GNU Radio; see the file COPYING. If not, write to -# the Free Software Foundation, Inc., 51 Franklin Street, -# Boston, MA 02110-1301, USA. -# diff --git a/gnuradio-core/src/python/gnuradio/utils/alignment.py b/gnuradio-core/src/python/gnuradio/utils/alignment.py deleted file mode 100644 index d32365866..000000000 --- a/gnuradio-core/src/python/gnuradio/utils/alignment.py +++ /dev/null @@ -1,139 +0,0 @@ -#!/usr/bin/env python -# -# Copyright 2011 Free Software Foundation, Inc. -# -# This file is part of GNU Radio -# -# GNU Radio is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 3, or (at your option) -# any later version. -# -# GNU Radio is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with GNU Radio; see the file COPYING. If not, write to -# the Free Software Foundation, Inc., 51 Franklin Street, -# Boston, MA 02110-1301, USA. -# -""" -This module contains functions for aligning sequences. - ->>> import random ->>> random.seed(1234) ->>> ran_seq = [random.randint(0,1) for i in range(0, 100)] ->>> offset_seq = [0] * 20 + ran_seq ->>> correct, overlap, offset = align_sequences(ran_seq, offset_seq) ->>> print(correct, overlap, offset) -(1.0, 100, -20) ->>> offset_err_seq = [] ->>> for bit in offset_seq: -... if random.randint(0,4) == 4: -... offset_err_seq.append(random.randint(0,1)) -... else: -... offset_err_seq.append(bit) ->>> correct, overlap, offset = align_sequences(ran_seq, offset_err_seq) ->>> print(overlap, offset) -(100, -20) - -""" - -import random - -# DEFAULT PARAMETERS -# If the fraction of matching bits between two sequences is greater than -# this the sequences are assumed to be aligned. -def_correct_cutoff = 0.9 -# The maximum offset to test during sequence alignment. -def_max_offset = 500 -# The maximum number of samples to take from two sequences to check alignment. -def_num_samples = 1000 - -def compare_sequences(d1, d2, offset, sample_indices=None): - """ - Takes two binary sequences and an offset and returns the number of - matching entries and the number of compared entries. - d1 & d2 -- sequences - offset -- offset of d2 relative to d1 - sample_indices -- a list of indices to use for the comparison - """ - max_index = min(len(d1), len(d2)+offset) - if sample_indices is None: - sample_indices = range(0, max_index) - correct = 0 - total = 0 - for i in sample_indices: - if i >= max_index: - break - if d1[i] == d2[i-offset]: - correct += 1 - total += 1 - return (correct, total) - -def random_sample(size, num_samples=def_num_samples, seed=None): - """ - Returns a set of random integers between 0 and (size-1). - The set contains no more than num_samples integers. - """ - random.seed(seed) - if num_samples > size: - indices = set(range(0, size)) - else: - if num_samples > size/2: - num_samples = num_samples/2 - indices = set([]) - while len(indices) < num_samples: - index = random.randint(0, size-1) - indices.add(index) - indices = list(indices) - indices.sort() - return indices - -def align_sequences(d1, d2, - num_samples=def_num_samples, - max_offset=def_max_offset, - correct_cutoff=def_correct_cutoff, - seed=None, - indices=None): - """ - Takes two sequences and finds the offset and which the two sequences best - match. It returns the fraction correct, the number of entries compared, - the offset. - d1 & d2 -- sequences to compare - num_samples -- the maximum number of entries to compare - max_offset -- the maximum offset between the sequences that is checked - correct_cutoff -- If the fraction of bits correct is greater than this then - the offset is assumed to optimum. - seed -- a random number seed - indices -- an explicit list of the indices used to compare the two sequences - """ - max_overlap = max(len(d1), len(d2)) - if indices is None: - indices = random_sample(max_overlap, num_samples, seed) - max_frac_correct = 0 - best_offset = None - best_compared = None - best_correct = None - pos_range = range(0, min(len(d1), max_offset)) - neg_range = range(-1, -min(len(d2), max_offset), -1) - # Interleave the positive and negative offsets. - int_range = [item for items in zip(pos_range, neg_range) for item in items] - for offset in int_range: - correct, compared = compare_sequences(d1, d2, offset, indices) - frac_correct = 1.0*correct/compared - if frac_correct > max_frac_correct: - max_frac_correct = frac_correct - best_offset = offset - best_compared = compared - best_correct = correct - if frac_correct > correct_cutoff: - break - return max_frac_correct, best_compared, best_offset, indices - -if __name__ == "__main__": - import doctest - doctest.testmod() - diff --git a/gnuradio-core/src/python/gnuradio/utils/gray_code.py b/gnuradio-core/src/python/gnuradio/utils/gray_code.py deleted file mode 100644 index 926a1ded1..000000000 --- a/gnuradio-core/src/python/gnuradio/utils/gray_code.py +++ /dev/null @@ -1,66 +0,0 @@ -#!/usr/bin/env python -# -# Copyright 2011 Free Software Foundation, Inc. -# -# This file is part of GNU Radio -# -# GNU Radio is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 3, or (at your option) -# any later version. -# -# GNU Radio is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with GNU Radio; see the file COPYING. If not, write to -# the Free Software Foundation, Inc., 51 Franklin Street, -# Boston, MA 02110-1301, USA. -# - -class GrayCodeGenerator(object): - """ - Generates and caches gray codes. - """ - - def __init__(self): - self.gcs = [0, 1] - # The last power of two passed through. - self.lp2 = 2 - # The next power of two that will be passed through. - self.np2 = 4 - # Curent index - self.i = 2 - - def get_gray_code(self, length): - """ - Returns a list of gray code of given length. - """ - if len(self.gcs) < length: - self.generate_new_gray_code(length) - return self.gcs[:length] - - def generate_new_gray_code(self, length): - """ - Generates new gray code and places into cache. - """ - while len(self.gcs) < length: - if self.i == self.lp2: - # if i is a power of two then gray number is of form 1100000... - result = self.i + self.i/2 - else: - # if not we take advantage of the symmetry of all but the last bit - # around a power of two. - result = self.gcs[2*self.lp2-1-self.i] + self.lp2 - self.gcs.append(result) - self.i += 1 - if self.i == self.np2: - self.lp2 = self.i - self.np2 = self.i*2 - -_gray_code_generator = GrayCodeGenerator() - -gray_code = _gray_code_generator.get_gray_code - diff --git a/gnuradio-core/src/python/gnuradio/utils/mod_codes.py b/gnuradio-core/src/python/gnuradio/utils/mod_codes.py deleted file mode 100644 index caacda5cc..000000000 --- a/gnuradio-core/src/python/gnuradio/utils/mod_codes.py +++ /dev/null @@ -1,33 +0,0 @@ -#!/usr/bin/env python -# -# Copyright 2011 Free Software Foundation, Inc. -# -# This file is part of GNU Radio -# -# GNU Radio is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 3, or (at your option) -# any later version. -# -# GNU Radio is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with GNU Radio; see the file COPYING. If not, write to -# the Free Software Foundation, Inc., 51 Franklin Street, -# Boston, MA 02110-1301, USA. -# - -GRAY_CODE = 'gray' -SET_PARTITION_CODE = 'set-partition' -NO_CODE = 'none' - -codes = (GRAY_CODE, SET_PARTITION_CODE, NO_CODE) - -def invert_code(code): - c = enumerate(code) - ic = [(b, a) for (a, b) in c] - ic.sort() - return [a for (b, a) in ic] diff --git a/gnuradio-core/src/python/gnuradio/utils/run_tests.in b/gnuradio-core/src/python/gnuradio/utils/run_tests.in deleted file mode 100644 index adcbdfd21..000000000 --- a/gnuradio-core/src/python/gnuradio/utils/run_tests.in +++ /dev/null @@ -1,11 +0,0 @@ -#!/bin/sh - -# 1st parameter is absolute path to component source directory -# 2nd parameter is absolute path to component build directory -# 3rd parameter is path to Python QA directory - -# Note: calling master run_tests.sh in gnuradio core is not strictly -# correct, as it will result in a partially bogus PYTHONPATH, but it -# does make the correct paths in the second half so all is well. - -# Nothing in here at the moment. |