Measure It Right: Scope, Multimeter and Calibration

The blindfold problem

Imagine a surgeon operating in the dark, feeling around with their fingers and *hoping*. That's what it feels like to debug embedded hardware without instruments. Your code says `set_duty(25)`, the compiler is happy, the board doesn't catch fire — and yet the motor it drives runs hot, or the sensor reads garbage. Somewhere between the line of C you wrote and the copper trace on the board, reality diverged from your mental model. The whole craft of bench measurement is about turning the lights on.

Every earlier rung in this track gave you something to *do* — toggle a GPIO, fire a PWM wave, clock out SPI frames. This rung gives you something to *see*. Three instruments cover almost everything you'll ever need on a hobby or professional bench: the multimeter answers 'what's the steady value?', the oscilloscope answers 'what does it look like over time?', and the spectrum analyzer answers 'what frequencies are in here?'. Learn what each one is honest about — and what each one quietly lies about — and you can debug almost anything.

The multimeter: your first question

The multimeter is the bench equivalent of taking someone's pulse — quick, cheap, and the first thing you reach for. It measures three things by reconfiguring itself internally. For DC voltage it puts a very high resistance (often 10 MΩ) across two points and reads the voltage that develops, obeying Ohm's law internally. For resistance it pushes a known tiny test current through the unknown part and measures the voltage back. For current it does the opposite of voltage: it inserts a tiny known resistance (a shunt) *in series* with the circuit and reads the voltage across it.

On an embedded bench the multimeter answers the boring-but-vital questions first. *Is 3.3 V actually 3.3 V?* (A regulator sagging to 3.05 V under load explains a hundred mysterious resets.) *Is this trace continuous, or did the solder joint crack?* (Continuity mode beeps.) *Is the LED resistor really 330 Ω, or did I grab a 33 Ω?* Before you ever reach for the scope, the meter has often already found the bug.

How a multimeter measures CURRENT (in series):

   +3.3V ──[ LED ]──[ 330R ]──┐
                              │
              ┌──( mA )───────┘   <- meter BREAKS the loop,
              │   meter            current flows THROUGH it
             GND

How it measures VOLTAGE (in parallel):

   +3.3V ──[ LED ]──┬──[ 330R ]── GND
                    │        │
                  ( V )──────┘   <- meter sits ACROSS the part,
                                    almost no current diverted

The oscilloscope: seeing time itself

A multimeter gives you one number. But a PWM signal *is* nothing but change — a number that's meaningless when averaged. Point a multimeter at a 25%-duty 1 kHz PWM and it might read '0.83 V', the average, which corresponds to no real voltage the pin ever sits at. To see the *shape*, you need the oscilloscope: an instrument that paints voltage on the vertical axis and time on the horizontal axis, thousands of times a second, so a repeating signal stands still on the screen like a strobe-frozen propeller.

That 'standing still' is the job of the trigger, the single most important scope control and the one beginners fight most. The trigger tells the scope *when to start drawing*: 'begin a sweep the instant the signal crosses 1.6 V going upward'. Because every sweep starts at the same point in the waveform, successive sweeps overlay perfectly and the image is rock-steady. Set the trigger wrong and the waveform scrolls or smears into a blurry ribbon — not because your signal is bad, but because the scope has no consistent anchor.

Now the parts that bite. Two specs decide whether you can trust what's on the screen. Bandwidth is the frequency at which the scope's own front-end attenuates your signal by 30% (the −3 dB point). A 100 MHz scope looking at a 100 MHz signal shows it 30% too small and with rounded edges — the famous rule of thumb is to pick a scope (and probe) with bandwidth at least 5× the fastest edge in your signal, since sharp digital edges are built from harmonics far above the clock rate. Probe loading is subtler: the moment you touch a probe to a node you add capacitance (a typical 10× probe adds ~10 pF) and the act of measuring slightly changes the thing you measure, slowing fast edges. On a sluggish SPI line you'll never notice; on a 100 MHz clock you might chase a 'glitch' that only exists because your probe created it.

Worked example: catching a PWM and an SPI clock

Let's prove your rung-2 firmware actually does what you think. You configured a timer for a 1 kHz PWM at 25% duty cycle to dim an LED. Here's how to verify it cold, with nothing but a scope.

1. Ground first. Clip the probe's ground lead to a known GND on the board — *before* touching the tip anywhere. A floating ground gives you a garbage trace and can inject noise.
2. Touch the tip to the PWM pin. Set timebase to ~500 µs/div so a 1 ms period (1 kHz) spans two divisions, and volts/div to 1 V so a 3.3 V swing fills the screen.
3. Set the trigger to rising edge at ~1.6 V. The waveform locks still: a clean rectangular pulse repeating every millisecond.
4. Read the duty cycle. Measure the high time and divide by the period. Most scopes have a one-button automatic 'Duty+' and 'Freq' measurement — confirm it reads ~25% and ~1.000 kHz.
5. If it reads 50%, you found a bug: your compare register is half what it should be. The scope just earned its keep.

PWM check — what a correct 1 kHz / 25% trace looks like:

  3.3V ┐   ┌───┐         ┌───┐         ┌───┐
       │   │   │         │   │         │   │
   0V  ┘───┘   └─────────┘   └─────────┘   └──
           |<->|             |<->|
          250us            high time = 0.25 ms
       |<------- 1.00 ms (1 kHz) ------->|

  duty = high / period = 0.25 ms / 1.00 ms = 25%   ✓

The rung-5 SPI clock is the same idea, faster. Probe SCLK, set the timebase short enough to see individual clock edges (for a 1 MHz SCLK, ~200 ns/div), and trigger on the rising edge. Now you can *see* the bus do its job: count eight clock pulses per byte, check that MOSI data is stable on the edge the slave samples, and verify chip-select (CS) drops low only during the burst. A logic-analyzer-equipped scope will even decode the hex bytes on-screen — turning 'did my driver send 0xA5?' from a guess into a label you read off the display.

The spectrum analyzer: seeing frequency

A scope shows a signal as a function of time. But sometimes the question isn't 'what shape?' — it's 'what frequencies live in here, and how strong is each?'. A musical chord on a scope is a wiggly mess; on a spectrum analyzer it's three clean peaks, one per note. The analyzer plots power versus frequency instead of voltage versus time — the same data, seen through a different lens (mathematically, the Fourier transform of the time signal).

Why does an embedded engineer care? Three reasons. First, EMI: your cute little PWM doesn't just sit at 1 kHz — its sharp edges radiate harmonics at 3 kHz, 5 kHz, 7 kHz and far beyond, and a spectrum analyzer is how you find the spike that's failing your product's emissions test. Second, clock purity: an oscillator that looks fine on a scope may show ugly sidebands (jitter, noise) that wreck a radio or an ADC. Third, finding a needle in noise: a weak 433 MHz transmitter buried under hash is invisible on a scope but pops out as a peak in the spectrum.

Calibration: why no reading is exact

Here's a truth that separates engineers from button-pushers: every measurement is wrong, and a good engineer knows by how much. Your meter reads '3.300 V'. That last digit is a confident lie. The real value lives in a band around it, and the width of that band is the instrument's uncertainty. Calibration and measurement uncertainty is the discipline of pinning that band down.

A datasheet tolerance like '±(0.5% of reading + 2 digits)' is a promise about that band. The '0.5% of reading' part scales with the value; the '+2 digits' part is a fixed floor from the least significant digits — together they tell you the worst-case error. Calibration is the periodic ritual of checking your instrument against a more-trusted reference (which was itself checked against an even-more-trusted one, all the way up to national standards) and adjusting it back into spec. A meter that hasn't been calibrated in years may read confidently and *wrongly*.

Worked uncertainty: meter spec ±(0.5% of reading + 2 digits)
Reading on a 4-digit display: 3.300 V  (last digit = 0.001 V)

  0.5% of 3.300 V .......... = 0.0165 V
  + 2 digits (2 x 0.001 V) . = 0.0020 V
  --------------------------------------
  total uncertainty ........ = ±0.0185 V

So the true voltage is somewhere in:
   3.300 - 0.0185  ...  3.300 + 0.0185
   = 3.2815 V  ...  3.3185 V

=> Report it honestly as 3.30 V +/- 0.02 V,
   NOT '3.300 V' as if the last digit were gospel.