from point import Point

from LookupTable import LookupTable

import BitStringHelper as BSH

import BitGenerator as BG

import Encoder

import math

LINEAR = 0

GRAY = 1

def createMod2LookupTable():

return table

def modLevels2(bits):

return modList

def demodLevels2(symbols):

return bits

# Creates a 2D array with all valid I/Q point

# that can be within it for a pointsPerSide * pointsPerSide

# constellation diagram

def generatePointsMatrix(pointsPerSide):

return points

def createMod4LinearLookupTable():

return table

def createMod4GrayLookupTable():

return table

def modLevels4(bits, encoding):

return modList

def demodLevels4(symbols, encoding):

return bits

def createMod8LookupTable(encoding):

return table

def modLevels8(bits, encoding):

return modList

def demodLevels8(symbols, encoding):

return bits

# Generates a matrix that is 2^numberOfBits * 2^numberOfBits in size

# and populates it with all possible values between 0 and 2^numberOfBits.

#

# For linear encoding these values are place in the order they are generated

# with no concern for the number of bits that change between adjacent values.

#

# For Gray encoding a Karnaugh map is used in order to guarantee that no

# two adjacent values differ by more than a single bit.

def generateSquareMatrix(numberOfBits, encoding):

return matrix

def printSquareMatrix(matrix):

print("\n"),

def createMod16LookupTable(encoding):

return table

def modLevels16(bits, encoding):

return modList

def demodLevels16(symbols, encoding):

return bits

def createMod64LookupTable(encoding):

return table

def modLevels64(bits, encoding):

return modList

def demodLevels64(symbols, encoding):

return bits

def createMod256LookupTable(encoding):

return table

def modLevels256(bits, encoding):

return modList

def demodLevels256(symbols, encoding):

return bits

def createMod1024LookupTable(encoding):

return table

def modLevels1024(bits, encoding):

return modList

def demodLevels1024(symbols, encoding):

return bits

# Given a matrix that can be divided equally into 4 quadrants

# this function mirror the values in that quadrant into the other

# three quadrants.

#

# Eg. The top right quadrant with be mirrored along the y axis and so on

# Each of the 4 quadrant's value then has one of the four possible 2 bit sequences

# 00,01,10,11 prepended to them. This makes even value in the matrix unique while

# allow the programming of a single quadrant only.

def mirrorTopLeftQuadrant(matrix):

matrix[i][j] = "11" + matrix[i][j]

# Generates a skeleton matrix with will hold

# the cross constellation diagram for 32 QAM.

#

# Points that will not be used are marked as

# None

def generateBaseBitStringMatrixMod32():

return bitStrings

def createMod32LookupTable(encoding):

return table

def modLevels32(bits, encoding):

return modList

def demodLevels32(symbols, encoding):

return bits

def generateBaseBitStringMatrixMod128():

return bitStrings

def createBlankSquareMatrix(side):

return matrix

# Fills a 2x2 square in the passed matrix starting with

# the value in startValue. The first value is entered

# in the bottom left location and the rest are filled in

# in an anti-clockwise direction.

def bottomLeftFillerMod128(matrix, i, j, startValue):

matrix[i][j] = startValue

# Fills a 2x2 square in the passed matrix starting with

# the value in startValue. The first value is entered

# in the top right location and the rest are filled in

# in an anti-clockwise direction.

def topRightFillerMod128(matrix, i, j, startValue):

matrix[i+1][j+1] = startValue

# Fills a 2x2 square in the passed matrix with Nones.

def noneFillerMod128(matrix, i, j):

matrix[i+1][j+1] = None

# The matrix uses the 32 QAM Gray mapping as a base

# and fills in the values according to that template.

# Eg. if in the 32 QAM version a 0 was placed in that

# location then in the 128 version the values 0,1,2,3

# are placed in the 4 locations that map to the

# original 32 Qam location. Rather than filling the

# reference array with the bit sequences, the reference

# array is filled with the decimal number representing

# the binary value.

def generateReferenceArrayFor128():

return matrix

# Fills the reference array generated from the 32 QAM

# pattern into the top left quadrant of a full sized

# matrix so that it can be mirrored into the other quadrants

# as before

def fillInBitStringMatrixMod128(fullMatrix):

fullMatrix[i][j] = reversedMatrix[i][j]

# Replaces the index values used in the reference array with

# Gray code values.

def replaceWithGrayCodeBinary(matrix, numberOfBits):

matrix[i][j] = grayValues[int(matrix[i][j])]

def createMod128LookupTable(encoding):

return table

def modLevels128(bits, encoding):

return modList

def demodLevels128(symbols, encoding):

return bits

def generateBaseBitStringMatrixMod512():

return bitStrings

# Generates a reference array for 512 based on 128. To see

# how this is done look at the generateReferenceArrayFor128()

# method above which does the same thing but uses QAM 32 as

# a reference.

def generateReferenceArrayFor512():

return matrix

# Copies the reference matrix into the top left

# quadrant of the full matrix

def fillInBitStringMatrixMod512(fullMatrix):

fullMatrix[i][j] = reversedMatrix[i][j]

def createMod512LookupTable(encoding):

return table

def modLevels512(bits, encoding):

return modList

def demodLevels512(symbols, encoding):

return bits

def mod(bits, levels, encoding):

return modLevels1024(bits, encoding)

def demod(symbols, levels, encoding):

return demodLevels1024(symbols, encoding)