Putting information on a wave
A voice is a signal from about 100 Hz to a few kilohertz. You cannot radiate it directly: a half-wave antenna at 3 kHz would be 50 km long, and if every radio station transmitted its audio as it is, they would all occupy the same few kilohertz and drown each other out. The solution, used by every radio system since the early twentieth century, is modulation: take a high-frequency sine wave, the carrier, and vary one of its properties in step with the message. The carrier's frequency is chosen for convenient antennas (antennas and radio links), the propagation the service needs, and a slot of spectrum that no neighbour is using.
There are only three things one can change about a sine wave: its amplitude, its frequency and its phase. This lesson starts with the analog versions, AM and FM, which are still on the air, and moves to digital modulation, where the message is a stream of bits and the questions become: how many bits per second fit in a given bandwidth, and how many of them arrive wrong? It ends with OFDM, the scheme behind Wi-Fi, 4G, 5G, digital television and DSL.
Two knobs on every carrier: I and Q
A carrier at frequency modulated in amplitude and phase can always be written as
where is the in-phase component and the quadrature component. Equivalently, with the complex envelope . This is the phasor of AC circuits, except that now it is allowed to move slowly: the carrier spins the phasor at , and the message steers it.
The practical consequence is enormous. A modulator does not need to know anything about AM, FM or QAM: it takes two baseband signals, and , multiplies them by a cosine and a sine of the carrier and adds them. The direct-conversion receiver of the last lesson does the reverse and hands and to a processor. Every modulation scheme is then just a choice of path for the point in the complex plane, and can be generated and decoded in software.
Analog modulation
Definition— amplitude modulation (AM)
With a message scaled so that and a modulation index , an AM signal is . Its envelope follows the message.
Definition— frequency and phase modulation (FM and PM)
In FM, the instantaneous frequency is , where is the peak deviation: . In PM, the phase itself follows the message: . For a sinusoidal message of frequency , the FM modulation index is .
FM and PM are two views of one thing: FM is PM of the integral of the message. Both are called angle modulation, and both have a constant envelope, which lets the transmitter use an efficient amplifier running flat out, and makes the signal immune to amplitude disturbances.
Spectra of AM and FM, and Carson's rule
The spectrum shows what each scheme costs in bandwidth. For a single message tone, , AM gives
a carrier and two sidebands, so AM occupies twice the message bandwidth. FM is less tidy. The tone produces lines at for every integer , with amplitudes given by Bessel functions ; in principle the spectrum is infinite, but the lines die out quickly once exceeds . That observation is Carson's rule: about 98 % of an FM signal's power lies within
The program builds both signals, measures their spectra with the FFT of sampling and the FFT, compares the FM lines with Bessel functions, and checks Carson's rule.
import numpy as np
fs, T = 200_000, 0.1 # sample rate (Hz) and duration (s): 0.1 s gives 10 Hz bins
t = np.arange(int(fs * T)) / fs
fc, fm = 20_000, 1_000 # carrier and message (a single tone) frequencies
message = np.cos(2 * np.pi * fm * t)
def spectrum_lines(s, label, threshold=0.01):
"""Print the amplitude of every spectral line above the threshold (single-sided)."""
amp = 2 * np.abs(np.fft.rfft(s)) / len(s)
freqs = np.fft.rfftfreq(len(s), 1 / fs)
lines = [(f, a) for f, a in zip(freqs, amp) if a > threshold]
print(label, " ".join(f"{f / 1e3:.0f}k:{a:.3f}" for f, a in lines))
return freqs, amp
# AM with modulation index m = 0.5
m = 0.5
am = (1 + m * message) * np.cos(2 * np.pi * fc * t)
spectrum_lines(am, "AM lines (kHz:amplitude):")
print(f"fraction of AM power in the sidebands: {m**2 / (2 + m**2):.3f}")
# FM with peak deviation 5 kHz, so beta = 5
dev = 5_000
beta = dev / fm
phase = 2 * np.pi * dev * np.cumsum(message) / fs # integral of the instantaneous frequency
fmsig = np.cos(2 * np.pi * fc * t + phase)
freqs, amp = spectrum_lines(fmsig, "FM lines (kHz:amplitude):", threshold=0.05)
def bessel_j(n, x, steps=20000): # J_n(x) = (1/pi) * integral of cos(n tau - x sin tau)
tau = (np.arange(steps) + 0.5) * np.pi / steps
return np.mean(np.cos(n * tau - x * np.sin(tau)))
print("Bessel |J_n(5)| for n = 0..8:", " ".join(f"{abs(bessel_j(n, beta)):.3f}" for n in range(9)))
power = amp**2 / 2
order = np.argsort(np.abs(freqs - fc)) # widen a band around fc until it holds 98 %
inside = np.cumsum(power[order]) / power.sum()
bw98 = 2 * np.abs(freqs[order][np.searchsorted(inside, 0.98)] - fc)
print(f"measured 98 % bandwidth: {bw98 / 1e3:.0f} kHz; Carson's rule 2(df + fm): {2 * (dev + fm) / 1e3:.0f} kHz")AM with shows the carrier at 20 kHz and two sidebands of amplitude , and only 11 % of the transmitted power is in the sidebands, which are the only part carrying the message. That waste is the price of a receiver as simple as a diode and a capacitor following the envelope, and it is why AM broadcasting is inefficient and why variants that suppress the carrier (DSB-SC) or one sideband as well (SSB, used by aviation and amateur HF radio) exist.
FM with shows lines 1 kHz apart whose heights match exactly; the lines at kHz almost vanish because happens to be small, and even the carrier line has shrunk to 0.178, because in FM the total power is fixed and the modulation redistributes it. The measured 98 % bandwidth is 12 kHz, as Carson's rule predicts. Broadcast FM uses kHz and audio up to 15 kHz, so Carson gives 180 kHz, which is why FM stations are spaced 200 kHz (or in some regions 100 kHz, with geographical separation) apart.
FM spends bandwidth to buy quality: above a threshold signal-to-noise ratio, widening the deviation improves the output SNR roughly as . Below the threshold, the improvement collapses and the receiver output turns to crackle. That trade of bandwidth for noise immunity is our first glimpse of Shannon's theorem in information theory.
Digital modulation and constellations
In digital modulation, time is divided into symbol periods of length , and in each one the transmitter sends one of possible waveforms, carrying bits. The symbol rate is (in baud) and the bit rate . Each symbol is a point in the complex plane, and the set of points is the constellation.
- ASK (amplitude-shift keying) uses different amplitudes; its simplest form, on–off keying, is how infrared remote controls and many cheap 433 MHz sensors send bits.
- FSK (frequency-shift keying) uses different frequencies. It has a constant envelope, so it suits cheap, efficient transmitters: Bluetooth Low Energy uses a filtered form, Gaussian FSK.
- PSK (phase-shift keying) uses phases at a constant amplitude: BPSK has two ( and ), QPSK four, 8-PSK eight.
- QAM (quadrature amplitude modulation) uses a grid of points in both and : 16-QAM carries 4 bits per symbol, 256-QAM 8, and Wi-Fi 7 goes up to 4096-QAM, 12 bits per symbol.
Denser constellations carry more bits per symbol, but at the same average power their points are closer together, so less noise is needed to push a received point across a decision boundary. Every scheme is therefore a trade between spectral efficiency (bits per second per hertz) and power efficiency (the energy per bit needed for a target error rate). The natural measure of the second is , the energy per bit divided by the noise power spectral density; it is related to the signal-to-noise ratio in a bandwidth by .
Theorem— Bit error rate of BPSK
BPSK sends in additive white Gaussian noise of power spectral density . With a matched filter and a decision at zero, the probability of a bit error is
where is the probability that a standard normal variable exceeds .
Proof
After the matched filter (which correlates the received signal with the pulse shape), the decision variable is , where is Gaussian with mean zero and variance . If was sent, an error occurs when , which has probability ; by symmetry the same holds for . The identity gives the second form.
∎
QPSK is two BPSK signals, on and on , which do not disturb each other (they are orthogonal), so with Gray coding its bit error rate is the same function of : twice the bits in the same bandwidth for no extra energy per bit. Let us check both claims by simulation, with two million bits per point and a fixed random seed.
import math
import numpy as np
rng = np.random.default_rng(2026)
n_bits = 2_000_000
print("Eb/N0 BPSK simulated QPSK simulated theory Q(sqrt(2 Eb/N0))")
for ebn0_db in range(0, 10):
ebn0 = 10 ** (ebn0_db / 10)
bits = rng.integers(0, 2, n_bits)
# BPSK: one bit per symbol, symbol energy Eb = 1, noise variance N0/2 per real dimension
x = 1.0 - 2.0 * bits # 0 -> +1, 1 -> -1
y = x + rng.normal(0, math.sqrt(1 / (2 * ebn0)), n_bits)
ber_bpsk = np.mean((y < 0) != (bits == 1))
# QPSK: two bits per symbol (I and Q), symbol energy 2 Eb, Gray-coded
i_bits, q_bits = bits[0::2], bits[1::2]
s = (1.0 - 2.0 * i_bits) + 1j * (1.0 - 2.0 * q_bits)
noise = rng.normal(0, math.sqrt(1 / (2 * ebn0)), (2, len(s)))
r = s + noise[0] + 1j * noise[1]
errors = np.sum((r.real < 0) != (i_bits == 1)) + np.sum((r.imag < 0) != (q_bits == 1))
ber_qpsk = errors / n_bits
theory = 0.5 * math.erfc(math.sqrt(ebn0))
print(f"{ebn0_db:3d} dB {ber_bpsk:14.2e} {ber_qpsk:14.2e} {theory:14.2e}")
for target in (1e-3, 1e-6): # Eb/N0 needed for a target BER
lo, hi = 0.0, 20.0
for _ in range(60):
mid = (lo + hi) / 2
lo, hi = (mid, hi) if 0.5 * math.erfc(math.sqrt(10 ** (mid / 10))) > target else (lo, mid)
print(f"BER {target:.0e} needs Eb/N0 = {mid:.1f} dB")The simulated points follow the theory closely down to , where only about 60 errors are counted and the statistics start to wobble, and BPSK and QPSK are indistinguishable. Reading the last lines: a link that must deliver one error in a million bits needs dB with BPSK.
Pulse shaping and inter-symbol interference
So far each symbol was an instant. In reality each symbol is sent as a pulse , and the transmitted baseband signal is , where are the constellation points. The pulse shape decides two things: how much spectrum the signal occupies, and whether the symbols interfere with each other.
Rectangular pulses are the obvious choice and the worst for spectrum: their spectrum is a sinc, in power, whose tails decay only as and splash power into neighbouring channels. Making the pulses smoother narrows the spectrum but stretches them in time, and then each pulse overlaps its neighbours: inter-symbol interference (ISI). A channel that filters the signal (a long cable, a bandwidth-limited amplifier) does the same.
Theorem— Nyquist criterion for zero ISI
A pulse with causes no inter-symbol interference at the sampling instants, for every integer , if and only if its spectrum satisfies for all .
The condition says that the copies of the pulse's spectrum, shifted by multiples of the symbol rate, add up to a constant. (It is the sampling theorem applied to the pulse: sampling at gives a single impulse exactly when the aliased spectrum is flat.) The narrowest pulse that satisfies it is the sinc, with a rectangular spectrum of width : the absolute minimum bandwidth, but with tails so long that a small timing error causes a lot of ISI. The raised-cosine pulses fix this with a gentle cosine roll-off in the spectrum, controlled by a roll-off factor between 0 and 1. They occupy a baseband bandwidth of , so a passband signal at symbols per second needs hertz. In practice the shaping is split equally between transmitter and receiver as two root-raised-cosine filters, which together give a raised cosine and make the receiver filter the matched filter.
The program sends 4000 random BPSK symbols with four pulse shapes, measures the eye opening (the worst-case sample at the symbol instants, as a fraction of the ideal 1; 1 is perfect and 0 means a wrong decision is possible without any noise), and computes the 99 % occupied bandwidth of each pulse's spectrum.
import numpy as np
rng = np.random.default_rng(7)
sps = 16 # samples per symbol
symbols = rng.choice([-1.0, 1.0], 4000)
def raised_cosine(alpha, span=8):
"""Raised-cosine pulse sampled at sps per symbol, truncated to +-span symbols, peak 1."""
t = np.arange(-span * sps, span * sps + 1) / sps # time in symbol periods
with np.errstate(divide="ignore", invalid="ignore"):
p = np.sinc(t) * np.cos(np.pi * alpha * t) / (1 - (2 * alpha * t) ** 2)
p[np.abs(np.abs(2 * alpha * t) - 1) < 1e-9] = np.pi / 4 * np.sinc(1 / (2 * alpha))
return p
def rc_lowpass(x, tau): # first-order RC filter, time constant in symbols
a = np.exp(-1 / (tau * sps))
y, acc = np.empty_like(x), 0.0
for i, v in enumerate(x):
acc = a * acc + (1 - a) * v
y[i] = acc
return y
def transmit(pulse):
up = np.zeros(len(symbols) * sps)
up[::sps] = symbols
return np.convolve(up, pulse)
def eye(wave, first_peak, offset=0):
"""Smallest correct-sign sample at the symbol instants: 1 = wide open, 0 or less = closed."""
at = first_peak + offset + sps * np.arange(100, len(symbols) - 100)
return (wave[at] * symbols[100:len(symbols) - 100]).min()
def occupied_bandwidth(power, f_max=500.0, df=1e-3):
"""Frequency (in units of the symbol rate) below which 99 % of the power lies."""
f = np.arange(0, f_max, df) + df / 2
p = power(f)
return f[np.searchsorted(np.cumsum(p) / p.sum(), 0.99)]
def rc_spectrum(alpha):
def power(f):
f1, f2 = (1 - alpha) / 2, (1 + alpha) / 2
roll = 0.5 * (1 + np.cos(np.pi / alpha * (f - f1)))
return np.where(f <= f1, 1.0, np.where(f <= f2, roll, 0.0)) ** 2
return power
rect = np.ones(sps)
rc = raised_cosine(0.35)
rows = [
("rectangular pulses", eye(transmit(rect), sps // 2),
lambda f: np.sinc(f) ** 2),
("rectangular, then RC low-pass", eye(rc_lowpass(transmit(rect), 0.5), sps - 1),
lambda f: np.sinc(f) ** 2 / (1 + (2 * np.pi * 0.5 * f) ** 2)),
("raised cosine, alpha = 0.35", eye(transmit(rc), 8 * sps), rc_spectrum(0.35)),
("raised cosine, 1/4 symbol late", eye(transmit(rc), 8 * sps, offset=sps // 4), rc_spectrum(0.35)),
]
print(f"{'pulse':32}{'eye opening':>12}{'99 % bandwidth':>18}")
for name, opening, power in rows:
print(f"{name:32}{opening:12.3f}{occupied_bandwidth(power):12.2f} x Rs")Rectangular pulses have a perfect eye but spread 99 % of their power over almost ten times the symbol rate. Filtering them with a simple RC low-pass narrows the spectrum but closes the eye by 27 %: ISI. The raised cosine with has both a perfect eye and a 99 % bandwidth of only half the symbol rate. But it relies on accurate timing: sampled a quarter of a symbol late, its eye shrinks to 0.26. That is why every receiver includes a timing-recovery loop, and why engineers look at eye diagrams, all the symbol periods of a signal overlaid on an oscilloscope, to judge a link at a glance.
OFDM: many slow carriers instead of one fast one
Radio waves reach a receiver by many paths, bouncing off buildings, hills and walls. Indoors the echoes are spread over tens to hundreds of nanoseconds, outdoors over microseconds. A single carrier sending 20 million symbols per second has symbols 50 ns long, so an echo 1 µs late smears each symbol over twenty of its successors, and undoing that needs a long, power-hungry equaliser.
Orthogonal frequency-division multiplexing (OFDM) turns the problem around. Instead of one carrier at 20 Msymbol/s, use (or 1024, or 4096) subcarriers, each at of the rate, so each symbol is long compared with the echoes. Space the subcarriers exactly apart, where is the symbol duration, so that they are orthogonal: their spectra overlap, but over one symbol each subcarrier's sinusoid integrates to zero against every other. Then the transmitter's job, putting a constellation point on each subcarrier , is exactly an inverse DFT,
computed with an IFFT, and the receiver's job is an FFT.
One more trick makes it work over a multipath channel. Before transmitting each block of samples, copy its last samples to the front: the cyclic prefix.
Theorem— The cyclic prefix diagonalises the channel
Let the channel be a filter (echoes up to samples late) and let each OFDM symbol carry a cyclic prefix of at least samples. After the receiver discards the prefix and takes the -point DFT, subcarrier receives (plus noise), where is the DFT of the channel at subcarrier .
Proof
The channel performs a linear convolution. Because the prefix repeats the end of the block, the samples the receiver keeps are exactly what a circular convolution of the block with would give: each echo that reaches back past the start of the block finds a copy of the block's own end there, rather than the previous symbol. And the DFT turns circular convolution into multiplication, (the convolution theorem of Fourier analysis, in its discrete form).
∎
So equalisation, the expensive part of a single-carrier receiver, becomes one complex division per subcarrier. The program sends 50 OFDM symbols of 64 QPSK subcarriers through a channel with echoes up to 9 samples late, at a signal-to-noise ratio of 30 dB, and decodes them with cyclic prefixes of 16, 4 and 0 samples.
import numpy as np
rng = np.random.default_rng(11)
N, CP, n_sym = 64, 16, 50 # subcarriers, cyclic-prefix length, OFDM symbols
qpsk = np.array([1 + 1j, -1 + 1j, -1 - 1j, 1 - 1j]) / np.sqrt(2)
data = qpsk[rng.integers(0, 4, (n_sym, N))] # one QPSK symbol per subcarrier per OFDM symbol
h = np.array([0.8, 0, 0, 0.45j, 0, 0.3, 0, 0, 0, -0.15]) # multipath: echoes up to 9 samples late
H = np.fft.fft(h, N) # the channel's gain on each subcarrier
def run(cp):
tx = np.fft.ifft(data, axis=1) # each row: one OFDM symbol in time
tx = np.hstack([tx[:, N - cp:], tx]).ravel() # copy the last cp samples to the front
rx = np.convolve(tx, h)[: len(tx)]
noise_power = np.mean(np.abs(rx) ** 2) / 10 ** (30 / 10) # 30 dB signal-to-noise ratio
rx = rx + np.sqrt(noise_power / 2) * (rng.normal(size=rx.shape) + 1j * rng.normal(size=rx.shape))
rx = rx.reshape(n_sym, N + cp)[:, cp:] # drop the prefix
est = np.fft.fft(rx, axis=1) / H # FFT, then one division per subcarrier
decided = qpsk[np.argmin(np.abs(est[..., None] - qpsk), axis=-1)]
evm = np.sqrt(np.mean(np.abs(est - data) ** 2))
return np.sum(decided != data), evm
print(f"channel gains |H_k| range from {np.abs(H).min():.2f} to {np.abs(H).max():.2f} across subcarriers")
for cp in (16, 4, 0):
errors, evm = run(cp)
print(f"cyclic prefix {cp:2d} samples: {errors:4d} symbol errors out of {n_sym * N}, "
f"EVM {100 * evm:5.1f} %")
print(f"overhead of a 16-sample prefix: {16 / (N + 16):.0%} of the air time")With a 16-sample prefix, longer than the channel's 9-sample spread, all 3200 symbols arrive correctly, using nothing but an FFT and one division per subcarrier. With a 4-sample prefix, the end of each echo leaks into the next symbol and errors appear; with none, the constellation is badly smeared. The prefix costs 20 % of the air time here; real systems size it to the expected delay spread, typically 7 % (LTE's normal prefix) to 25 %.
OFDM has one notable cost: adding many independent subcarriers gives a signal that looks like Gaussian noise, with occasional peaks far above its average power (a high peak-to-average power ratio). Power amplifiers must be backed off to avoid clipping those peaks, which wastes energy. That is why LTE and 5G phones may transmit a "DFT-spread" variant of OFDM on the uplink, with lower peaks, while base stations, with more power to spare, use plain OFDM.
The professional view
- Who uses what. Wi-Fi has used OFDM since 802.11a (1999), and Wi-Fi 7 uses it with constellations from BPSK to 4096-QAM (IEEE 802.11); LTE and 5G NR use OFDM with flexible subcarrier spacing (3GPP); digital television (DVB-T2, ISDB-T, ATSC 3.0), digital radio (DAB) and DSL broadband use it too. Constant-envelope schemes survive where power efficiency rules: Bluetooth Low Energy, many satellite links, and FM broadcasting, which is still on the air in most countries.
- Adaptive modulation and coding. Modern links measure the channel continuously and choose the modulation and code rate for each transmission, sometimes for each group of subcarriers: 1024-QAM near the access point, QPSK at the edge of coverage. The table of choices is the "MCS index" in Wi-Fi and cellular specifications.
- Measurement. Transmitters are tested for error vector magnitude (EVM), the RMS distance between received and ideal constellation points, against limits in the standards (for dense constellations, a few per cent or less), and for spectral masks that bound the power leaking into neighbouring channels. Vector signal analysers do this, and open-source tools such as GNU Radio can too.
A short history
Speech was first sent by amplitude modulation in the first decade of the twentieth century, by Reginald Fessenden among others, and AM broadcasting spread worldwide in the 1920s. Edwin Armstrong patented wideband FM in 1933 to defeat static, and FM broadcasting followed. Harry Nyquist's 1928 paper set the limit on how fast pulses can be sent through a channel without interfering. In 1966 Robert Chang at Bell Labs described orthogonal multicarrier transmission; in 1971 Stephen Weinstein and Paul Ebert showed that the DFT could generate it, and the cyclic prefix was proposed by Abraham Peled and Antonio Ruiz in 1980. OFDM waited until integrated circuits could run FFTs cheaply, and then, in the 1990s and 2000s, took over digital broadcasting, DSL, Wi-Fi and finally mobile networks.
Common misconceptions
Misconception
"FM is immune to noise." FM is immune to amplitude disturbances and, above its threshold, trades bandwidth for a large improvement in output SNR. Below the threshold (a weak, distant station) it degrades abruptly, more abruptly than AM.
Misconception
"A signal at 100 Mbit/s needs 100 MHz of bandwidth." Bandwidth is set by the symbol rate and the pulse shape: in passband. With 1024-QAM (10 bits per symbol) and , 100 Mbit/s needs 10 Msymbol/s and 12.5 MHz, before coding overhead.
Misconception
"OFDM subcarriers are separated by guard bands so they do not overlap." Their spectra overlap heavily; each subcarrier's sinc-shaped spectrum has its peak exactly at the other subcarriers' zeros. Orthogonality, not separation, keeps them apart, which is why OFDM is so spectrally efficient, and why it is sensitive to frequency offsets that break the orthogonality.
Misconception
"Denser constellations are always better." At a given , 256-QAM makes far more errors than QPSK. Dense constellations pay off only when the SNR is high, which is why links adapt and why the fastest Wi-Fi rates are available only close to the access point.
Exercises
1. Modulation
Warm-upHumanA broadcast FM station uses a peak deviation of 75 kHz and audio up to 15 kHz. Estimate its bandwidth with Carson's rule, in kHz.
2. Modulation
Warm-upHumanA microwave link sends 5 million symbols per second using 256-QAM and an error-correcting code of rate 3/4 (three information bits for every four bits sent). What is its information rate, in Mbit/s?
3. Modulation
CoreHumanAn AM transmitter is modulated by a single tone at the maximum index . What percentage of the transmitted power is in the two sidebands (the part that carries the message)? Give the nearest whole number.
4. Modulation
CoreHumanA satellite modem sends 20 Msymbol/s with root-raised-cosine filtering of roll-off α = 0.25. What bandwidth does the modulated (passband) signal occupy, in MHz?
5. Modulation
CoreHumanWhich statements about OFDM are true? Select all that apply.
6. Modulation
CoreComputationalWrite two functions:
bpsk_ber_theory(ebn0_db), returning for given in dB;bpsk_ber_sim(ebn0_db, n_bits, seed=0), which drawsn_bitsrandom bits withnp.random.default_rng(seed), maps 0 to +1 and 1 to −1 (so ), adds Gaussian noise of variance , decides by the sign, and returns the fraction of wrong bits.
The tests compare your simulation with your theory at 0, 3 and 6 dB.
7. Modulation
StretchComputationalBuild the two halves of an OFDM link:
ofdm_tx(X, cp):Xhas one row of constellation points per OFDM symbol. Take each row's inverse FFT, put a copy of its lastcpsamples in front, and return all symbols concatenated into one 1-D array.ofdm_rx(y, N, cp, h): split the received stream into blocks ofcpsamples, drop each prefix, take the FFT of each block and divide by the channel's frequency responsenp.fft.fft(h, N). Return an array of the same shape asX.
The tests pass QPSK symbols through a channel with echoes up to 5 samples late and an 8-sample prefix, with no noise, and expect exact recovery.
Further reading and resources
- Certain Topics in Telegraph Transmission Theory · Harry Nyquist · 1928Transactions of the AIEE, vol. 47. Where the condition for transmitting pulses without inter-symbol interference comes from.
- Synthesis of Band-Limited Orthogonal Signals for Multichannel Data Transmission · Robert W. Chang · 1966Bell System Technical Journal, vol. 45. The founding paper of orthogonal frequency-division multiplexing.
- Data Transmission by Frequency-Division Multiplexing Using the Discrete Fourier Transform · S. B. Weinstein and P. M. Ebert · 1971IEEE Transactions on Communication Technology. The idea of generating OFDM with the DFT, and so with the FFT.
- IEEE 802.11 Wireless LAN Working GroupThe committee that writes the Wi-Fi standards, which have used OFDM since 802.11a.
- 3GPPThe partnership that writes the LTE and 5G NR specifications.
- GNU Radio tutorialsHands-on modulation and demodulation in software, with simulated or real radio hardware.