Event-driven vs clock-driven sensing

"You told me to report every millisecond. For six hours nothing moved, and I dutifully filed six hours of the word 'still'."

An Overworked Telemetry Agent

Section 3.1 assumed a uniform sampling grid: take a reading every \(\Delta t\) seconds and reason about aliasing against the Nyquist limit. That is the clock-driven world, and it is the default almost everyone learns first. This section names its opposite and shows when the opposite wins. We keep the book's notation: the continuous signal is \(x(t)\), a clock-driven stream is \(x[n] = x(n\,\Delta t)\), and an event-driven stream is a list of timestamped pairs \((t_k, x_k)\) where the gaps \(t_{k+1} - t_k\) are not constant. If the idea of a transducer emitting an asynchronous pulse feels abstract, Chapter 2 grounds it in the physics of the devices that do exactly this.

Clock-driven sensing: the metronome

What it is. A clock-driven (also called synchronous, periodic, or time-triggered) sensor is paced by a timer. Every \(\Delta t\) seconds the analog-to-digital converter fires, a number lands in a buffer, and the cadence never varies. The sampling rate \(f_s = 1/\Delta t\) is a design constant, and the resulting stream is a uniform grid indexed by an integer \(n\).

Why it dominates. Uniform sampling is the substrate the entire classical toolkit assumes. The Fourier transform, the Nyquist theorem, FIR and IIR filters, and nearly every off-the-shelf neural sequence model expect one sample per tick with a constant spacing. When your data is a uniform grid you can reach for Chapter 6's filters and Chapter 7's spectra without a second thought. Simplicity is the whole selling point.

What it costs. A metronome is indifferent to content. If the world is quiet, the clock keeps sampling anyway, spending bandwidth, storage, and energy on samples that repeat the last one to the bit. If the world produces a spike between two ticks, the clock never sees it: temporal resolution is capped at \(\Delta t\) no matter how fast the event was. You pay a fixed cost for a variable world, and the mismatch is exactly where event-driven sensing gets its opening.

Event-driven sensing: report only on change

What it is. An event-driven (asynchronous, data-triggered) sensor stays silent until the signal does something notable, then emits a timestamped sample. "Notable" is defined by a rule baked into the device: cross a threshold, change by more than \(\delta\) since the last report, or trip an interrupt line. The output is not a grid but a sparse sequence \((t_k, x_k)\), dense in time when the world is active and empty when it is calm.

Why it exists. Three pressures push designs toward events. First, power: a device that transmits nothing during quiet stretches can idle its radio and its processor, which is decisive for coin-cell and batteryless deployments where every transmission is a measurable fraction of the energy budget. Second, latency: an interrupt fires the instant a threshold is crossed, so the reaction time is set by the event, not by waiting for the next scheduled tick. Third, dynamic range in time: a level-crossing scheme captures a microsecond transient and a multi-hour plateau in the same stream, something no single fixed \(f_s\) can do without either oversampling the plateau or aliasing the transient.

The canonical hardware. The dynamic-vision sensor, or event camera, is the purest example: each pixel independently emits an event only when its log-brightness changes past a threshold, so a static scene produces no data and a fast-moving edge produces microsecond-resolution events. We treat these devices in depth in Chapter 46. The humbler cousins are everywhere too: an accelerometer's motion-interrupt pin, a door contact, a Geiger counter, and send-on-delta industrial telemetry all speak in events.

Level-crossing sampling: the bridge concept

The cleanest way to turn a continuous signal into events is level-crossing (or send-on-delta) sampling. Instead of sampling the time axis uniformly, you sample the amplitude axis uniformly: emit \((t_k, x_k)\) whenever \(x(t)\) has moved by more than a fixed step \(\delta\) from the last value you reported. Formally, given the last emitted sample \(x_{k}\), the next event occurs at the first \(t\) where \(|x(t) - x_k| \ge \delta\). Flat regions generate almost nothing; steep regions generate a burst. The code below runs the rule over a synthetic trace and counts how few samples survive.

import numpy as np

# A calm baseline with one short burst: mostly flat, briefly active.
t = np.linspace(0, 10, 10_000)                 # 1 kHz clock-driven grid
x = 0.05 * np.sin(2 * np.pi * 0.2 * t)         # slow, low-amplitude drift
x[4800:5000] += np.hanning(200) * 2.0          # a fast transient at t~5 s

def level_crossing(t, x, delta):
    """Emit (t_k, x_k) only when x moves by >= delta since the last event."""
    ts, xs = [t[0]], [x[0]]
    last = x[0]
    for ti, xi in zip(t[1:], x[1:]):
        if abs(xi - last) >= delta:
            ts.append(ti); xs.append(xi); last = xi
    return np.array(ts), np.array(xs)

et, ex = level_crossing(t, x, delta=0.1)
print(f"clock-driven samples: {x.size}")       # 10000, one per tick
print(f"event-driven samples: {et.size}")      # a few hundred, clustered in the burst
print(f"fraction kept: {et.size / x.size:.3%}")

Run it and the printout tells the whole story: the uniform grid pays 10,000 samples to describe a signal that was interesting for two hundredths of its duration, while the event stream concentrates its samples exactly where the action was. That concentration is the benefit. The cost arrives the moment a downstream tool wants a uniform grid back, because most of Part II and Part IV assume one.

import pandas as pd
events = pd.Series(ex, index=pd.to_timedelta(et, unit="s"))
grid = events.reindex(pd.timedelta_range(0, periods=10_000, freq="1ms")).ffill()

Choosing, and blending, the two

When clock-driven wins. Reach for periodic sampling when the signal is continuously informative (audio, a spinning-machine vibration line that never truly rests), when you need clean spectra, or when downstream models demand a fixed grid and the power budget is generous. Its predictability is a feature: buffer sizes, latency, and bandwidth are all constant and easy to reason about.

When event-driven wins. Reach for events when the signal is sparse in time (rare threshold crossings, mostly-still scenes), when energy is the binding constraint, or when you need sub-tick latency on a specific trigger. The irregular timestamps are the price, and they ripple forward: models built for uneven spacing, such as the continuous-time state-space models of Chapter 16, exist partly to consume event streams natively rather than forcing them onto a grid first.

The common answer is both. Real systems hybridize. A wearable runs its accelerometer in low-rate periodic mode as a baseline and arms a high-rate interrupt that wakes a burst capture when motion spikes. The periodic stream gives context and clean features; the event trigger buys latency and detail without paying for them during the many quiet hours. That two-tier pattern feeds directly into the streaming-inference budgets of Chapter 60.

What's Next

In Section 3.3, we confront the timestamps themselves. An event stream is only as trustworthy as the \(t_k\) attached to each sample, and once several sensors, each on its own clock, must be reconciled into one timeline, the question of what "the same instant" even means becomes the hard part of building a multi-sensor system.