Skip to content

Chapter 20 · Sending bits

Constellations & 64-QAM

Two chapters ago we planted a seed: every symbol we'd sent so far answered a single yes-or-no question. One little slice of wave, one timid bit. Then we spent a chapter making bits safe. Time to collect. This is the summit of the book, the idea at the heart of Wi-Fi and your phone, and you have already earned every piece of it.

Four starts instead of two#

Start with , the machine's favorite. We used two phases: upright and flipped, one bit per symbol. But why stop at two? Where a wave begins is an angle around a circle (the very circle from chapter 2), and a circle has room for more than two positions. Pick four phases, a quarter-turn apart, and each symbol now has four possible answers instead of two. Four answers is exactly two yes-or-nos at once: the first bit picks a half, the second picks within it. Two bits per symbol, for free. Engineers call it QPSK, and it's the workhorse of satellites and deep-space probes.

And here a better picture takes over. Waves drawn as wiggles have served us for eighteen chapters, but four phases already look samey as wiggles, and what's coming next would be hopeless. So stop drawing the wave. Draw a map of the allowed symbols instead: each one plotted as a star, where the distance from the center is its amplitude (its loudness) and the direction around is its phase. Radio people call this map a . Below is QPSK's: four stars on one circle, same loudness, four different starts. (Yes, starts. One letter away from stars, and not a typo: a phase is where a wave starts, and on the map every start becomes a star. The two words will keep close company for the rest of the chapter.) If you wandered through the spinning arrow appendix, you'll recognize every star as the tip of one arrow.

00011110

phase 45° → bits 00 · one symbol, two bits

QPSK: four allowed symbols, all equally loud, a quarter-turn of phase apart. Tap a star and watch the wave it stands for. Two bits ride on every slice, and neighboring stars differ by only one bit, so a small mistake costs as little as possible.

Both knobs at once#

Four phases carry two bits. Eight would carry three. But crowding more and more stars onto one circle squeezes them together fast, and we've been ignoring a whole second knob. Amplitude! Vary the loudness and the phase together and the stars no longer have to share a single circle; they can spread out across the whole map in a tidy grid. That combination is , quadrature amplitude modulation, the name we promised back in chapter 7. The mouthful is friendlier than it looks: amplitude modulation you already know, and quadrature is just an old word for a quarter-turn, since the map's two directions, across and up, sit a quarter-turn of phase apart.

A four-by-four grid gives sixteen stars: sixteen answers, which is four bits per symbol, 16-QAM. An eight-by-eight grid gives sixty-four stars: six bits in every single slice of wave, 64-QAM, the number in this chapter's title. Your Wi-Fi, in a good moment, speaks 64-QAM or richer; recent routers reach for grids of 1,024 stars and beyond. (And QPSK fits the family portrait too: tilt your head and its four stars are just the tiniest grid, two by two.)

QPSK (4-QAM) · 4 stars · 2 bits per symbol

16-QAM · 16 stars · 4 bits per symbol

64-QAM · 64 stars · 6 bits per symbol

64-QAM star · height 0.59 · start 59° · still one plain wave

The family, drawn to the same scale: 4, 16, and 64 stars carrying 2, 4, and 6 bits per symbol. Tap any star, in any grid, and the strip below draws the wave it stands for: even deep in 64-QAM, every star is still just a plain wave with a chosen height and a chosen start. And the price of packing in more bits is right there to see: the stars stand ever closer together.

Noise blurs the stars#

So why not a million stars? Look at that 64-QAM panel again and you can almost smell the trouble: the stars stand shoulder to shoulder. A transmitted symbol is a single perfect point on the map, but the receiver never sees it perfectly, because the channel's hiss nudges every measurement a little. Each received symbol lands near its star, not on it. The receiver copes by ruling the map into boxes, one per star, and sorting each arrival into whichever box it lands in: those are the faint grid lines below, its decision boundaries.

Now everything hangs on one comparison: is the fuzz around each star smaller than the box it lives in? Turn the noise up on QPSK and its four fat boxes barely notice; the fuzz balls swell and swell and still land home. Turn it up on 64-QAM and the tiny boxes flood almost immediately, with symbols spilling across the lines and coming out as the wrong six bits. Watch the amber dots and the tally as you switch grids.

Noise 30%

4 bits per symbol · symbols landing in the wrong box: 0.0%

Thousands of received symbols raining onto the map, each one nudged off its star by noise. Pick a grid, turn the storm up, and watch the spill: amber dots are symbols decoded wrongly. 64-QAM demands a quiet channel; QPSK shrugs off weather that would drown it.

The negotiation#

Here is the payoff, and it's happening in your house right now. Since no single grid is best everywhere, modern radios don't commit to one: they negotiate. Your laptop and router constantly measure how clean the channel between them is and agree on the densest constellation the fuzz allows. Sit beside the router and they chat in 64-QAM or better, six-plus bits per symbol. Wander to the garden and the signal fades with distance and gets gnawed by walls, the fuzz grows relative to it, and the pair quietly steps down: 16-QAM, then sturdy old QPSK. The bars drop, the link slows, but it does not break. That is why Wi-Fi in the far bedroom still works and merely crawls.

And notice how neatly the whole book folds into this one picture. The noise floor sets the size of the fuzz. Fading sets the strength of the signal, which is the size of the map itself. Their ratio decides how finely the map can be ruled into boxes, and so how many bits each little slice of wave can carry. Signal over noise: that single fraction is the speed of your internet.

So six bits now ride on every slice of wave, and the noise decides how many more the map can hold. Which leaves exactly one place left to hunt for speed: if each symbol is full, deal more symbols. Slice the wave thinner, flick between stars millions of times a second, and the bits should simply pour. It seems too easy, and it is. Try it indoors and something old and stubborn pushes back: not the noise, not the distance, but the room itself. That showdown is the next chapter.