Lever Microswitch

What it is

A lever microswitch — a miniature snap-action switch — is a mechanical contact in a small plastic body with a metal lever sticking out of it. Push the lever and an internal spring snaps the contact across; release it and the spring snaps it back. It is one of the oldest components in this library and, on a robot, one of the most useful.

What makes it a robotics part is the snap action. The contact does not close gradually as you press; it jumps, at a repeatable point, with an audible click. That gives you a definite yes-or-no answer from a mechanism that is being shoved by a moving robot, which is exactly the situation where a gradual sensor gives you nonsense.

How it works

Three terminals: COM (common), NO (normally open) and NC (normally closed). Unpressed, COM is connected to NC. Pressed, it snaps across to NO. You use two of the three and ignore the other.

For a robot bumper, wire COM to ground and NO to the input pin, with the pin’s internal pull-up on:

pinMode(BUMP_L, INPUT_PULLUP);              // idle HIGH
bool pressed = digitalRead(BUMP_L) == LOW;  // LOW means the bumper moved

That arrangement fails safe: a broken bumper lead reads HIGH, which is not pressed. Wire it the other way and a snapped wire convinces the robot it is permanently colliding. For an emergency stop, use NC instead — there, a broken wire should stop the machine.

The lever trades force for travel. The bare plunger wants around 1 N over roughly 1 mm; a lever arm multiplies the movement so a bumper shell can travel 3–5 mm and trigger with a much lighter push. A roller on the end reduces friction where something slides across it rather than pressing straight in.

When to use it

Use one wherever the robot needs to know it has already made contact: bumpers, end stops on an arm or a slide, a lid or drawer sensor, or a docking detector. It is the sensing of last resort, and that is a compliment — it catches the black chair leg, the pane of glass, and the obstacle at the wrong height that every optical and acoustic sensor misses.

It is also the only sensing a random-bounce coverage robot needs. Two of these and a random number generator will cover a whole room, which is a remarkable amount of behaviour for two moving parts.

Look elsewhere when you need to avoid the collision rather than detect it — that is what an ultrasonic or time-of-flight sensor is for. Use both: the range finder avoids most obstacles, the switch catches the ones it cannot see.

Common gotchas

• One press is nine edges. Debounce it, and never attach an interrupt that counts — only one that sets a flag or captures a timestamp.
• The switch body is not a structural part. Give the bumper shell a hard stop that takes the impact. Switch bodies crack; that is what kills them long before the contacts wear out.
• Its own spring will not return your bumper. A microswitch pushes back with 50–100 g. Use rubber bands or light compression springs for the return and let the switch only sense.
• A flat bumper misses glancing hits. Wrap the shell round to at least 45° each side, with a switch behind each half so the code knows which way to turn.
• Long leads pick up motor noise. Keep the run short, twist the pair, and rely on the pull-up’s low-impedance path when closed.
• Contact ratings are for mains, not logic. A switch rated 5 A at 125 V AC is being asked to pass microamps here; the rating tells you nothing useful about its life in this job. Pre-travel and operating force do.

Wiring

Two of the three terminals, and which two decides how the robot fails.

The distinction matters. A bumper wired to NO fails safe by reading “no collision”, which is right — a robot with a broken bumper lead should keep driving, not freeze. An emergency stop wired to NC fails safe by reading “stopped”, which is also right, for the opposite reason.

Use the internal pull-up. It costs nothing, needs no components, and gives a defined idle state. A pin left as a bare INPUT with a switch on it floats when the switch is open, and floating pins read whatever electrical noise is nearby — which on a robot full of motors is a lot.

Debouncing, done properly

A single press produces around nine transitions over roughly 4.7 ms as the contacts snap and rebound. Software that reads the pin naively sees nine presses.

const int BUMP_L = 2, BUMP_R = 3;
const unsigned long DEBOUNCE_MS = 8;      // longer than the ~5 ms bounce

struct Bumper {
  uint8_t pin;
  bool stable;            // the debounced state
  bool lastRead;
  unsigned long changedAt;
};

Bumper left  = {BUMP_L, true, true, 0};
Bumper right = {BUMP_R, true, true, 0};

// Returns true on the frame the bumper newly closes.
bool update(Bumper &b) {
  bool now = digitalRead(b.pin);          // HIGH = open, with INPUT_PULLUP
  if (now != b.lastRead) {
    b.lastRead = now;
    b.changedAt = millis();               // restart the timer on any edge
    return false;
  }
  if (millis() - b.changedAt >= DEBOUNCE_MS && b.stable != now) {
    b.stable = now;
    return (now == LOW);                  // newly pressed
  }
  return false;
}

void setup() {
  pinMode(BUMP_L, INPUT_PULLUP);
  pinMode(BUMP_R, INPUT_PULLUP);
}

void loop() {
  if (update(left))  { backUp(); turnRight(); }
  if (update(right)) { backUp(); turnLeft(); }
}

The important structural detail is that the timer restarts on every edge, rather than sampling once and waiting. A fixed sample-and-wait can land inside the bounce and latch the wrong value; restarting the window means the state is only accepted once the pin has been quiet for the full period.

Why not an interrupt

Interrupts on a bump switch are a trap, and specifically:

• Never attach an interrupt that counts. Nine edges become nine counts, and a debounce inside an ISR needs millis(), which does not advance inside an ISR on an AVR.
• A flag-setting interrupt is fine, if the debounce happens in the main loop. But polling a switch at 100 Hz costs nothing, and a robot’s loop is already running.
• Reserve D2 and D3 for encoders on an Uno. They are the only two external-interrupt pins, and encoders genuinely need them. A bumper does not.

The one case that justifies an interrupt is a hard emergency stop that must cut the motors even if the main loop has hung — and that is better solved by wiring the switch into the motor driver’s enable line, so it works with no software at all.

Mounting: the part that actually decides whether it works

Everything above is a solved problem. The mechanical design is where bumpers succeed or fail.

The shell takes the impact, not the switch. A microswitch body is thin plastic and cracks under a direct hit. Build a bumper shell that pivots or slides, give it a hard stop that takes the force, and let the switch sense a small movement near the end of that travel.

Wrap the shell. A flat front bumper misses everything hit at an angle — and a robot navigating by ranging sensors mostly hits things at an angle, because straight-on obstacles were already detected. Wrap to at least 45° each side.

Two switches, not one. Left and right, behind the two halves of the shell. One switch tells you that you hit something; two tell you which way to turn. The difference in behaviour is dramatic and the extra cost is about twenty cents.

Return the bumper with its own spring. A microswitch’s internal spring pushes back with only 50–100 g, which is not enough to reliably reset a shell with friction in its pivot. Use rubber bands or light compression springs, and let the switch do nothing but sense.

Set the pre-travel so the shell moves before the switch bottoms out. The switch operates after 1–3 mm and has a little over-travel beyond that; the shell’s hard stop must arrive within the over-travel, or the impact is taken by the switch’s internal mechanism.

Choosing one

The contact rating is irrelevant here. A switch rated 5 A at 125 V AC is being asked to pass a few microamps into a pull-up. What matters is the mechanical specification: operating force, pre-travel, and rated mechanical life (10⁵–10⁷ operations). A robot bumping a hundred times per run reaches 10⁵ operations after a thousand runs, so mechanical life is effectively unlimited — the switch will die from a cracked body long first.

Troubleshooting

Why this cheap part earns its place

Every other sensor on a robot has surfaces it cannot see. An ultrasonic sensor is blind to curtains and to walls met at a steep angle. A VL53L0X is blind to black matte surfaces, mirrors, and anything in bright sunlight. A camera needs light.

A microswitch has no such list. If something is touching the bumper, the switch closes. That makes it the sensing of last resort, and on a robot that has to survive unattended it is the cheapest reliability available — two switches, two pins, and about forty cents.

It is also, remarkably, sufficient on its own. A robot with two bump switches and a random turn on contact will cover an entire room given enough time — which is exactly how the first generation of robot vacuums worked, and it is worth understanding before reaching for anything more sophisticated.