Touch, pressure, capacitive, and proximity sensing

"A finger is just a grounded electrode with opinions. My job is to guess the opinion from the charge it steals."

A Capacitively Coupled AI Agent

Four modalities, one idea: perturbing a physical quantity

All four modalities share a template from Chapter 2: a contact event changes a measurable electrical quantity, and we invert that change to infer the event. They differ in which quantity and how directly the finger couples to it.

Resistive touch uses two conductive layers separated by a small air gap; pressing shorts them, and the position is read as a voltage divider along each axis. It is pressure-activated (works with a gloved finger or stylus), cheap, but single-touch and mechanically fragile. Piezoresistive and force-sensitive-resistor (FSR) pressure sensing goes further: a polymer whose bulk resistance \(R\) falls as applied force \(F\) rises, so a simple divider yields a continuous force estimate. The transfer is strongly nonlinear and hysteretic, roughly \(R \propto F^{-\gamma}\) with \(\gamma\) near 0.5 to 1 over the usable range, which is why FSRs are excellent for coarse "hard vs soft press" but poor as calibrated scales. Capacitive sensing, the dominant modality, measures the capacitance between electrodes; a finger (a grounded conductor rich in water) adds or diverts capacitance when it approaches. Proximity and hover are the same capacitive measurement operated at higher sensitivity, reading the finger before contact, trading spatial precision for range.

The reason capacitive won the interaction market is that it has no moving parts, survives millions of touches behind a sealed glass surface, supports true multi-touch, and scales to fine grids. The cost is that it senses a proxy (charge), not force, so it cannot natively tell a light rest from a hard press, and it is exquisitely sensitive to anything else that couples to the field: water, a hovering palm, a charging cable, a person's other hand on the case.

Capacitive sensing in depth: self versus mutual

Two capacitive architectures dominate, and knowing which one produced your data changes how you model it. In self-capacitance, each electrode's capacitance to ground is measured. A finger increases that capacitance because the body offers a large path to ground: \[ C_{\text{self}} = C_0 + \Delta C_{\text{finger}}, \qquad \Delta C_{\text{finger}} \approx \varepsilon_0 \varepsilon_r \frac{A}{d}, \] where \(A\) is the effective overlap area and \(d\) the finger-to-electrode distance through the cover glass and air. Self-capacitance is very sensitive (great for proximity and hover, where \(d\) is large) but on a row-and-column grid it is ambiguous under multi-touch: two touches light up two rows and two columns, which is consistent with either of two diagonal pairs, the classic "ghost point" problem.

In mutual capacitance, one set of electrodes drives (transmit, TX) and an orthogonal set receives (RX). At each row-column crossing there is a small coupling capacitance \(C_m\); a finger steals field lines from that junction and reduces \(C_m\). Because every intersection is measured independently, mutual capacitance yields a true two-dimensional image of \(-\Delta C_m\) with no ghosting, which is exactly why every modern multi-touch screen uses it. The measured object is literally a low-resolution grayscale image (a "capacitance image" or heatmap), and that framing is the bridge to everything in Part IV: a \(16\times 28\) capacitance frame is a tiny image you can run a convolutional network over, as we do in Chapter 13.

The analog front end and the signal you actually get

The idealized \(\Delta C\) hides the engineering that decides whether your data is usable. Capacitance is measured by charging the electrode and timing or integrating the result, typically by charge transfer or a sigma-delta converter, scanning the whole grid tens to hundreds of times per second. Three realities follow directly, and each is a modeling constraint, not a nuisance to wish away.

First, baseline drift. The "no touch" capacitance \(C_0\) wanders with temperature, humidity, a water film, and slow charge buildup, on time scales of seconds to minutes. Every practical system tracks a running baseline and reports the deviation from it, which is why a finger held perfectly still eventually "fades": the baseline tracker adapts to it. Your detector therefore responds to changes, and the tracker's time constant is a genuine hyperparameter, per the drift-and-denoising treatment of Chapter 6. Second, sample rate and latency. A 120 Hz scan gives an 8 ms frame period; a swipe that must feel instant leaves only a handful of frames, so aliasing and jitter (from Chapter 3) directly limit gesture responsiveness, a theme the whole chapter returns to and Section 27.7 makes a budget of. Third, interference and grounding. Mains hum, a noisy display underneath, and a poorly grounded device (a phone on a wooden table versus in your hand) all inject noise; "my touchscreen goes crazy when charging with a cheap adapter" is a real, physics-level grounding failure, not a bug.

import numpy as np

def touch_from_capacitance(frame, baseline, alpha=0.02, on=8.0, off=4.0, state=False):
    """One frame of a capacitive touch pipeline.
    frame, baseline: same-shape arrays of raw per-cell readings.
    alpha: baseline-tracker rate (small = slow adaptation).
    on/off: hysteresis thresholds in signal units. Returns (touch, xy, baseline, state)."""
    signal = frame - baseline                      # deviation from the tracked "no touch" level
    peak = signal.max()
    # Hysteresis: need > on to engage, must fall below off to release (debounces flicker).
    if not state and peak > on:   state = True
    elif state and peak < off:    state = False
    xy = None
    if state:
        r, c = np.unravel_index(np.argmax(signal), signal.shape)
        # Sub-cell centroid over a 3x3 window: this is why reported resolution beats the grid pitch.
        rs, cs, w = slice(max(r-1,0), r+2), slice(max(c-1,0), c+2), signal[max(r-1,0):r+2, max(c-1,0):c+2].clip(0)
        gr, gc = np.mgrid[rs, cs]
        xy = ((gr*w).sum()/w.sum(), (gc*w).sum()/w.sum())
    # Freeze the baseline while touched; adapt only in no-touch cells to chase drift, not the finger.
    baseline = np.where(signal < off, (1-alpha)*baseline + alpha*frame, baseline)
    return state, xy, baseline, state

rng = np.random.default_rng(0)
base = np.full((12, 20), 100.0)
frame = base + rng.normal(0, 0.5, base.shape); frame[5, 9] += 30  # a press at (5,9)
print(touch_from_capacitance(frame, base)[:2])

From raw frames to gestures, force, and rejection

With the frame in hand, four downstream tasks fall out, in rising difficulty. Detection and localization is the centroid math above; sub-cell interpolation is why a screen with 5 mm electrode pitch reports sub-millimeter coordinates. Gesture recognition (tap, swipe, pinch, rotate, edge-swipe) is a temporal-pattern problem over the sequence of frames or extracted points, and for anything beyond hand-tuned state machines it is the recurrent and convolutional modeling of Chapter 14 applied to a very small signal. Force estimation is the interesting one: pure capacitance cannot measure force, yet a fingertip flattens as you press, so the contact area, the number of activated cells and their summed magnitude, is a usable force proxy. Apple's early "3D Touch" combined a genuine capacitive strain layer with this area cue; many systems today skip the extra layer and learn force from contact-area features alone, which works acceptably per user but drifts across users and finger sizes, a cross-user generalization problem exactly like the one Section 27.5 tackles for neuromotor decoding. Rejection (palm, water, cheek-against-screen during a call) is where naive thresholds die: a water droplet and a light touch produce similar peak deviations, and only the shape of the blob in the frame tells them apart, which is precisely why treating the frame as an image and learning the discrimination outperforms any single threshold.

When each modality is the right choice

Selection follows the physics. Choose resistive when cost dominates and you need single-touch operation with gloves or a stylus (industrial panels, budget appliances). Choose an FSR or piezoresistive element when you genuinely need a continuous force or grip signal and can tolerate loose calibration (a squeezable earbud stem, a soft robot gripper's coarse contact sense, a smart-scale footpad). Choose mutual-capacitance whenever you need multi-touch, durability behind glass, and the richest signal for learning, accepting the water and grounding sensitivities. Choose self-capacitance proximity when non-contact wake, hover, or hands-on-wheel detection is the goal and coarse localization suffices. Crucially, these are not exclusive: the strongest interaction stacks fuse them, mutual capacitance for the touch image, self-capacitance for hover, and an FSR or strain layer for true force, and that fusion is the multimodal-interaction subject of Section 27.6. For gesture systems that must work at a distance with no surface at all, capacitive sensing hands off to the radar and RF techniques of Chapter 47.

What's Next

In Section 27.2, we lift off the surface entirely and let the hand move through free space, turning the accelerometer and gyroscope of Chapter 23 into a gesture sensor. The central tension shifts from field perturbation to latency: an inertial flick must be recognized in a few tens of milliseconds to feel like control rather than lag, which reframes the whole problem as low-latency inference on a motion stream.