Knock Sensor

What it is

A spring vibration switch, a 10 kΩ pull-down resistor, a 100 nF capacitor and a red LED. Inside the switch's clear body, a coiled spring hangs around a metal rod without touching it. Knock the board and the spring swings, touches the rod, bounces off and touches again; each touch joins SIGNAL to VCC for a moment, your board reads HIGH, and the LED flashes. Between knocks the pull-down holds SIGNAL at 0 V and your board reads LOW.

It is the TK17 collision sensor's circuit with a different switch and one extra part, and the switch is what shapes every sketch. A knock is not one pulse but a short burst of them, each about a millisecond long, so a sketch has to read the pin without waiting and count each burst once. It tells you that something shook the board; it cannot tell you how hard.

VCC is the voltage your pin sees

The switch joins SIGNAL straight to VCC, so whatever is on VCC is what your pin receives during every touch:

Never 5V beside a 3.3 V board. With VCC unconnected, the block does nothing and the light never flashes. The LED currents are worked out from a red LED's typical forward voltage rather than measured.

Which pin is which

Switch at the top, header at the bottom, reading left to right:

The back prints TK28 KNOCK SENSOR and SENSES VIBRATIONS instead of pin names. Turned over, the square pad is on the right, and it is still GND.

Wiring, in three lines

1. GND to your board's GND.
2. VCC to 5V on an Uno, 3V3 on an ESP32, ESP32-S3 or Pico.
3. SIGNAL to a digital pin: D2 on an Uno, GPIO 25 on an ESP32, GPIO 4 on an ESP32-S3, GP15 on a Pico.

Leave NC unconnected. Set the pin to INPUT, not INPUT_PULLUP: the pull-down is already on the board. On an Uno, D2 can also raise an interrupt.

Example

Counts knocks, once each. It reads the pin on every pass of loop() and never waits, because a pulse lasts about a millisecond.

// The GPIO number SIGNAL is wired to.
// Uno: 2. ESP32: 25. ESP32-S3: 4. Pico: 15.
const int KNOCK_PIN = 4;
const unsigned long HOLD_OFF_MS = 100;   // longer than the spring rings

int last = LOW;
unsigned long lastKnock = 0;
unsigned long knocks = 0;

void setup() {
  Serial.begin(115200);
  pinMode(KNOCK_PIN, INPUT);   // the block has its own pull-down
}

void loop() {
  int level = digitalRead(KNOCK_PIN);
  unsigned long now = millis();
  if (level == HIGH && last == LOW) {       // a pulse starts
    if (now - lastKnock >= HOLD_OFF_MS) {   // not the same knock
      knocks++;
      lastKnock = now;
      Serial.print("knocks: ");
      Serial.println(knocks);
    }
  }
  last = level;                // no delay(): it would miss knocks
}

from machine import Pin
import time

# The GPIO number SIGNAL is wired to. ESP32: 25. ESP32-S3: 4. Pico: 15.
knock = Pin(4, Pin.IN)        # no pull: the block has its own
HOLD_OFF_MS = 100
last = 0
last_knock = time.ticks_add(time.ticks_ms(), -HOLD_OFF_MS)
knocks = 0

while True:
    level = knock.value()
    now = time.ticks_ms()
    if level == 1 and last == 0:
        if time.ticks_diff(now, last_knock) >= HOLD_OFF_MS:
            knocks += 1
            last_knock = now
            print("knocks:", knocks)
    last = level

Where to start

The handbook below is ten short articles, each with a working figure. The first read is the whole build in three wires, and prints every pulse so you can see the spring ring. Catching it with an interrupt is the version to build on, and a secret knock is a lock that opens to a rhythm.

And before plugging it into an ESP32, VCC sets the voltage is the one page that protects the board.