diff options
| author | Ben Reynwar <ben@reynwar.net> | 2011-05-11 00:17:09 -0700 |
|---|---|---|
| committer | Ben Reynwar <ben@reynwar.net> | 2011-05-11 00:17:09 -0700 |
| commit | 0b3658687ac902763ffa4d1c0f574e470b3c28db (patch) | |
| tree | 4e2e15e233814ef086a40eeac71cb09adea29d8d /gnuradio-core/src/python/gnuradio/blks2impl | |
| parent | f6c10234d42f5b6913002ca3cd5723b9c5270f7c (diff) | |
Moved generic psk and qam modulation into gr-digital.
Diffstat (limited to 'gnuradio-core/src/python/gnuradio/blks2impl')
6 files changed, 0 insertions, 924 deletions
diff --git a/gnuradio-core/src/python/gnuradio/blks2impl/Makefile.am b/gnuradio-core/src/python/gnuradio/blks2impl/Makefile.am index 6a2e7d5f74..34e246b36d 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 16524de945..0000000000 --- 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 44779754b1..0000000000 --- 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 aaa9659a43..0000000000 --- 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 9c135b25a9..0000000000 --- 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 4af8d00180..0000000000 --- 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) |