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

e14sbhargav — Thu, 21 May 2026 13:29:40 GMT

Current Revision posted to Documents by e14sbhargav on 5/21/2026 1:29:40 PM

In this video, Mark builds a reaction-based catch game inspired by a classic TV challenge, using an Arduino Nano, relay-driven actuators, and a simple but effective control system. The setup drops sticks at random intervals, testing reflexes while showcasing practical electronics design, from power regulation and PCB assembly to embedded programming and mechanical integration. This project balances accessibility with clever implementation, making it ideal for makers looking to build something interactive and fun, watch the build and find the supporting code below.

Watch the Build

https://youtu.be/yxGkHVo9bEw

Can you Catch the Game?

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.”

Finally, the relay drivers form the core of the mechanical interaction. Each relay controls a latch mechanism holding a stick. When triggered, the latch releases, allowing gravity to do the rest.

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:

Play a start tone
Sequentially drop sticks in random order
Ensure no stick is dropped twice
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);
}

This ensures that each actuator is triggered only once per game cycle, a detail not explicitly called out in the original blog, but critical to gameplay integrity.

Timing is also adjustable based on difficulty:

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

This reflects Mark’s intent to scale challenge dynamically, something he alludes to in his video breakdown as part of creating “a more difficult game.”

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.”

This design choice reduces noise, improves reliability, and simplifies assembly, particularly important in a system with multiple actuators.

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.”

Because activation is randomised in software, physical ordering is irrelevant, a useful simplification during assembly. The sticks themselves are simple wooden segments, but their preparation is essential for consistent performance.

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>

As highlighted in both the blog and transcript, this library simplifies input handling and enables multi-function button logic without complex interrupt handling, although the code does optionally enable interrupts if supported:

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

Testing reveals a key insight: the game is harder than it looks.

“As you can guess… this is more difficult than I expected.”

Even with a basic prototype setup, the random timing and human reaction limits quickly become apparent. This validates the original TV concept, and demonstrates the effectiveness of Mark’s implementation.

Reflection and future considerations

While the blog frames the build as complete, the transcript makes it clear that this is still a prototype:

“Of course I will put a casing over the electronics… for now it’s an experimental setup.”

This suggests several natural future improvements:

Enclosing electronics for safety and durability
Refining the frame structure for portability
Adjusting difficulty scaling further
Potentially expanding actuator count or configurability

There is also a strong intended use case beyond personal experimentation:

“I’m going to have lots of fun on this… especially with the kids at my youth school.”

This positions the project as both a technical exercise and a practical interactive installation. Mark’s catch game successfully recreates a classic concept using accessible electronics and straightforward mechanical design. It balances simplicity with enough technical depth to make the build engaging, while the gameplay itself delivers genuine challenge.

By combining randomness, physical interaction, and clear feedback mechanisms, the project highlights how effective even relatively simple embedded systems can be in creating engaging experiences, especially when paired with thoughtful implementation and iterative testing.

Most importantly, it remains true to its roots: a simple idea, executed well, that is far more difficult than it first appears.

Supporting Files and Links

- Episode 715 Resources

Bill of Materials

Product Name

Manufacturer

Quantity

Buy Kit

MOLEX Pin Header, Wire-to-Board, 2.5 mm, 1 Rows, 2 Contacts, Through Hole Straight, KK 5045

Molex

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

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

Watch the Build

Can you Catch the Game?

The Schematic

Game logic and behaviour

Placing the components

Baseplate

Building a Rig

Sketch upload

Reflection and future considerations

Supporting Files and Links

Bill of Materials

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

Watch the Build

Can you Catch the Game?

The Schematic

Game logic and behaviour

Placing the components

Baseplate

Building a Rig

Sketch upload

Reflection and future considerations

Supporting Files and Links

Bill of Materials

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

Watch the Build

Can you Catch the Game?

The Schematic

Game logic and behaviour

Placing the components

Baseplate

Building a Rig

Preparing the drop sticks

Sketch upload

Testing and gameplay

Reflection and future considerations

Final thoughts

Supporting Files and Links

Bill of Materials

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

Watch the Build

Can you Catch the Game?

The Schematic

Game logic and behaviour

Placing the components

Baseplate

Building a Rig

Preparing the drop sticks

Sketch upload

Testing and gameplay

Reflection and future considerations

Final thoughts

Supporting Files and Links

Bill of Materials

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

Watch the Build

Can you Catch the Game?

The Schematic

Game logic and behaviour

Placing the components

Baseplate

Building a Rig

Preparing the drop sticks

Sketch upload

Testing and gameplay

Reflection and future considerations

Final thoughts

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

Can you Catch the Game?

The Schematic

Game logic and behaviour

Placing the components

Baseplate

Building a Rig

Preparing the drop sticks

Sketch upload

Testing and gameplay

Reflection and future considerations

Final thoughts