How to Build a Reaction-Based Catch Game Using Arduino and Relays

When he was young, Mark didn’t have access to modern gaming platforms. Like many at the time, entertainment came from broadcast television, limited channels, scheduled programming, and a reliance on anticipation rather than instant access. One particular show left a lasting impression: The Honeymoon Quiz. Among its many challenges was a deceptively simple game that stood out for its difficulty and tension.

The concept was straightforward. A frame positioned above the player held several sticks. Without warning, they would drop at random, and the player’s only task was to catch them before they hit the ground. Simple in design, but demanding in execution.

Decades later, Mark revisits this concept with a modern, electronics-driven interpretation, building a fully autonomous, microcontroller-based version of the game. As he puts it:

“It will hold several sticks that will drop down randomly one by one… and you need to try to catch them. That’s the game.”

The Schematic

The system is divided cleanly into four functional sections: power, control, sound, and actuation.

The power design reflects Mark’s preference for simplicity and reliability over modern optimisation. While acknowledging newer approaches, he intentionally uses a linear regulator:

“I know it's not the most elegant regulator nowadays, but it's analog and it's proven and tested… that's why I use it.”

An input supply (e.g. 12V) is stepped down to 8V for the actuators. This is a deliberate choice to provide sufficient drive strength to the relay-based mechanisms responsible for releasing the sticks.

The Arduino Nano operates using its onboard regulator, while also serving as the central controller. A push button connected to digital pin D2 serves dual purposes: starting the game and toggling difficulty.

This behaviour is clearly implemented in the code:

#define StartButton 2
EasyButton button(StartButton);

void buttonPressed() {
  running = !running;
}

void sequenceEllapsed() {
  expertmode = !expertmode;
  digitalWrite(ModeLed, expertmode);
}

button.onPressed(buttonPressed);
button.onSequence(2, 1500, sequenceEllapsed);

Here, a single press toggles the game state, while a double press (within 1500 ms) activates “expert mode” — a faster-paced variant of gameplay.

The sound system is implemented using a PWM-driven speaker, producing simple tones to indicate game states. Mark describes this pragmatically:

“It’s only used to generate a beeping sound to indicate the start and the end of a game… it will do the job quick and dirty.”

Game logic and behaviour

The game’s operation is governed by a simple but effective state-driven loop. Once started, it progresses through a fixed lifecycle:

1. Play a start tone
2. Sequentially drop sticks in random order
3. Ensure no stick is dropped twice
4. Play an end tone and reset

The randomness is carefully handled to avoid repetition:

int randStick = random(3, 13);

while (valueExistsInArray(droplog, arraySize, randStick)) {
  randStick = random(3, 13);
}

if (expertmode == 1) randTime = randTime * 500;
else randTime = randTime * 1000;

Placing the components

Component placement follows a logical and structured layout, aided by the available space on the prototyping board. While the blog presents this as straightforward. Mark notes:

“I know this is not the most elegant way of soldering… but I have to make do with what I have at home.”

This highlights a key aspect of the project: it is intentionally accessible and built using available tools rather than precision manufacturing.

After soldering, the board requires manual refinement. Traces are selectively removed using a rotary tool to prevent unintended connections:

“If I don't we will have a big short circuit… so this needs to be done.”

Baseplate

The baseplate serves as a practical integration point for the electronics. It houses the PCB, speaker, LED, and control button in a compact arrangement.

Mark emphasises the importance of keeping wiring short and manageable:

“I made a base plate… to keep wires short and compact.”

Building a Rig

The mechanical structure is deliberately flexible. While the blog suggests building a frame, the transcript shows Mark adapting available materials:

“You can use some wood bars… I happen to have aluminum frames laying around from an old table.”

This reinforces the project’s ethos: use what you have, adapt creatively.

Actuators are mounted to the horizontal bar using strong double-sided tape. Interestingly, this is not just a convenience but a considered mechanical decision:

“Make sure you use proper double-sided tape… you don’t want the actuator to fall off completely.”

The goal is controlled release, only the sticks should fall, not the mechanisms themselves.

Another practical insight not present in the original write-up is wiring flexibility:

“All I need to worry about later is which wire is the common… all the other wires I can just connect randomly because the actuators are controlled randomly.”

Cut to approximately 25 cm and fitted with hooks, they interface directly with the latch mechanisms. While the blog presents this briefly, the transcript reinforces the intended gameplay experience, lightweight sticks that drop cleanly and predictably.

Sketch upload

Programming the Arduino completes the system. Mark uses the Arduino IDE, selecting the correct board and port before uploading the sketch.

The only dependency is the EasyButton library:

#include <EasyButton.h>

if (button.supportsInterrupt()) {
  button.enableInterrupt(buttonISR);
}

Bill of Materials