From one link to a million strangers
Up to now every rung has quietly assumed a comfortable fiction: one transmitter talking to one receiver over its own private channel. Modulate a carrier, push it through the air, recover the bits at the other end. But step outside and look up. Above any city, thousands of phones, two competing Wi-Fi access points per apartment, a dozen GPS satellites, a passing aircraft transponder and a baby monitor are all radiating into the *same* sky at the *same* instant. Nobody handed them a private channel. They are all fighting over one shared, finite resource — the radio spectrum — and somehow it works.
The reason it works is multiple access: a set of disciplined rules for slicing one channel into many usable pieces. The umbrella technique is multiplexing — combining several independent signals onto a shared medium so a receiver can pull *its* signal back out cleanly. The whole field comes down to a single question with three classic answers: along *what axis* do we divide the resource? You can divide frequency, divide time, or — the subtle one — divide code. Each axis gives a different multiplexing scheme, and modern systems blend all three.
FDM and TDM: slicing frequency, slicing time
The oldest answer is Frequency-Division Multiplexing (FDM): give every user a different narrow band, stacked side by side like lanes on a highway. This is exactly how analogue radio works — your favourite FM station at 99.7 MHz sits in its own 200 kHz lane, and the station at 100.3 MHz lives in another, with empty guard bands between them so their skirts do not collide. A receiver tunes a bandpass filter (and a local oscillator — recall the PLL that locks it precisely) to one lane and ignores the rest. Everyone transmits *all the time*, but each on their own colour of light.
The complementary answer is Time-Division Multiplexing (TDM): give every user the *whole* band, but only for a brief turn. Slice time into repeating frames, hand each user one slot per frame, and round-robin through them fast enough that — buffered at each end — every user perceives a continuous link. This is how the classic 2G GSM cellphone worked: eight callers shared one 200 kHz carrier, each getting a 577 µs burst every 4.6 ms. The catch is that everyone must agree on *when* their slot starts, to the microsecond, so TDM lives or dies by tight synchronisation — a shared clock everyone trusts.
FDM — divide FREQUENCY TDM — divide TIME (everyone all the time, (everyone full band, each in their own band) one at a time) freq freq ^ ^ | [ U4 ]====guard==== | |U1|U2|U3|U4|U1|U2|U3|U4| | [ U3 ] | | full bandwidth used | | [ U2 ] | | by whoever's turn it | | [ U1 ] | | is, right now | +-----------------> time +-----------------------> time share by colour share by taking turns
CDMA: dividing by code, not time or frequency
Now the strange one. Code-Division Multiple Access (CDMA) does something that sounds impossible: every user transmits *at the same time, over the same frequency band* — and a receiver still separates them perfectly. There are no lanes and no turns. Instead, each user is assigned a unique high-speed code — a pseudo-random pattern of +1s and −1s called a chipping sequence — and they multiply their slow data bits by this fast code before transmitting. The trick is that the codes are chosen to be orthogonal: mathematically, two different codes are 'invisible' to each other.
What does 'orthogonal' buy you? The receiver knows the code of the user it wants. It multiplies the jumbled, summed-together airwave by *that one code* and adds up the result over each bit — an operation called correlation. For the wanted user, multiplying their code by itself gives +1 everywhere (a code times itself is all +1s), so their bit accumulates into a big, clear number. For every *other* user, their code multiplied by the wanted code is orthogonal — the +1s and −1s cancel in equal measure and sum to zero. The unwanted signals do not get filtered out; they mathematically *annihilate themselves* in the sum.
Worked example: separating two CDMA users
Let us make the magic concrete with the smallest possible CDMA system: two users, length-4 codes. We will write a +1 bit as +1 and a 0 bit as −1 (this 'bipolar' mapping is what makes the cancellation arithmetic clean — it is just BPSK under the hood). Pick two orthogonal codes:
Codes (orthogonal: their dot product is zero)
Ca = (+1, +1, +1, +1)
Cb = (+1, -1, +1, -1)
Ca . Cb = (+1)(+1)+(+1)(-1)+(+1)(+1)+(+1)(-1) = 1-1+1-1 = 0 <- orthogonal
This bit period, suppose:
User A sends bit +1 -> transmits +1 * Ca = (+1, +1, +1, +1)
User B sends bit -1 -> transmits -1 * Cb = (-1, +1, -1, +1)
The air sums both signals (they overlap completely in time & frequency):
R = (+1, +1, +1, +1)
+ (-1, +1, -1, +1)
= ( 0, 2, 0, 2) <- a garbled mess; neither bit is readable
Receiver A correlates R with Ca, then sums:
R . Ca = (0)(+1)+(2)(+1)+(0)(+1)+(2)(+1) = 0+2+0+2 = +4
Divide by code length 4 -> +1 == User A's bit. CORRECT.
Receiver B correlates R with Cb, then sums:
R . Cb = (0)(+1)+(2)(-1)+(0)(+1)+(2)(-1) = 0-2+0-2 = -4
Divide by 4 -> -1 == User B's bit. CORRECT.Look closely at receiver A's calculation. User B's transmitted vector was buried inside R, yet it contributed exactly zero to A's correlation sum — every +2 it caused was matched by the structure of Ca so it neither helped nor hurt. That is orthogonality doing the entire job. Scale this up: the real IS-95 CDMA standard used 64-chip Walsh codes, giving 64 mutually orthogonal channels, layered on top of an even faster pseudo-random scrambling code that spreads the energy and distinguishes neighbouring cell towers.
Spread spectrum: getting wider on purpose
Everything we have done so far tried to *save* bandwidth. Spread spectrum does the opposite, and it sounds insane: take a signal that needs, say, 10 kHz, and deliberately smear it across 10 MHz — a thousand times wider, at the *same* total power. The energy per hertz drops by that same factor of a thousand, so the signal can actually sink below the noise floor: a spectrum analyser sweeping the band sees nothing but a faint, almost imperceptible rise in the noise. Why would anyone throw away spectral efficiency this lavishly? Because of what you get in return: robustness.
There are two ways to spread. The CDMA example you just worked is Direct-Sequence Spread Spectrum (DSSS): multiply the data by a fast pseudo-random chip code, smearing it across a wide band, then de-spread at the receiver by correlating with the same code. Frequency-Hopping Spread Spectrum (FHSS) spreads differently — it keeps the signal narrow at any instant but makes it *hop* between hundreds of frequencies many times a second, following a pseudo-random pattern that transmitter and receiver both know. To anyone who does not know the hop pattern, the signal is a will-o'-the-wisp, never in the same place twice.
What does spreading actually buy? Three powerful properties, all flowing from processing gain — the ratio of spread bandwidth to data bandwidth. First, jam resistance: a hostile narrowband jammer can blast one frequency with huge power, but when the receiver de-spreads, the jammer's narrow energy gets *spread out* by the same code while your signal collapses back to full strength — the jammer is suppressed by the processing gain (often 20–30 dB). Second, low probability of intercept: hidden below the noise, the signal is hard even to *detect*, let alone decode. Third, coexistence: many spread users (or unrelated systems) overlap in the same band, each one just a small bump in the others' noise floor.
Spread spectrum in the wild: GPS and Wi-Fi
The most beautiful demonstration of DSSS is in your pocket: GPS. A satellite 20,000 km overhead transmits with about the power of a household light bulb, spread by a 1.023 Mchip/s code across roughly 2 MHz. By the time it reaches the ground, the signal arrives 30–40 dB below the thermal noise floor — utterly invisible to a normal radio. Your receiver knows each satellite's unique pseudo-random code and correlates against it; the processing gain (~43 dB) lifts the buried signal out of the noise. Better still, *sliding* the local code in time until the correlation peaks tells the receiver the signal's travel time to nanosecond precision — and that travel time, times the speed of light, is the distance to the satellite. The de-spreading correlation that separates the signal is the very same measurement that locates you.
- Acquire: the receiver slides its local copy of a satellite's code across all possible time shifts (and Doppler-shifted frequencies), watching for a correlation spike — that spike means 'found it, and this is the alignment'.
- Track: a feedback loop (a code-tracking loop alongside a carrier PLL) keeps the local code locked onto the incoming one as the satellite moves and the user walks.
- Measure: the precise code phase yields the pseudo-range to that satellite; do this for four or more satellites and solve for 3-D position plus the receiver's clock error.
Spread spectrum also shaped early Wi-Fi. The original 802.11 and the first popular flavour, 802.11b, used DSSS in the unlicensed 2.4 GHz band — chosen partly *because* spreading lets multiple devices and unrelated gadgets (microwaves, cordless phones, Bluetooth) coexist in a band nobody licenses. The classic 11 Mbit/s 802.11b mode used an 11-chip Barker code, later CCK, to spread each symbol. Spreading bought that crucial early robustness against the messy interference of a band shared by everyone. As demand for raw speed exploded, Wi-Fi migrated to OFDM (802.11a/g and beyond) for higher data rates — but DSSS got it off the ground.