Merge branch 'master' into next

Conflicts: gr-digital/include/digital_constellation.h gr-digital/lib/digital_constellation.cc gr-digital/python/qa_constellation.py gr-digital/python/qa_constellation_receiver.py gr-digital/python/qam.py gr-digital/swig/digital_constellation.i
author: Tom Rondeau <trondeau@vt.edu> 2013-03-06 17:18:37 -0500
committer: Tom Rondeau <trondeau@vt.edu> 2013-03-06 17:18:37 -0500
commit: 5c18bac20fcbdee03c332e29a676ea8f1481b5ea (patch)
tree: 7988441a1b098d336314bdc8e74979553c7d2d53 /gr-digital/python
parent: 9ac143a654bc581d9a74363fc02e1ad30be93138 (diff)
parent: 64d8f82c531a477262304bf93b98c2de4eb83d35 (diff)
5 files changed, 287 insertions, 53 deletions
diff --git a/gr-digital/python/CMakeLists.txt b/gr-digital/python/CMakeLists.txt
index c44248d54c..7f35e3c2be 100644
--- a/gr-digital/python/CMakeLists.txt
+++ b/gr-digital/python/CMakeLists.txt
@@ -43,6 +43,7 @@ GR_PYTHON_INSTALL(
     pkt.py
     psk.py
     qam.py
+    qamlike.py
     qpsk.py
     DESTINATION ${GR_PYTHON_DIR}/gnuradio/digital
     COMPONENT "digital_python"
diff --git a/gr-digital/python/qa_constellation.py b/gr-digital/python/qa_constellation.py
index 37112f70a3..a593c3ea3e 100755
--- a/gr-digital/python/qa_constellation.py
+++ b/gr-digital/python/qa_constellation.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 #
-# Copyright 2011 Free Software Foundation, Inc.
+# Copyright 2011,2013 Free Software Foundation, Inc.
 # 
 # This file is part of GNU Radio
 # 
@@ -31,6 +31,7 @@ import blocks_swig as blocks
 # import from local folder
 import psk
 import qam
+import qamlike
 
 tested_mod_codes = (mod_codes.NO_CODE, mod_codes.GRAY_CODE)
 
@@ -65,11 +66,14 @@ def threed_constell():
     dim = 3
     return digital.constellation_calcdist(points, [], rot_sym, dim)
 
-tested_constellation_info = (
+# A list of tuples for constellation testing.  The contents of the
+# tuples are (constructor, poss_args, differential, diff_argname).
+
+# These constellations should lock on well.
+easy_constellation_info = (
     (psk.psk_constellation,
-     {'m': (2, 4, 8, 16, 32, 64),
-      'mod_code': tested_mod_codes, 
-      'differential': (True,)},
+     {'m': (2, 4, 8, 16, ),
+      'mod_code': tested_mod_codes, },
      True, None),
     (psk.psk_constellation,
      {'m': (2, 4, 8, 16, 32, 64),
@@ -77,9 +81,9 @@ tested_constellation_info = (
       'differential': (False,)},
      False, None),
     (qam.qam_constellation,
-     {'constellation_points': (4, 16, 64),
+     {'constellation_points': (4,),
       'mod_code': tested_mod_codes, 
-      'differential': (True,)},
+      'large_ampls_to_corners': [False],},
      True, None),
     (qam.qam_constellation,
      {'constellation_points': (4, 16, 64),
@@ -94,11 +98,44 @@ tested_constellation_info = (
     (threed_constell, {}, True, None),
     )
 
-def tested_constellations():
+# These constellations don't work nicely.
+# We have a lower required error rate.
+medium_constellation_info = (
+    (psk.psk_constellation,
+     {'m': (32, 64),
+      'mod_code': tested_mod_codes, },
+     True, None),
+    (qam.qam_constellation,
+     {'constellation_points': (16 ,),
+      'mod_code': tested_mod_codes, 
+      'large_ampls_to_corners': [False, True],},
+     True, None),
+    (qamlike.qam32_holeinside_constellation,
+     {'large_ampls_to_corners': [True]},
+     True, None),
+)
+
+# These constellation are basically broken in our test
+difficult_constellation_info = (
+    (qam.qam_constellation,
+     {'constellation_points': (64,),
+      'mod_code': tested_mod_codes, 
+      'large_ampls_to_corners': [False, True],},
+     True, None),    
+)
+
+def tested_constellations(easy=True, medium=True, difficult=True):
     """
     Generator to produce (constellation, differential) tuples for testing purposes.
     """
-    for constructor, poss_args, differential, diff_argname in tested_constellation_info:
+    constellation_info = []
+    if easy:
+        constellation_info += easy_constellation_info
+    if medium:
+        constellation_info += medium_constellation_info
+    if difficult:
+        constellation_info += difficult_constellation_info
+    for constructor, poss_args, differential, diff_argname in constellation_info:
         if differential:
             diff_poss = (True, False)
         else:
diff --git a/gr-digital/python/qa_constellation_receiver.py b/gr-digital/python/qa_constellation_receiver.py
index ff0154d740..bc44220ea9 100755
--- a/gr-digital/python/qa_constellation_receiver.py
+++ b/gr-digital/python/qa_constellation_receiver.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 #
-# Copyright 2011 Free Software Foundation, Inc.
+# Copyright 2011,2013 Free Software Foundation, Inc.
 # 
 # This file is part of GNU Radio
 # 
@@ -42,7 +42,9 @@ SEED = 1239
 # We need this many to let the frequency recovery block converge.
 DATA_LENGTH = 1000
 # Test fails if fraction of output that is correct is less than this.
-REQ_CORRECT = 0.7
+EASY_REQ_CORRECT = 0.9
+# For constellations that aren't expected to work so well.
+MEDIUM_REQ_CORRECT = 0.8
 
 # CHANNEL PARAMETERS
 NOISE_VOLTAGE = 0.01
@@ -103,30 +105,33 @@ class test_constellation_receiver(gr_unittest.TestCase):
         self.indices = alignment.random_sample(
             self.max_data_length, self.max_num_samples, SEED)
 
-        for constellation, differential in tested_constellations():
-            # The constellation_receiver doesn't work for constellations
-            # of multple dimensions (i.e. multiple complex numbers to a
-            # single symbol).
-            # That is not implemented since the receiver has no way of
-            # knowing where the beginning of a symbol is.
-            # It also doesn't work for non-differential modulation.
-            if constellation.dimensionality() != 1:
-                continue
-            data_length = DATA_LENGTH * constellation.bits_per_symbol()
-            if differential:
-                freq_offset=True
-            else:
-                freq_offset=False
-            tb = rec_test_tb(constellation, differential,
-                             src_data=self.src_data[:data_length],
-                             freq_offset=freq_offset)
-            tb.run()
-            data = tb.dst.data()
-            d1 = tb.src_data[:int(len(tb.src_data)*self.ignore_fraction)]
-            d2 = data[:int(len(data)*self.ignore_fraction)]
-            correct, overlap, offset, indices = alignment.align_sequences(
-                d1, d2, indices=self.indices)
-            self.assertTrue(correct > REQ_CORRECT)
+        requirements = (
+            (EASY_REQ_CORRECT, tested_constellations(easy=True, medium=False, difficult=False)),
+            (MEDIUM_REQ_CORRECT, tested_constellations(easy=False, medium=True, difficult=False)),
+            )
+        for req_correct, tcs in requirements:
+            for constellation, differential in tcs:
+                # The constellation_receiver doesn't work for constellations
+                # of multple dimensions (i.e. multiple complex numbers to a
+                # single symbol).
+                # That is not implemented since the receiver has no way of
+                # knowing where the beginning of a symbol is.
+                # It also doesn't work for non-differential modulation.
+                if constellation.dimensionality() != 1 or not differential:
+                    continue
+                data_length = DATA_LENGTH * constellation.bits_per_symbol()
+                tb = rec_test_tb(constellation, differential,
+                                 src_data=self.src_data[:data_length])
+                tb.run()
+                data = tb.dst.data()
+                d1 = tb.src_data[:int(len(tb.src_data)*self.ignore_fraction)]
+                d2 = data[:int(len(data)*self.ignore_fraction)]
+                correct, overlap, offset, indices = alignment.align_sequences(
+                    d1, d2, indices=self.indices)
+                if correct <= req_correct:
+                    print("Constellation is {0}. Differential is {1}.  Required correct is {2}. Correct is {3}. FAIL.".
+                          format(constellation, differential, req_correct, correct))
+                self.assertTrue(correct > req_correct)
             
 
 class rec_test_tb(gr.top_block):
diff --git a/gr-digital/python/qam.py b/gr-digital/python/qam.py
index 8584c59c6f..5919839186 100644
--- a/gr-digital/python/qam.py
+++ b/gr-digital/python/qam.py
@@ -1,5 +1,5 @@
 #
-# Copyright 2005,2006,2011 Free Software Foundation, Inc.
+# Copyright 2005,2006,2011,2013 Free Software Foundation, Inc.
 # 
 # This file is part of GNU Radio
 # 
@@ -147,9 +147,17 @@ def make_non_differential_constellation(m, gray_coded):
 
 def qam_constellation(constellation_points=_def_constellation_points,
                       differential=_def_differential,
-                      mod_code=_def_mod_code):
+                      mod_code=_def_mod_code,
+                      large_ampls_to_corners=False):
     """
     Creates a QAM constellation object.
+
+    If large_ampls_to_corners=True then sectors that are probably
+    occupied due to a phase offset, are not mapped to the closest
+    constellation point.  Rather we take into account the fact that a
+    phase offset is probably the problem and map them to the closest
+    corner point.  It's a bit hackish but it seems to improve
+    frequency locking.
     """
     if mod_code == mod_codes.GRAY_CODE:
         gray_coded = True
@@ -163,19 +171,90 @@ def qam_constellation(constellation_points=_def_constellation_points,
         points = make_non_differential_constellation(constellation_points, gray_coded)
     side = int(sqrt(constellation_points))
     width = 2.0/(side-1)
-    # For differential and gray-coded then gray-code the first two
-    # bits with a pre_diff_code.
-    # FIXME: It would be good to have a test to make sure that gray-coded constellations
-    # are really gray-coded.  Perhaps by checking on the correlation between bit-errors.
-    if differential and gray_coded:
-        m = constellation_points
-        pre_diff_code = range(0, m/2) + range(3*m/4, m) + range(m/2, 3*m/4)
+
+    # No pre-diff code
+    # Should add one so that we can gray-code the quadrant bits too.
+    pre_diff_code = []
+    if not large_ampls_to_corners:
+        constellation = digital_swig.constellation_rect(points, pre_diff_code, 4,
+                                                        side, side, width, width)
     else:
-        pre_diff_code = []
-    constellation = digital.constellation_rect(points, pre_diff_code, 4,
-                                               side, side, width, width)
+        sector_values = large_ampls_to_corners_mapping(side, points, width)
+        constellation = digital_swig.constellation_expl_rect(
+            points, pre_diff_code, 4, side, side, width, width, sector_values)
+
     return constellation
 
+def find_closest_point(p, qs):
+    """
+    Return in index of the closest point in 'qs' to 'p'.
+    """
+    min_dist = None
+    min_i = None
+    for i, q in enumerate(qs):
+        dist = abs(q-p)
+        if min_dist is None or dist < min_dist:
+            min_dist = dist
+            min_i = i
+    return min_i
+
+def large_ampls_to_corners_mapping(side, points, width):
+    """
+    We have a grid that we use for decision making.  One additional row/column
+    is placed on each side of the grid.  Points in these additional rows/columns
+    are mapped to the corners rather than the closest constellation points.
+
+    Args:
+        side: The number of rows/columns in the grid that we use to do
+              decision making.
+        points: The list of constellation points.
+        width: The width of the rows/columns.
+
+    Returns:
+        sector_values maps the sector index to the constellation
+        point index.
+    """
+    # First find the indices of the corner points.
+    # Assume the corner points are the 4 points with the largest magnitudes.
+    corner_indices = []
+    corner_points = []
+    max_mag = 0
+    for i, p in enumerate(points):
+        if abs(p) > max_mag:
+            corner_indices = [i]
+            corner_points = [p]
+            max_mag = abs(p)
+        elif abs(p) == max_mag:
+            corner_indices.append(i)
+            corner_points.append(p)
+    if len(corner_indices) != 4:
+        raise ValueError("Found {0} corner indices.  Expected 4."
+                         .format(len(corner_indices)))
+    # We want an additional layer around the constellation
+    # Value in this extra layer will be mapped to the closest corner rather
+    # than the closest constellation point.
+    extra_layers = 1
+    side = side + extra_layers*2
+    # Calculate sector values
+    sector_values = []
+    for real_x in range(side):
+        for imag_x in range(side):
+            sector = real_x * side + imag_x
+            # If this sector is a normal constellation sector then
+            # use the center point.
+            c = ((real_x-side/2.0+0.5)*width +
+                 (imag_x-side/2.0+0.5)*width*1j)
+            if (real_x >= extra_layers and real_x < side-extra_layers
+                and imag_x >= extra_layers and imag_x < side-extra_layers):
+                # This is not an edge row/column.  Find closest point.
+                index = find_closest_point(c, points)
+            else:
+                # This is an edge. Find closest corner point.
+                index = corner_indices[find_closest_point(c, corner_points)]
+            sector_values.append(index)
+    return sector_values
+
+ 
 # /////////////////////////////////////////////////////////////////////////////
 #                           QAM modulator
 # /////////////////////////////////////////////////////////////////////////////
@@ -200,9 +279,25 @@ class qam_mod(generic_mod):
                  mod_code=_def_mod_code,
                  *args, **kwargs):
 
-        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.
+        """
+	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.
+
+        Args:
+            constellation_points: Number of constellation points.
+                Must be a power of 4.
+            mod_code: Specifies an encoding to use (typically used to indicated
+                      if we want gray coding, see digital.utils.mod_codes)
+
+        See generic_mod block for list of additional 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)
 
@@ -229,10 +324,31 @@ class qam_demod(generic_demod):
     def __init__(self, constellation_points=_def_constellation_points,
                  differential=_def_differential,
                  mod_code=_def_mod_code,
+                 large_ampls_to_corner = False,
                  *args, **kwargs):
-        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.
+        """
+	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.
+
+        Args:
+            constellation_points: Number of constellation points.
+                Must be a power of 4.
+            mod_code: Specifies an encoding to use (typically used to indicated
+                      if we want gray coding, see digital.utils.mod_codes)
+            large_ampls_to_corners:  If this is set to True then when the
+                constellation is making decisions, points that are far outside
+                the constellation are mapped to the closest corner rather than
+                the closet constellation point.  This can help with phase
+                locking.
+
+        See generic_demod block for list of additional 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)
 
diff --git a/gr-digital/python/qamlike.py b/gr-digital/python/qamlike.py
new file mode 100644
index 0000000000..2f8c855339
--- /dev/null
+++ b/gr-digital/python/qamlike.py
@@ -0,0 +1,75 @@
+# Copyright 2013 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 file contains constellations that are similar to QAM, but are not perfect squares.
+"""
+
+import digital_swig
+from qam import large_ampls_to_corners_mapping
+
+def qam32_holeinside_constellation(large_ampls_to_corners=False):
+    # First make constellation for one quadrant.
+    #      0   1   2 
+    # 2 - 010 111 110
+    # 1 - 011 101 100
+    # 0 - 000 001
+
+    # Have put hole in the side rather than corner.
+    # Corner point is helpful for frequency locking.
+
+    # It has an attempt at some gray-coding, but not
+    # a very good one.
+
+    # Indices are (horizontal, vertical).
+    indices_and_numbers = (
+        ((0, 0), 0b000),
+        ((0, 1), 0b011),
+        ((0, 2), 0b010),
+        ((1, 0), 0b001),
+        ((1, 1), 0b101),
+        ((1, 2), 0b111),
+        ((2, 1), 0b100),
+        ((2, 2), 0b110),
+        )
+    points = [None]*32
+    for indices, number in indices_and_numbers:
+        p_in_quadrant = 0.5+indices[0] + 1j*(0.5+indices[1])
+        for quadrant in range(4):
+            index = number + 8 * quadrant
+            rotation = pow(1j, quadrant)
+            p = p_in_quadrant * rotation
+            points[index] = p
+    side = 6
+    width = 1
+    # Double number of boxes on side
+    # This is so that points in the 'hole' get assigned correctly.
+    side = 12
+    width = 0.5
+    pre_diff_code = []
+    if not large_ampls_to_corners:
+        constellation = digital_swig.constellation_rect(points, pre_diff_code, 4,
+                                                        side, side, width, width)
+    else:
+        sector_values = large_ampls_to_corners_mapping(side, points, width)
+        constellation = digital_swig.constellation_expl_rect(
+            points, pre_diff_code, 4, side, side, width, width, sector_values)
+    return constellation
+
author	Tom Rondeau <trondeau@vt.edu>	2013-03-06 17:18:37 -0500
committer	Tom Rondeau <trondeau@vt.edu>	2013-03-06 17:18:37 -0500
commit	5c18bac20fcbdee03c332e29a676ea8f1481b5ea (patch)
tree	7988441a1b098d336314bdc8e74979553c7d2d53 /gr-digital/python
parent	9ac143a654bc581d9a74363fc02e1ad30be93138 (diff)
parent	64d8f82c531a477262304bf93b98c2de4eb83d35 (diff)