BPSK and QPSK Modulation Techniques with Python

BPSK Signal Generation

This section demonstrates the generation of a Binary Phase Shift Keying (BPSK) signal using Python.

import numpy as np
import matplotlib.pyplot as plt

def bpsk_detect(modulated_signal, carrier):
    return np.sign(modulated_signal * carrier)

message_frequency = 10
carrier_frequency = 20
sampling_frequency = 30 * carrier_frequency
t = np.arange(0, 4/carrier_frequency, 1/sampling_frequency)
message = np.sign(np.cos(2 * np.pi * message_frequency * t) + np.random.normal(scale = 0.01, size = len(t)))
carrier = np.cos(2 * np.pi * sampling_frequency/carrier_frequency * t)
modulated_signal = carrier * message
detected_message = bpsk_detect(modulated_signal, carrier)

plt.figure(figsize=(12, 8))
plt.subplot(4, 1, 1)
plt.plot(t, message)
plt.title('Message signal')
plt.subplot(4, 1, 2)
plt.plot(t, carrier)
plt.title('Carrier signal')
plt.subplot(4, 1, 3)
plt.plot(t, modulated_signal)
plt.title('Modulated signal')
plt.subplot(4, 1, 4)
plt.plot(t, detected_message)
plt.title('Detected message signal')
plt.tight_layout()
plt.show()

Monte Carlo Simulation for BPSK

This section implements a Monte Carlo simulation to evaluate the Bit Error Rate (BER) of BPSK modulation in an Additive White Gaussian Noise (AWGN) channel.

import numpy as np
import matplotlib.pyplot as plt

N = 5000000
EbNodB_range = range(0, 15)
ber = []

for EbNodB in EbNodB_range:
    EbNo = 10.0**(EbNodB/10.0)  # Convert dB to Linear
    # BPSK modulation
    x = 2 * (np.random.rand(N) >= 0.5) - 1  # Random NRZ message
    # AWGN channel
    noise_std = 1/np.sqrt(2*EbNo)
    y = x + noise_std * np.random.randn(N)  # Adding noise to message
    # Demodulation and error counting
    y_d = 2 * (y >= 0) - 1  # Received signal
    errors = np.sum(x != y_d)
    print(errors)
    # Calculate Bit Error Rate (BER) and store
    ber.append(1.0 * errors / N)

# Plotting
plt.semilogy(EbNodB_range, ber, 'bo-')
plt.xlabel('Eb/N0 (dB)')
plt.ylabel('Bit Error Rate (BER)')
plt.grid(True)
plt.title('BPSK Modulation with AWGN Channel')
plt.show()

QPSK Signal Generation

This section demonstrates the generation of a Quadrature Phase Shift Keying (QPSK) signal using Python.

import numpy as np
import matplotlib.pyplot as plt

def cosineWave(f, overSamplingRate, nCycles, phase):
    fs = overSamplingRate * f
    t = np.arange(0, nCycles * 1/f, 1/fs)
    g = np.cos(2 * np.pi * f * t + phase)
    return list(g)

fm = 10
fc = 30
overSamplingRate = 20
fs = overSamplingRate * fc
x = np.random.rand(30) >= 0.5  # True or false
str_x = [str(int(i)) for i in x]  # Boolean to string conversion via integer conversion
x = "".join(str_x)  # The bit stream
print("Message string: {}".format(x))
message = [x[2*i : 2*(i+1)] for i in range(int(len(x)/2))]  # Half the length of the string x.
print("Message string grouped as combinations of 2 bits each: {}".format(message))

mod_00 = cosineWave(fc, overSamplingRate, fc/fm, np.pi/6)
mod_01 = cosineWave(fc, overSamplingRate, fc/fm, np.pi/3)
mod_10 = cosineWave(fc, overSamplingRate, fc/fm, -np.pi/6)
mod_11 = cosineWave(fc, overSamplingRate, fc/fm, -np.pi/3)

modulated_signal = []
for i in message:
    if i == '00':
        modulated_signal += mod_00
    if i == '01':
        modulated_signal += mod_01
    if i == '10':
        modulated_signal += mod_10
    if i == '11':
        modulated_signal += mod_11

t = np.arange(0, (len(x)/2) * 1/fm, 1/fs)
print(len(t), len(modulated_signal))
plt.figure(figsize=(28, 6))
plt.plot(t, modulated_signal)
plt.xlabel("Time")
plt.ylabel("Amplitude")
plt.title("Modulated signal")
plt.grid(True)
plt.show()

QPSK Error Performance

This section analyzes the error performance of QPSK modulation.

# Error performance of QPSK
N = 500000
EbN0dB_list = np.arange(0, 20)
BER = []

for i in range(len(EbN0dB_list)):
    EbN0dB = EbN0dB_list[i]
    EbN0 = 10**(EbN0dB/10)  # DB TO LINEAR CONVERSION
    x = np.random.rand(N) >= 0.5  # BOOLEAN GENERATION
    x_str = [str(int(i)) for i in x]  # COVERSTION OF BOOLEAN TO STRING VIA INTEGER
    x_str = "".join(x_str)
    message = [x_str[2*i : 2*(i+1)] for i in range(int(len(x)/2))]  # BIT STREAM (Splits the binary string into pairs of bits, forming the message.)
    noise = 1/np.sqrt(2 * EbN0)  # Standard deviation calculation of gaussian noise
    channel = x + np.random.randn(N) * noise
    received_x = channel >= 0.5  # Decoding
    xReceived_str = [str(int(i)) for i in received_x]
    xReceived_str = "".join(xReceived_str)
    messageReceived = [xReceived_str[2*i : 2*(i+1)] for i in range(int(len(x)/2))]
    message = np.array(message)
    messageReceived = np.array(messageReceived)
    errors = (message != messageReceived).sum()
    BER.append(errors/N)
    # print(BER)
    plt.plot(EbN0dB_list, BER, "-", EbN0dB_list, BER, "go")
    plt.xscale('linear')
    plt.yscale('log')
    plt.grid()
    plt.xlabel("EbN0 in dB")
    plt.ylabel("BER")
    plt.title("BER in QPSK")
    plt.show()