Phase-shift keying¶

import matplotlib.pyplot as plt
import numpy as np

import sdr

%config InlineBackend.print_figure_kwargs = {"facecolor" : "w"}
%matplotlib inline
# %matplotlib widget

In the sdr library, phase-shift keying modulation is available in the sdr.PSK class.

def analyze_psk(psk, esn0):
    # Generate random decimal symbols
    s = np.random.randint(0, psk.order, 100_000)

    # Modulate decimal symbols to complex symbols
    x = psk.map_symbols(s)

    # Add AWGN to complex symbols to achieve desired Es/N0
    snr = sdr.esn0_to_snr(esn0, sps=1)
    x_hat = sdr.awgn(x, snr)

    plt.figure(figsize=(10, 5))
    plt.subplot(1, 2, 1)
    sdr.plot.symbol_map(psk.symbol_map, limits=(-2, 2))
    plt.subplot(1, 2, 2)
    sdr.plot.constellation(x_hat, bins=75, heatmap=True, limits=(-2, 2))
    plt.title(f"Constellation at {esn0} dB $E_s/N_0$")
    plt.suptitle(f"{psk.order}-PSK constellation")
    plt.tight_layout()
    plt.show()

    y = psk.modulate(s)
    # h_srrc = sdr.root_raised_cosine(0.1, 6, sps)
    # tx_mf = sdr.Interpolator(sps, h_srrc)
    # y = tx_mf(x)

    plt.figure(figsize=(10, 5))
    sdr.plot.time_domain(y[0:1000])
    plt.show()

Constellations¶

BPSK¶

bpsk = sdr.PSK(2, sps=10, pulse_shape="srrc")
analyze_psk(bpsk, 6)

../../_images/44ddd676d80d87af4b45f2dfeebea16c2f4c0de764eecfbce37e99e0724a781f.png

../../_images/a0181b3e746027c3a599d193175c081c874c1b70c49cf66c0bc4ae5d42099506.png

QPSK¶

qpsk = sdr.PSK(4, phase_offset=45, sps=10, pulse_shape="srrc")
analyze_psk(qpsk, 9)

../../_images/eeafebaf9cc7ec6632a1fde3b0390a385d08ad7bfba9faf89ef09bb973a0f2dd.png

../../_images/a76252c66d918ed8d76c1e51df5e75a019d33a8bf94714a5eca6d682011dc323.png

8-PSK¶

psk8 = sdr.PSK(8, sps=10, pulse_shape="srrc")
analyze_psk(psk8, 12)

../../_images/b1540b98e9b8402ce88ca59c6fd04326ec7312f15142c836db4290ff591812be.png

../../_images/b87a649852693af588d2b61b7877489cd447886e2cec912cadc5ca1aa64f9590.png

16-PSK¶

psk16 = sdr.PSK(16, sps=10, pulse_shape="srrc")
analyze_psk(psk16, 18)

../../_images/e957629bbcf515f208fdb5d77a19ed896c81c233585868fe057a73b32ff83853.png

../../_images/d36610d9d3fcec87479ccbe927530de05e5789dfc4e19c6be778e55b069299cd.png

Error rate curves¶

def error_rates(psk, ebn0):
    esn0 = sdr.ebn0_to_esn0(ebn0, psk.bps)
    snr = sdr.esn0_to_snr(esn0)

    ber = sdr.ErrorRate()
    ser = sdr.ErrorRate()

    for i in range(snr.size):
        s = np.random.randint(0, psk.order, int(1e6))
        a = psk.map_symbols(s)
        a_tilde = sdr.awgn(a, snr[i])
        s_hat, a_hat = psk.decide_symbols(a_tilde)

        ber.add(ebn0[i], sdr.unpack(s, psk.bps), sdr.unpack(s_hat, psk.bps))
        ser.add(esn0[i], s, s_hat)

    return ber, ser

ebn0 = np.linspace(-2, 10, 20)

bpsk_ber, bpsk_ser = error_rates(bpsk, ebn0)
qpsk_ber, qpsk_ser = error_rates(qpsk, ebn0)
psk8_ber, psk8_ser = error_rates(psk8, ebn0)
psk16_ber, psk16_ser = error_rates(psk16, ebn0)

Bit error rate curves¶

plt.figure(figsize=(10, 5))
ebn0 = np.linspace(-2, 10, 200)
sdr.plot.ber(ebn0, bpsk.ber(ebn0), label="BPSK theoretical")
sdr.plot.ber(ebn0, qpsk.ber(ebn0), label="QPSK theoretical")
sdr.plot.ber(ebn0, psk8.ber(ebn0), label="8-PSK theoretical")
sdr.plot.ber(ebn0, psk16.ber(ebn0), label="16-PSK theoretical")
plt.gca().set_prop_cycle(None)
sdr.plot.ber(*bpsk_ber.error_rates(), linestyle="none", marker=".", label="BPSK simulated")
sdr.plot.ber(*qpsk_ber.error_rates(), linestyle="none", marker=".", label="QPSK simulated")
sdr.plot.ber(*psk8_ber.error_rates(), linestyle="none", marker=".", label="8-PSK simulated")
sdr.plot.ber(*psk16_ber.error_rates(), linestyle="none", marker=".", label="16-PSK simulated")
plt.ylim(1e-6, 1e0)
plt.title("Bit error rate curves for PSK modulation in AWGN")
plt.tight_layout()
plt.show()

../../_images/30fcb824556beef452a166873d4ab790ae685b153ec34b7d6424ec0911e51ac5.png

Symbol error rate curves¶

plt.figure(figsize=(10, 5))
esn0 = np.linspace(-4, 16, 200)
sdr.plot.ser(esn0, bpsk.ser(esn0), label="BPSK theoretical")
sdr.plot.ser(esn0, qpsk.ser(esn0), label="QPSK theoretical")
sdr.plot.ser(esn0, psk8.ser(esn0), label="8-PSK theoretical")
sdr.plot.ser(esn0, psk16.ser(esn0), label="16-PSK theoretical")
plt.gca().set_prop_cycle(None)
sdr.plot.ser(*bpsk_ser.error_rates(), linestyle="none", marker=".", label="BPSK simulated")
sdr.plot.ser(*qpsk_ser.error_rates(), linestyle="none", marker=".", label="QPSK simulated")
sdr.plot.ser(*psk8_ser.error_rates(), linestyle="none", marker=".", label="8-PSK simulated")
sdr.plot.ser(*psk16_ser.error_rates(), linestyle="none", marker=".", label="16-PSK simulated")
plt.ylim(1e-6, 1e0)
plt.title("Symbol error rate curves for PSK modulation in AWGN")
plt.tight_layout()
plt.show()

../../_images/f56762034abd17fcb032735cb74f29d8738ec4d31997453841e5b4e43e529974.png

Symbol mapping¶

The mapping of decimal symbols to complex symbols is important. Ideally, adjacent symbol errors only result in 1 bit error. This is generally accomplished using a Gray code (the default in :class:sdr.PSK).

psk8_bin = sdr.PSK(8, symbol_labels="bin")
psk8_gray = sdr.PSK(8, symbol_labels="gray")

plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
sdr.plot.symbol_map(psk8_bin.symbol_map, limits=(-2, 2))
plt.title(f"Symbol map for binary coded 8-PSK")
plt.subplot(1, 2, 2)
sdr.plot.symbol_map(psk8_gray.symbol_map, limits=(-2, 2))
plt.title(f"Symbol map for gray coded 8-PSK")
plt.tight_layout()
plt.show()

../../_images/a3c2b8d900462bceb7efa1b4608b1ae4f00c4f34d3aff540305f9a0af6905093.png

Since adjacent symbol errors can lead to multiple bit errors, binary-coded 8-PSK has worse bit error performance.

plt.figure(figsize=(10, 5))
ebn0 = np.linspace(-2, 10, 200)
sdr.plot.ber(ebn0, sdr.PSK(8, symbol_labels="bin").ber(ebn0), label="8-PSK w/ binary code")
sdr.plot.ber(ebn0, sdr.PSK(8, symbol_labels="gray").ber(ebn0), label="8-PSK w/ gray code")
plt.title("Bit error rate curves for 8-PSK modulation in AWGN")
plt.tight_layout()
plt.show()

../../_images/a5be79c9cc2ca103234c35416d9d2a12a0f89eb82000110001a1fff534093269.png

Last update: Dec 09, 2023