Ferkans — Interactive Telecom Tutor

The OFDM Receiver: Undo Everything the Channel Did

The receiver reverses the transmitter operations and corrects for the channel: remove CP, apply FFT, estimate the channel, equalize each subcarrier, and demap symbols back to bits.

Definition:
OFDM Receiver Chain

The receiver performs:

CP removal: discard the first $N_{\text{CP}}$ samples
FFT: $Y[k] = \frac{1}{\sqrt{N}}\sum_{n=0}^{N-1} y[n]\,e^{-j2\pi kn/N}$
Channel estimation: estimate $\hat{H}[k]$ from pilot subcarriers
Equalization: $\hat{X}[k] = Y[k] / \hat{H}[k]$
Demapping: convert equalized symbols back to bits

def ofdm_receiver(rx_block, N_fft, N_cp, H_est):
    y = rx_block[N_cp:]          # CP removal
    Y = np.fft.fft(y) / np.sqrt(N_fft)  # FFT
    X_hat = Y / H_est            # ZF equalization
    return X_hat

Definition:
Pilot-Based Channel Estimation

At pilot subcarrier positions $\mathcal{P}$ , the channel is estimated as:

$\hat{H}[k] = \frac{Y[k]}{X_p[k]}, \quad k \in \mathcal{P}$

where $X_p[k]$ is the known pilot symbol. The channel at data subcarrier positions is obtained by interpolation (linear, spline, or DFT-based).

def estimate_channel(Y, pilot_idx, pilot_symbols, N_fft):
    H_pilot = Y[pilot_idx] / pilot_symbols
    # Linear interpolation to all subcarriers
    H_est = np.interp(np.arange(N_fft), pilot_idx, np.abs(H_pilot)) \
          * np.exp(1j * np.interp(np.arange(N_fft), pilot_idx, np.angle(H_pilot)))
    return H_est

Averaging pilots across multiple OFDM symbols (in time) improves estimation accuracy, especially in low-SNR conditions.

Definition:
One-Tap Equalization: ZF and MMSE

Zero-Forcing (ZF) equalization divides by the channel:

$\hat{X}_{\text{ZF}}[k] = \frac{Y[k]}{H[k]}$

MMSE equalization balances noise enhancement:

$\hat{X}_{\text{MMSE}}[k] = \frac{H^*[k]}{|H[k]|^2 + 1/\text{SNR}} \cdot Y[k]$

MMSE is better at low SNR where ZF amplifies noise on weak subcarriers.

def zf_equalize(Y, H):
    return Y / H

def mmse_equalize(Y, H, snr):
    return H.conj() * Y / (np.abs(H)**2 + 1/snr)

Theorem: Per-Subcarrier SNR After Equalization

After ZF equalization, the SNR on subcarrier $k$ is:

$\text{SNR}_k = |H[k]|^2 \cdot \frac{E_s}{N_0}$

Deep fades ( $|H[k]| \ll 1$ ) cause very low SNR on those subcarriers. With MMSE equalization, the effective SNR is:

$\text{SINR}_k = \frac{|H[k]|^2 \cdot \text{SNR}}{|H[k]|^2 \cdot \text{SNR} + 1}$

Each subcarrier sees a flat-fading channel. ZF perfectly inverts the channel but amplifies noise; MMSE accepts some residual interference to avoid noise amplification.

Theorem: Pilot-Based Channel Estimation Error

For LS (least-squares) pilot estimation with $N_p$ pilots and unit-power pilot symbols, the MSE per pilot is:

$\text{MSE}_{\text{LS}} = \frac{N_0}{E_p} = \frac{1}{\text{SNR}_p}$

MMSE estimation exploits channel statistics (delay profile) and achieves lower MSE, approaching the CRLB.

More pilots and higher pilot power improve estimation. But more pilots means less room for data, creating an overhead trade-off.

Example: Complete OFDM Transceiver in NumPy

Build a complete OFDM system: transmitter, multipath channel, and receiver with pilot-based channel estimation.

Solution

System parameters

N_fft = 64
N_cp = 16
M = 16  # 16-QAM
pilot_idx = np.arange(0, N_fft, 8)  # every 8th subcarrier
null_idx = [0, 32]  # DC and Nyquist

Transmit, channel, receive

# Channel: 3-tap
h = np.array([1, 0.5+0.3j, 0.2-0.1j])
h /= np.sqrt(np.sum(np.abs(h)**2))
H = np.fft.fft(h, N_fft)

# TX -> Channel -> RX
x_cp = add_cp(np.fft.ifft(X)*np.sqrt(N_fft), N_cp)
y = np.convolve(x_cp, h)[:len(x_cp)]
y += sigma * (np.random.randn(len(y)) + 1j*np.random.randn(len(y)))
Y = np.fft.fft(remove_cp(y, N_cp)) / np.sqrt(N_fft)
X_hat = Y / H  # ZF equalization

OFDM Receiver Visualization

Visualize the complete OFDM receiver: channel estimation, equalization, and the effect on the received constellation.

Parameters

Quick Check

When does MMSE equalization significantly outperform ZF in OFDM?

At high SNR

At low SNR with deep fading subcarriers

When there is no multipath

When the FFT size is large

Correction:

At low SNR with deep fading subcarriers

Correct: ZF amplifies noise on deeply faded subcarriers; MMSE avoids this.

Common Mistake: CP Shorter Than Channel Delay

Mistake:

Setting $N_{\text{CP}} < L - 1$ where $L$ is the channel length, causing ISI that breaks the circular convolution property.

Correction:

Always ensure $N_{\text{CP}} \ge L - 1$ . In practice, use $N_{\text{CP}} \ge \lceil \tau_{\max} \cdot f_s \rceil$ where $\tau_{\max}$ is the maximum excess delay.

Key Takeaway

The OFDM receiver is elegant: CP removal + FFT + one-tap equalization. Channel estimation from pilots is the key challenge, and MMSE equalization outperforms ZF at low SNR by avoiding noise amplification on faded subcarriers.

Zero-Forcing Equalization

A linear equalization method that inverts the channel: $\hat{X} = Y/H$ . Simple but amplifies noise on deeply faded subcarriers.

MMSE Equalization

Minimum mean-square error equalization that balances channel inversion with noise suppression: $\hat{X} = H^*Y/(|H|^2 + 1/\text{SNR})$ .

OFDM Receiver