Waiting for the Rattle to Settle

The first contact mic I built was unusable. I’d solder a piezo disc to the back of a cigar box, tap it once, and the signal would scream for a good fiftieth of a second afterward — a decaying mechanical ring as the brass and ceramic argued about whether the tap was really over. One tap registered as a dozen. The disc wasn’t broken; it was doing exactly what a piezo element does, which is keep vibrating long after the thing that struck it has moved on.

The fix isn’t in the hardware, it’s in deciding when to believe the signal. That’s debouncing: the discipline of treating a burst of rapid edges as a single event. The classic case is a mechanical switch whose contacts bounce for a few milliseconds, but a contact mic’s ringing piezo is the same problem wearing a different costume. The rule I settled on is the trailing-edge one — a new strike only counts if the signal had been quiet for long enough beforehand. You wait for the rattle to settle.

In Ruby, that’s a small object that remembers the time of the last edge it saw:

class StrikeDebouncer
  def initialize(quiet_ms)
    @quiet = quiet_ms
    @last_edge = nil
  end

  # Feed every raw edge time in ms. Returns true only for edges that begin
  # a new strike — the line had been quiet for >= quiet_ms beforehand.
  def strike?(t)
    new_strike = @last_edge.nil? || (t - @last_edge) >= @quiet
    @last_edge = t
    new_strike
  end
end

d = StrikeDebouncer.new(50)
edges = [0, 12, 27, 48, 110, 122]
strikes = edges.select { |t| d.strike?(t) }
puts "strikes: #{strikes.inspect}"

The edge list tells the story: a strike at time 0, then ringing at 12, 27, and 48 milliseconds as the disc decays, then a genuine second strike at 110 with its own ring at 122. With a 50ms quiet window, only times 0 and 110 survive — every other edge arrived too soon after its predecessor to count as a fresh event. The key detail is that I update @last_edge on every edge, including the rejected ones, so a long rattle keeps pushing the quiet deadline forward until the disc actually settles.

C is where this code would really live, on a microcontroller reading the comparator output, and the structure is the same:

#include <stdio.h>
#include <stdbool.h>

typedef struct {
    long quiet;
    long last_edge;
    bool seen;
} Debouncer;

static bool strike(Debouncer *d, long t) {
    bool new_strike = !d->seen || (t - d->last_edge) >= d->quiet;
    d->last_edge = t;
    d->seen = true;
    return new_strike;
}

int main(void) {
    Debouncer d = { .quiet = 50, .last_edge = 0, .seen = false };
    long edges[] = { 0, 12, 27, 48, 110, 122 };
    int n = sizeof(edges) / sizeof(edges[0]);
    printf("strikes:");
    for (int i = 0; i < n; i++) {
        if (strike(&d, edges[i])) printf(" %ld", edges[i]);
    }
    printf("\n");
    return 0;
}

Both versions accept the same two strikes and reject the four bounces. The Ruby reads like prose and the C compiles down to a couple of comparisons and a stored timestamp — cheap enough to run inside an interrupt handler, which is where a real mic would call it.

What the contact mic taught me is that a sensor’s honesty isn’t the same as its usefulness. The piezo is telling the truth the whole 50 milliseconds it rings; the ringing is real. Debouncing is me deciding which part of the truth I actually meant to listen for, and being patient enough to let the rest die down first.