Example #1
0
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_non_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 = digital_swig.constellation_rect(points, pre_diff_code, 4,
                                                    side, side, width, width)
    return constellation
Example #2
0
def dvbt_16qam_constellation(m, differential=_def_differential, mod_code=_def_mod_code):
    """
    Creates a QAM constellation object.
    """
    if m != 16:
        raise ValueError("16QAM can only have 16 constellation points.")
        
    if mod_code != mod_codes.GRAY_CODE:
        raise ValueError("Gray encoding missing.")
        
        
    side = int(sqrt(m))
    #width = 2.0
    width = 2.0/(side-1)
    
    points = [complex(3,3),complex(-3,3),complex(3,-3), complex(-3,-3),
	      complex(1,3),complex(-1,3),complex(1,-3),complex(-1,-3),
	      complex(3,1),complex(-3,1),complex(3,-1), complex(-3,-1),
              complex(1,1),complex(-1,1),complex(1,-1),complex(-1,-1)]
              
    norm_points = map(lambda pt: pt / (math.sqrt(10)), points)

    # No pre-diff code
    # Should add one so that we can gray-code the quadrant bits too.
    pre_diff_code = []
    constellation = digital_swig.constellation_rect(norm_points, pre_diff_code, 4,
                                                    side, side, width, width)
    return constellation
Example #3
0
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=False)
    else:
        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)
    else:
        pre_diff_code = []
    constellation = digital.constellation_rect(points, pre_diff_code, 4,
                                               side, side, width, width)
    return constellation
Example #4
0
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_non_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 = []
    print points
    constellation = digital_swig.constellation_rect(points, pre_diff_code, 4,
                                                    side, side, width, width)
    return constellation
Example #5
0
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
Example #6
0
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
Example #7
0
def qam_constellation(constellation_points=_def_constellation_points,
                      differential=_def_differential,
                      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
    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=False)
    else:
        points = make_non_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 = []
    if not large_ampls_to_corners:
        constellation = digital.constellation_rect(points, pre_diff_code, 4,
                                                        side, side, width, width)
    else:
        sector_values = large_ampls_to_corners_mapping(side, points, width)
        constellation = digital.constellation_expl_rect(
            points, pre_diff_code, 4, side, side, width, width, sector_values)

    return constellation
Example #8
0
def qam_constellation(constellation_points=_def_constellation_points,
                      differential=_def_differential,
                      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
    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=False)
    else:
        points = make_non_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 = []
    if not large_ampls_to_corners:
        constellation = digital.constellation_rect(points, pre_diff_code, 4,
                                                        side, side, width, width)
    else:
        sector_values = large_ampls_to_corners_mapping(side, points, width)
        constellation = digital.constellation_expl_rect(
            points, pre_diff_code, 4, side, side, width, width, sector_values)

    return constellation