From Waves to Bits: Sampling and Digital Modulation

The bridge nobody sees

Speak into a phone and a thin membrane wobbles, pushing out a voltage that traces the exact shape of your voice — a smooth, continuous curve with no gaps. But the radio leaving the antenna carries no curve at all. It carries bits: a relentless march of 1s and 0s. Somewhere inside that handset sits a bridge that turns the wiggle into bits going out, and bits back into a wiggle coming in. That bridge is the single most important idea in modern communications, and once you see it you can't unsee it — it's the reason a 50-year-old vinyl record sounds worse every time you play it, while a song you've streamed a thousand times sounds identical to the day it was mastered.

In rung 2 we sent voice by gently bending an analog carrier — stretching its amplitude for AM, or nudging its frequency for FM. That's elegant, but it has a fatal flaw we'll meet shortly. This rung is the pivot of the whole track: from here on, everything is digital. So we need to answer two questions in order. First, how do we honestly capture a continuous wave as a finite list of numbers? That's [[sampling|sampling]] and [[quantization|quantization]]. Second, how do we put those numbers — as bits — onto a radio wave we can actually transmit? That's [[ee-digital-modulation|digital modulation]].

Sampling: freezing the wave in time

Imagine filming a spinning bicycle wheel. You don't record every instant — you snap a photo every fraction of a second, and your eye fills in the motion between frames. Sampling does exactly this to a voltage: a circuit reaches out at perfectly even moments, grabs the instantaneous height of the wave, and throws the rest away. The result is a row of numbers spaced by the sampling period Ts. Do it 44,100 times a second (CD audio) and you've reduced an infinitely detailed curve to 44,100 numbers per second — a list a computer can store, copy, and compute on.

But there's a trap, and it's the same trap that makes wagon wheels appear to spin backwards in old movies. If you photograph the wheel too slowly, a fast forward spin can look like a slow backward one — your samples are honest, but they're consistent with the *wrong* motion. In signals this is called [[ee-aliasing|aliasing]], and the cure is the Nyquist–Shannon sampling theorem you met in Signals & Systems: to capture a signal whose highest frequency is fmax, you must sample faster than 2·fmax. Human hearing tops out near 20 kHz, so CD audio samples at 44.1 kHz — comfortably above 40 kHz, with a little headroom for the anti-alias filter to do its work.

Quantization: rounding to a price tag

Sampling fixed the *time* axis — we now have values only at tidy instants. But each captured value is still a real number with endless decimals, and no computer can store endless decimals. [[quantization|Quantization]] snaps each sample to the nearest rung on a fixed ladder of allowed levels, exactly like a shop rounding every price to the nearest cent. With N bits you get 2^N rungs: 8 bits give 256 levels, 16 bits give 65,536. The gap you create by rounding is unavoidable error — quantization noise — and it sets a hard ceiling on quality, measured by the signal-to-noise ratio.

Analog wave        Sample (time grid)      Quantize (level grid)
  ___                  o                        o-> 110
 /   \               o   o                    o   o-> 101
|     |    ==>      o     o      ==>          o     o
 |   |             o       o                o       o-> 011
  \_/            o           o            o           o-> 001
  (smooth)      |---Ts---|                snap each to nearest level

  Each kept value -> nearest of 2^N rungs -> N-bit number
  3-bit ladder shown:  000 001 010 011 100 101 110 111  (8 levels)

There's a beautifully simple rule of thumb every audio and instrumentation engineer carries in their head: each extra bit of quantization buys you about 6 dB of SNR. The full formula for a full-scale sine wave is SNR ≈ 6.02·N + 1.76 dB. So 16-bit CD audio reaches roughly 6.02·16 + 1.76 ≈ 98 dB — meaning the loudest sound is about 80,000 times stronger than the rounding hiss, far beyond what your ears can detect. Modern studio converters use 24 bits not because you can hear the difference, but to leave generous headroom while mixing.

Why digital wins: regeneration beats accumulation

Now to that fatal flaw of analog. Picture photocopying a photocopy of a photocopy. Each pass adds a little smear, and the smears never go away — they pile up until the page is mush. An analog signal travelling down a long cable is exactly this: every kilometre adds a whisper of noise, every amplifier boosts the signal *and* the accumulated noise together, and there is no way to tell the original wiggle from the noise riding on it. After enough hops the voice is buried.

Digital plays a completely different game. A bit is only ever a 1 or a 0, so a receiver doesn't have to reproduce a shape — it only has to decide which of two symbols was sent. As long as the noise is small enough that a 1 still looks more like a 1 than a 0, the receiver outputs a *perfect, brand-new* 1 — every trace of noise erased. This act of cleaning up and re-transmitting is called regeneration, and it's why a chain of digital repeaters can span an ocean with zero cumulative degradation, while an analog chain of the same length would arrive as hiss.

ANALOG repeater chain (noise ACCUMULATES):
  clean ~~~~> +noise ~~~> amp(sig+noise) ~~~> +noise ~~~> amp ... = MUSH

DIGITAL repeater chain (noise is ERASED each hop):
  1 0 1 1 --noisy--> [decide >threshold?] --> 1 0 1 1 (perfect) --noisy--> [decide] --> 1 0 1 1
        ^ as long as noise < half the gap between levels, output is flawless

Stamping bits on a carrier: ASK, FSK, PSK

We have a river of bits; now we must launch them as radio. A sine carrier has exactly three knobs we can twist — its amplitude, its frequency, and its phase — and each gives one family of [[ee-digital-modulation|digital modulation]]. Twist amplitude and you get ASK (amplitude-shift keying): a strong burst for 1, silence (or a weak burst) for 0 — Morse code is its great-grandparent. Twist frequency and you get FSK (frequency-shift keying): one tone for 1, a different tone for 0 — the screech of an old dial-up modem is FSK you can actually hear. Twist phase and you get PSK (phase-shift keying): the carrier's amplitude and frequency stay rock-steady, but it suddenly flips its phase to signal a different bit.

Bit stream:    1     0     1     1

ASK  ampl.   /\/\  ____  /\/\  /\/\     strong = 1, off = 0

FSK  freq.   /\/\  /\/\/ /\/\  /\/\     fast tone = 1, slow tone = 0
             (hi)  (lo)  (hi)  (hi)

PSK  phase   /\/\  \/\/  /\/\  /\/\     phase flips 180 deg on a 0
             0deg  180   0deg  0deg     (same amplitude throughout)

Why is PSK the workhorse of modern links? Because amplitude is the property noise corrupts most easily — a thunderstorm or a fading multipath echo wrecks signal strength but barely touches *when* the wave crosses zero. By hiding the information in phase, PSK rides through amplitude chaos that would cripple ASK. Engineers picture PSK with a constellation diagram: a 2-D map where each possible symbol is a dot, its angle showing the phase and its distance from the origin showing the amplitude. The farther apart the dots, the more noise the link can tolerate before the receiver confuses one for its neighbour.

BPSK constellation (1 bit/symbol)     QPSK constellation (2 bits/symbol)
        Q                                      Q
        |                                   01  |  00
  o-----+-----o   bit0      ->            o     |     o
  1     |     0                       ----+-----+-----+---- I
        |                                 o     |     o
      I axis                             11     |  10
   two phases: 0deg and 180deg          four phases: 45,135,225,315 deg

Symbols vs bits, and a worked BPSK example

Here is a distinction that trips up nearly everyone at first. A bit is one unit of information — a single 1 or 0. A symbol is one transmitted state of the carrier, held for one symbol period. The two are not the same! In BPSK each symbol carries exactly one bit, so symbols and bits march in lockstep. But in QPSK there are four distinct phases, so each symbol carries two bits; in 16-QAM each of 16 states carries four bits. Pack more bits per symbol and you send data faster in the same bandwidth — but the constellation dots crowd closer together, so you need a cleaner channel (higher SNR) to keep them apart. That trade — bits-per-symbol against noise tolerance — is the central bargain of every modem ever built.

Let's encode a real bit pattern as BPSK by hand. The recipe is the simplest in all of modulation: keep the carrier's amplitude and frequency fixed, and choose its phase by the bit. We'll use the common convention bit 1 → 0° phase and bit 0 → 180° phase. A 180° flip is mathematically just multiplying the carrier by −1, so BPSK is really 'send +cos for a 1, send −cos for a 0.'

1. Take the bit pattern to send: 1 0 1 1 0.
2. Map each bit to a phase: 1→0°, 0→180°. Pattern becomes phases 0°, 180°, 0°, 0°, 180°.
3. Map each phase to a sign of the carrier: 0°→ +cos(2πfc·t), 180°→ −cos(2πfc·t).
4. Transmit one such carrier burst per symbol period Tsym (here 1 symbol = 1 bit, so 5 bursts for 5 bits).
5. At the receiver, multiply the incoming wave by a clean local cos and average over each Tsym: a positive result reads as 1, a negative result reads as 0. (This is matched detection — it's why BPSK is so robust.)

Bits:      1        0        1        1        0
Phase:     0deg     180deg   0deg     0deg     180deg
Sign:      +cos     -cos     +cos     +cos     -cos

Waveform (each cell = one symbol period Tsym):
   /\  /\   \/  \/   /\  /\   /\  /\   \/  \/
  /  \/  \  /\  /\  /  \/  \  /  \/  \  /\  /\
           \/  \/             ^         \/  \/
  +1 phase  flip 180   back to +1, +1   flip 180

Receiver: integrate (rx * cos) over Tsym ->  +  -  +  +  -  ->  1 0 1 1 0  (recovered!)