Generalized OFDMA Simulation with Python

This document provides a guide to a generalized Orthogonal Frequency Division Multiple Access (OFDMA) simulation using Python. The OFDMA Python code presented here simulates a two-user scenario, incorporating data modulation (QPSK) and IFFT.

Introduction to OFDMA

OFDMA, or Orthogonal Frequency Division Multiple Access, is a multi-user variant of the OFDM digital modulation scheme. In OFDMA, multiple users share the same symbol duration, but each user is assigned a different set of subcarriers, hence achieving multiple access. Subcarriers are combined to form subchannels, and each user is allocated one or more unique subchannels.

OFDMA is employed in various wireless technologies, including:

• Mobile WiMAX (IEEE 802.16e)
• WLAN (WiFi-6 IEEE 802.11ax)
• 4G LTE
• 5G NR

For a detailed explanation of OFDMA modules, especially as defined in the Mobile WiMAX (IEEE 802.16e) standard, refer to articles on OFDMA Physical Layer.

OFDMA Simulation Block Diagram

The following block diagram illustrates the key components used in the OFDMA simulation, implemented using Python code.

In this simulation, we use 192 data subcarriers, which are divided into 8 subchannels. Each subchannel consists of 24 data subcarriers. For demonstration purposes, we allocate a unique subchannel to each of the two users. Specifically, user #1 is assigned subchannel #2, while user #2 is assigned subchannel #5. At the receiver, we specify the subchannel number assigned to user #1 to retrieve its data.

OFDMA Frame Structure

The following diagram presents the OFDMA frame structure implemented in the python simulation.

In this Python simulation, we have omitted guard subcarriers, pilot subcarriers, and the null subcarrier for simplicity. We focus on implementing the core OFDMA concept. Consequently, several blocks typically found in a complete OFDMA physical layer implementation (e.g., scrambler, FEC encoder, interleaver) are not included in this simulation.

OFDMA Python Code

# Following script is OFDMA simulation python code
# Library files
import random
import numpy as np
import matplotlib.pyplot as plt
from scipy.fftpack import fft, ifft, ifftshift

# Define parameters for OFDMA System simulation
dataCarriers = 192  # Number of data sub carriers in a symbol
DataSC_per_subchannel = 24
Nsubchl = 8  # Each subchannel carry 24 data subcarriers
mu = 2  # bits per symbol for QPSK modulation type (mu = 4 for 16QAM, mu = 6 for 64QAM)
payloadBits_per_OFDM = dataCarriers * mu  # number of payload bits per OFDM symbol   192*2 = 384 bits
payloadBits_per_SC = DataSC_per_subchannel * mu  # number of payload bits per OFDM symbol   192*2 = 384 bits
len1 = payloadBits_per_SC  # length of input data
mode = 2  # Modulation Order for QPSK

mapping_table = {
    0: 0.7071 + 0.7071j,
    1: - 0.7071 + 0.7071j,
    2: 0.7071 - 0.7071j,
    3: - 0.7071 - 0.7071j
}

# Conversion of 192 data subcarriers to 8 Subchannels
list = [i for i in range(1, 193)]
SCarray = np.reshape(list, (8, 24))
print(list)

# USer # 1 Mapping
# Step-1 : Sub channel allocation
SCnum = 2  # Range of sub channel assignment is 0 to 7
print(SCarray[SCnum, :])

# Step 2 : Binary data generation for 1 sub channel
# i.e. 24 data sub carriers i.e. 48 bits
input_data = ""
for i in range(len1):
    temp1 = str(random.randint(0, 1))
    input_data += temp1
print(input_data)

# Step-3: Converting binary vector into group of 2 bits (as per QPSK) and
# map the same as per mapping table
s1 = input_data
s2_user1 = []
chunks = [s1[i:i+mode] for i in range(0, len(s1), mode)]
for piece in chunks:
    temp = int(piece, 2)
    s2_user1.append(temp)
print(s2_user1)

Q = np.zeros((24,), dtype=complex)
j = 0
for val in s2_user1:
    Q[j] = mapping_table[val]
    j += 1
print(Q)

dummy1 = [0 for element in range(256)]
i = 0
for val1 in SCarray[SCnum, :]:
    dummy1[val1] = Q[i]
    i += 1
print('complex value inserted:', dummy1)

# USer # 1 Mapping
# Step-1 : Sub channel allocation
SCnum = 5  # Range of sub channel assignment is 0 to 7
print(SCarray[SCnum, :])

# Step 2 : Binary data generation for 1 sub channel
# i.e. 24 data sub carriers i.e. 48 bits
input_data = ""
for i in range(len1):
    temp1 = str(random.randint(0, 1))
    input_data += temp1
print(input_data)

# Step-3: Converting binary vector into group of 2 bits (as per QPSK) and
# map the same as per mapping table
s1 = input_data
s2_user2 = []
chunks = [s1[i:i+mode] for i in range(0, len(s1), mode)]
for piece in chunks:
    temp = int(piece, 2)
    s2_user2.append(temp)
print(s2_user2)

Q1 = np.zeros((24,), dtype=complex)
j = 0
for val in s2_user2:
    Q1[j] = mapping_table[val]
    j += 1
print(Q)

dummy2 = [0 for element in range(256)]
i = 0
for val1 in SCarray[SCnum, :]:
    dummy2[val1] = Q1[i]
    i += 1
print('complex value inserted:', dummy2)

# Summing data of both users
dummy = np.zeros((256,), dtype=complex)
for i in range(1, 256):
    dummy[i] = dummy1[i] + dummy2[i]

# Time domain conversion before feeding data to DAC
N = 256
OFDM_sym = ifft(dummy, N)

# Receiver part (User # 1 decoding)
SCnum = 2  # This is 2 for user#1 and 5 for user#2
OFDM_sym_r = fft(OFDM_sym, N)

Q_r = np.zeros((24,), dtype=complex)
i = 0
for val1 in SCarray[SCnum, :]:
    Q_r[i] = OFDM_sym_r[val1]
    i += 1

# Plots for User # 1
figure, axis = plt.subplots(2, 2)

# For Built in convolution
axis[0, 0].plot(Q.real, Q.imag, 'bo')
axis[0, 0].set_title("User #1 : Tx Constellation Diagram")

axis[0, 1].plot(OFDM_sym)
axis[0, 1].set_title("Time domain IFFT diagram")

axis[1, 0].plot(OFDM_sym_r)
axis[1, 0].set_title("Frequency domain FFT diagram")

axis[1, 1].plot(Q_r.real, Q_r.imag, 'ro')
axis[1, 1].set_title("User #1 : Rx const. diagram")

plt.tight_layout()
plt.show()

Output Plots

The following plots represent the output of the OFDMA Python code, including:

• Transmit constellation diagram (for user #1)
• Time domain diagram (for both users)
• Frequency domain diagram (for both users)
• Received constellation diagram (for user #1)