Documents

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

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

Molex

ONSEMI Linear Voltage Regulator, 7808, Fixed, Positive, 10V To 35V In, 8V/1A Out, TO-220-3

Onsemi

KYCON DC Power Connector, Jack, 3.5 A, 2 mm, PCB Mount, Through Hole

KYCON

ONSEMI Small Signal Diode, Single, 100 V, 200 mA, 1 V, 4 ns, 4 A 1n4148

ONSEMI

Transistor BC517-D74Z

ONSEMI

VISATON Speaker, Mini, 2 ", 500 mW, 8 ohm, 83 dB, 250 Hz to 10000 Hz

Visaton

MENTOR LED Panel Mount Indicator, Chrome Plated, Green, 2 VDC, 8 mm, 20 mA, 20 mcd, Not Rated

Mentor

MULTICOMP PRO Pushbutton Switch, 12 mm, SPST, (On)-Off, Round Raised, Red

Multicomp Pro

Ressitor 2K

Multicomp Pro

Resistor 3.9K

Multicomp Pro

Resistor 200E

Multicomp Pro

KEMET Multilayer Ceramic Capacitor, 0.1 ÂµF, 50 V, Â± 10%, Radial Leaded, X7R, 5.08 mm

Kemet

330nF

Kemet

Arduino Nano

Arduino

MULTICOMP PRO 6MS1S3M1RESlide Switch, SPDT, On-On, Through Hole, Side Actuator, 100 mA, 20 V

Multicomp Pro

Striped prototyping pcb board

CIF

Product Name

Manufacturer

Quantity

**BUY_KIT**

Lock mechanism 3~5V

BADODO Security

Power adapter 12V / 1A

Metal or wooden frame

Tags: arduino pwm speaker, diy stem game, diy arcade build, physical computing project, diy catch game, random drop game, reaction time game arduino, engineering project tutorial, maker electronics project, prototyping pcb project, arduino easybutton library, interactive electronics game, arduino nano project, arduino game, relay actuator project, e14presents_markdonners, friday_release

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

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

Revision 7 posted to Documents by cstanton on 5/21/2026 1:29:40 PM

Watch the Build

Can you Catch the Game?

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

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

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);
}

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

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

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

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

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

Molex

ONSEMI Linear Voltage Regulator, 7808, Fixed, Positive, 10V To 35V In, 8V/1A Out, TO-220-3

Onsemi

KYCON DC Power Connector, Jack, 3.5 A, 2 mm, PCB Mount, Through Hole

KYCON

ONSEMI Small Signal Diode, Single, 100 V, 200 mA, 1 V, 4 ns, 4 A 1n4148

ONSEMI

Transistor BC517-D74Z

ONSEMI

VISATON Speaker, Mini, 2 ", 500 mW, 8 ohm, 83 dB, 250 Hz to 10000 Hz

Visaton

MENTOR LED Panel Mount Indicator, Chrome Plated, Green, 2 VDC, 8 mm, 20 mA, 20 mcd, Not Rated

Mentor

MULTICOMP PRO Pushbutton Switch, 12 mm, SPST, (On)-Off, Round Raised, Red

Multicomp Pro

Ressitor 2K

Multicomp Pro

Resistor 3.9K

Multicomp Pro

Resistor 200E

Multicomp Pro

KEMET Multilayer Ceramic Capacitor, 0.1 ÂµF, 50 V, Â± 10%, Radial Leaded, X7R, 5.08 mm

Kemet

330nF

Kemet

Arduino Nano

Arduino

MULTICOMP PRO 6MS1S3M1RESlide Switch, SPDT, On-On, Through Hole, Side Actuator, 100 mA, 20 V

Multicomp Pro

Striped prototyping pcb board

CIF

Product Name

Manufacturer

Quantity

**BUY_KIT**

Lock mechanism 3~5V

BADODO Security

Power adapter 12V / 1A

Metal or wooden frame

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

cstanton — Thu, 21 May 2026 11:33:46 GMT

Revision 6 posted to Documents by cstanton on 5/21/2026 11:33:46 AM

Watch the Build

Can you Catch the Game?

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

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.

Preparing the drop sticks

The sticks themselves are simple wooden segments, but their preparation is essential for consistent performance.

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);
}

Testing and gameplay

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

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

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.

Final thoughts

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.

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

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

Molex

ONSEMI Linear Voltage Regulator, 7808, Fixed, Positive, 10V To 35V In, 8V/1A Out, TO-220-3

Onsemi

KYCON DC Power Connector, Jack, 3.5 A, 2 mm, PCB Mount, Through Hole

KYCON

ONSEMI Small Signal Diode, Single, 100 V, 200 mA, 1 V, 4 ns, 4 A 1n4148

ONSEMI

Transistor BC517-D74Z

ONSEMI

VISATON Speaker, Mini, 2 ", 500 mW, 8 ohm, 83 dB, 250 Hz to 10000 Hz

Visaton

MENTOR LED Panel Mount Indicator, Chrome Plated, Green, 2 VDC, 8 mm, 20 mA, 20 mcd, Not Rated

Mentor

MULTICOMP PRO Pushbutton Switch, 12 mm, SPST, (On)-Off, Round Raised, Red

Multicomp Pro

Ressitor 2K

Multicomp Pro

Resistor 3.9K

Multicomp Pro

Resistor 200E

Multicomp Pro

KEMET Multilayer Ceramic Capacitor, 0.1 ÂµF, 50 V, Â± 10%, Radial Leaded, X7R, 5.08 mm

Kemet

330nF

Kemet

Arduino Nano

Arduino

MULTICOMP PRO 6MS1S3M1RESlide Switch, SPDT, On-On, Through Hole, Side Actuator, 100 mA, 20 V

Multicomp Pro

Striped prototyping pcb board

CIF

Product Name

Manufacturer

Quantity

**BUY_KIT**

Lock mechanism 3~5V

BADODO Security

Power adapter 12V / 1A

Metal or wooden frame

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

cstanton — Thu, 21 May 2026 11:31:14 GMT

Revision 5 posted to Documents by cstanton on 5/21/2026 11:31:14 AM

Watch the Build

Can you Catch the Game?

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

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.

Preparing the drop sticks

The sticks themselves are simple wooden segments, but their preparation is essential for consistent performance.

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);
}

Testing and gameplay

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

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

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.

Final thoughts

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

Bill of Materials

Product Name

Manufacturer

Quantity

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

Molex

ONSEMI Linear Voltage Regulator, 7808, Fixed, Positive, 10V To 35V In, 8V/1A Out, TO-220-3

Onsemi

KYCON DC Power Connector, Jack, 3.5 A, 2 mm, PCB Mount, Through Hole

KYCON

ONSEMI Small Signal Diode, Single, 100 V, 200 mA, 1 V, 4 ns, 4 A 1n4148

ONSEMI

Transistor BC517-D74Z

ONSEMI

VISATON Speaker, Mini, 2 ", 500 mW, 8 ohm, 83 dB, 250 Hz to 10000 Hz

Visaton

MENTOR LED Panel Mount Indicator, Chrome Plated, Green, 2 VDC, 8 mm, 20 mA, 20 mcd, Not Rated

Mentor

MULTICOMP PRO Pushbutton Switch, 12 mm, SPST, (On)-Off, Round Raised, Red

Multicomp Pro

Ressitor 2K

Multicomp Pro

Resistor 3.9K

Multicomp Pro

Resistor 200E

Multicomp Pro

KEMET Multilayer Ceramic Capacitor, 0.1 ÂµF, 50 V, Â± 10%, Radial Leaded, X7R, 5.08 mm

Kemet

330nF

Kemet

Arduino Nano

Arduino

MULTICOMP PRO 6MS1S3M1RESlide Switch, SPDT, On-On, Through Hole, Side Actuator, 100 mA, 20 V

Multicomp Pro

Striped prototyping pcb board

CIF

Product Name

Manufacturer

Quantity

**BUY_KIT**

Lock mechanism 3~5V

BADODO Security

Power adapter 12V / 1A

Metal or wooden frame

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

cstanton — Thu, 21 May 2026 11:25:39 GMT

Revision 4 posted to Documents by cstanton on 5/21/2026 11:25:39 AM

Watch the Build

element14 presents | Meet the Hosts

Can you Catch the Game?

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

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.

Preparing the drop sticks

The sticks themselves are simple wooden segments, but their preparation is essential for consistent performance.

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);
}

Testing and gameplay

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

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

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.

Final thoughts

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

Supporting Links and Files

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

cstanton — Thu, 21 May 2026 11:15:33 GMT

Revision 3 posted to Documents by cstanton on 5/21/2026 11:15:33 AM

Watch the Build

Can you Catch the Game?

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

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.

Preparing the drop sticks

The sticks themselves are simple wooden segments, but their preparation is essential for consistent performance.

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);
}

Testing and gameplay

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

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

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.

Final thoughts

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

Supporting Links and Files

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

cstanton — Thu, 21 May 2026 11:11:56 GMT

Revision 2 posted to Documents by cstanton on 5/21/2026 11:11:56 AM

Watch the Build

Can you Catch the Game?

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

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.

Preparing the drop sticks

The sticks themselves are simple wooden segments, but their preparation is essential for consistent performance.

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);
}

Testing and gameplay

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

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

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.

Final thoughts

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

Supporting Links and Files

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

cstanton — Thu, 21 May 2026 10:51:25 GMT

Revision 1 posted to Documents by cstanton on 5/21/2026 10:51:25 AM

Watch the Build

Project Video Release Archive

e14sbhargav — Thu, 14 May 2026 14:06:52 GMT

Revision 212 posted to Documents by e14sbhargav on 5/14/2026 2:06:52 PM

Project Video Releases

Episode 714: Find EMI Fast with a Low‑Cost, Automated Way to See Where Your PCB Radiates

Episode 713: How to Make an LED Sculpture React to Sound with micro:bit

Episode 712: Designing a More Capable Dual Motor Driver Beyond the L298N (What worked and what didn't)

Episode 711: Modern Edge AI on Raspberry Pi 5 for an Animatronic Tracker: Vision Acceleration with AI Hat+ and AI Camera

Episode 710: Your First Real PCB in KiCad : An Arduino Compatible Board Designed from Scratch

Episode 709: Was that my Number!? Fixing Café Order Chaos with a Raspberry Pi Announcer

Episode 708: Reviving a Vintage LED Sign with Arduino and PS/2 Control

Episode 707: Building a Circuit Sculpture with LED Filament

Episode 706: ESP32 + RFID = Smart Access Control in a Simple DIY Build

Episode 705: Building a Super Smooth Z-Scale Train Controller with Arduino

Episode 704: Hacking an IKEA Desk into a Programmable Electric Workstation

Episode 703: How to Set Up the Raspberry Pi 5: Complete Beginner Step-by-Step Guide

Episode 702: Build Your Own USB Looper for Serial Debugging and File Transfer

Episode 701: From Snooze to Launch: The Arduino-Powered LEGO Alarm Clock Inspired by Artemis 2

Episode 700: How Voice Recognition Works on Raspberry Pi (and Why It’s Easy to Break)

Episode 699: GimmeGPIO: A Simple Way to Get GPIO on Laptops and Desktops

Episode 698: Building a Practical Electronics Workbench for Makers and Engineers

Episode 697: A Smart, Safe 3D Printer Cabinet Using Raspberry Pi and Node-RED

Episode 696: How a Pulse Metal Detector Works, and How to Build One

Episode 695: A DIY Test and Programming Rig Built for Small-Batch Electronics Production

Episode 694: Earn Your Fitness Reward with a Smart Cookie Jar Using Strava and ESP32

Episode 693: Open-Source Multicolour 3D Printing Upgrade: Clem’s 3D Chameleon Remix

Episode 692: Build Your own ESP32 Fitness Heart Rate Monitor / Tracker

Episode 691: How Accurate Is Bluetooth Channel Sounding? A Deep Dive with the nRF54L15

Episode 690: Meet the PlatypusBot: Now Powered by Raspberry Pi & ROS

Episode 689: How Clem Built a Handheld Sci-Fi Communicator That Really Works

Episode 688: Building the Cylon Pumpkin: Combining a Larson Scanner and Vocoder for Halloween

Episode 687: Turning a $10 Air Fryer into an Arduino powered Filament Dryer

Episode 686: Creepy Motion-Activated Painting You Can Build Yourself

Episode 685: When Your Body Becomes the Instrument: Clem Builds the “Dröne” Synth

Episode 684: Building an Audio Reactive LED Matrix with a micro:bit and NeoPixels

Episode 683: How to Make a Portable Emergency Radio with an Arduino Nano in a Mint TinT

Episode 682: DIY RF Modulator + Raspberry Pi Pico = Gaming on a Sony Watchman FD-10A CRT

Episode 681: Turn anything into an Arduino Module: Reusing Everyday Electronics

Episode 680: From Kit to Custom Design: Building a Tube-Based FM Radio

Episode 679: ESP32 Duolingo Owl Project: Never Miss a Lesson Again

Episode 678: Open Source ATtiny3226 Arduino Calculator – Hardware, Case & Code Build

Episode 677: Make Your Own Vocoder with Teensy 4.0 - Voice of a Cylon?!

Episode 676: I Tried Building 16 ATtiny Robots with Vibration Motors – It Was a Disaster

Episode 675:Avoid Conflict with this ESP32 Defcon Task Tracker

Episode 674: Building an Open Source Blood Pressure & Heart Signal Monitor

Episode 673: Building an ESP32 Powered Warhammer 40k Rhino with Dynamic LED Effects!

Episode 672: Building an Autonomous LEGO Train with CircuitPython and LIDAR

Episode 671: PlatypusBot - Scavenging for Robotics Parts

Episode 670: Build your own Larson Scanner

Episode 669: Creating an ESD (Or Lightning!) Detector!

Episode 668: Designing an Arduino PID Controlled Micro Drone

Episode 667: Emulating a Speech Synthesis Chip with an ESP32

Episode 666: How Far Can I2C Go?

Episode 665: Raspberry Pi AI Tracking Eye of Sauron - AI AL Barad Dur

Episode 664: Learn how to Make a Photo Booth with the ESP32 and Telegram Automation!

Episode 663: Upcycling a Vintage Microphone into an Emergency Radio System

Episode 662: Making a Stronger Affordable DIY Robot Arm with 3D Printing with Raspberry Pi Pico

Episode 661: Clem makes his own LED Wristwatch

Episode 660: LoFi Beats to Solder To

Episode 659: DIY Single Board Computer with ESP32 and Raspberry Pi Pico

Episode 658: A Smart Youtube Counter With An Audio Analyzer

Episode 657: How to Control a LEGO Mindstorms kit with AI and Raspberry Pi 5

Episode 656: DIY Jig for your Laser Cutter with Custom Arduino Automation

Episode 655: DIY Hot Plate for SMD Soldering Using Raspberry Pi Pico

Episode 654: How Do BattleBots Work? In the Pit with HyperShock

Episode 653: Edge-lit 7-Segment Display Clock Using Raspberry Pi Pico

Episode 652: Smart Windows and Blinds with Arduino and Raspberry Pi Pico

Episode 651: Design for Manufacturing - Project to Product by Modifying Off-the-Shelf Cases

Episode 650: Using Nordic's nRF7002, My Dehumidifier Tells Me When It's Full!

Episode 649: Giant Retro Gaming Magic Mirror with a Raspberry Pi 5!

Episode 648: Home AI Image Generation Server with LattePanda and Stable Diffusion

Episode 647: Building an Open-Source Tool for Cave Surveying

Episode 646: Creating a Digital Roulette Table with an ESP32 DevKit

Episode 645: Practical DIY Pi Pico Current Load Circuits

Episode 644: Turning a Raspberry Pi Pico into a GPU!

Episode 643: Making a Tribble that Detects Klingons

Episode 642: Making a Time-lapse Camera with a Raspberry Pi 5

Episode 641: Moon Phase Display with Raspberry Pi Pico

Episode 640: Tinkering vs Engineering: Can You Build a Laptop from Scratch?

Episode 639: Off-Grid Remote Generator Starter?

Episode 638: RP2040 PCB: Design, Turn-On, and Debug - How Hard Could It Be?

Episode 637: Making Music with a Lego Guitar and Capacitive Touch

Episode 636: Creating an IMU based 3D Mouse with an ESP32-S3

Episode 635: Vintage Electronics Exploration with a Bally Cypress Gardens Bingo Machine

Episode 634: Craft a Festive LED Christmas Sweater Featuring the ATtiny416

Episode 633: Spying Under the Christmas Tree with an Arduino-powered Ornament

Episode 632: Revamping Old School Pinball with an ESP32

Episode 631: All-Purpose Debugging: A Practical Universal Screen with LCD Displays

Episode 630: Mega IIe: First Fully Functional Computer built around the Apple Mega-II Chip

Episode 629: Backpack Splash: Mark's Water Gun Upgrade for Epic Outdoor Water Wars!

Episode 628: Affordable DIY Robot Arm - A Deep Dive into 3D Printing and Servo Motors

Episode 627: Creating sudostick - From Prototype to Product

Episode 626: Catching you Up on Bonesnapper Ridge - Off-Grid Maker Shop

Episode 625: Interactive Magic - Creating an Enchanted Cauldron

Episode 624: Modding A Smoke Machine to Add Motion Detection

Episode 623: How to Run Linux on an ESP32

Episode 622: Building Spooky Fun: Halloween Sound Pranks with nRF 5340 BLE Audio

Episode 621: Color Sensor-Based Water Quality Tracker: DIY Environmental Monitoring

Episode 620: Stey-by-Step Guide to Creating your own Speaking Animatronic Hat

Episode 619: How to Build an Open Source Bluetooth Mechanical Keyboard

Episode 618: Upgrading My Racing Sim with a Force-Sensitive Keyboard

Episode 617: Simplify Network Monitoring: Building an ESP32-Powered Solution

Episode 616: Mastering Oven Control: Precision Resin Curing with DIY Modifications - How Hard Can it Be?

Episode 615: Building a Unique USB Card Reader: From Idea to Prototype

Episode 614: Using PID (Proportional-Integral-Derivative) in Robotics - How Hard Could It Be?

Episode 613: Building a Magic Wand Talking Sound Board

Episode 612: Handheld BASIC computer in Badge Format with the Arduino Uno

Episode 611: How to Run the Distance to the Moon with Strava Data and a Pico W Board

Episode 610: How to Embroider with Circuits and Conductive Thread

Episode 609: Updating a Fujitsu N860-2500-T111 Keyboard to Work with a PS2 Standard

Episode 608: Making the Simplest DIY Wind Energy Generator - How Hard Could it Be?

Episode 607: From Strava to Motion: Creating an Arduino-Powered Arcade Game with Running Data

Episode 606: How to Use LoRaWAN to Launch Model Rockets Wirelessly

Episode 605: Arduino and LEDs Make Solitaire Easier to Solve

Episode 604: Charlieplexing Buttons and LEDs at the Same Time - How Hard Can It Be?

Episode 603: Create Your Own Air Hockey Table with Arduino Scoring

Episode 602: DIY AC Dimmer Circuit: Control Your Lights with a Raspberry Pi Pico

Episode 601: How to Reverse Engineer Electronics: Building a Developer Board for a Coding Class

Episode 600: Building My Dream Digital Clock: DIY 7 Segment Display with a Cute Robot Twist!

Episode 599: How to Build a Spectrum Analyzer with Lego Bricks & Discrete Electronics

Episode 598: How To Build a Portable, Solar-Charged Off-Grid Power Station

Episode 597: How to Build a Robot that Celebrates Good Grades with Arduino

Episode 596: How to Build Your Own Voice Assistant with MyCroft AI - How Hard Can It Be?

Episode 595: Member Challenge Accepted - Universal LANC Controller for DSLR cameras

Episode 594: Repairing a Neewer 660 Studio light - How Hard Can It Be?

Episode 593: Playing 3D Famicom Games Wirelessly on the NES - How Hard Could It Be?

Episode 592: Lamptopus: Spinning LED Desk Lamp

Episode 591: Building A Bluetooth Speaker in 5 Minutes - How Hard Can It Be?

Episode 590: Seven Kingdoms Open Source Bartop Arcade

Episode 589: Upgrading the iMac G4 With a NUC

Episode 588: Highlights from element14 presents 2022

Episode 587: Create Your Own Talking Stress Indicator

Episode 586: DIY Open Source Bluetooth Headphones

Episode 585: Enhancing a Magnifying Headband with Auto Sensing Light

Episode 584: Going Beyond Periodic Wakes: Using WiFi to Revive a Sleeping Device

Episode 583: Epic Neopixel Birthday Cake

Episode 582: Smart Christmas Decoration with Raspberry Pi Pico and MQTT

Episode 581: Bee-Saving Electronics Prototype

Episode 580: DIY Low Cost Capacitance Meter Using a 555 Timer

Episode 579: How to Make a Basketball Auto Score Keeper Using Colour Sensing

Episode 578: Build your Own Bat Detector with Analog Parts

Episode 577: The Game Guy Mini, Upgrading the Unportable Game Boy!

Episode 576: Build your own Underwater Drone with 3D Printed Parts

Episode 575: How to Make a Secured Parcel Pickup Box with Arduino

Episode 574: Ghost Rider Halloween Costume

Episode 573: Using a Pi Pico to Convert Keyboard Input to Morse Code

Episode 572: How to Use an ESP32 & Camera to Know You've Got Mail!

Episode 571: Using Dead Batteries to Test for Dead Batteries

Episode 570: Making a WiFi Connected Audio Spectrum Analyzer with ESP32

Episode 569: Multi-Spectrum UV Resin Curing Station with Würth LEDs

Episode 568: How to Make a Custom Soundboard with the STM32F4 using FreeCAD

Episode 567: Synced NeoPixel Mickey Mouse Ears

Episode 566: How to Automate Industrial Welding Positioners with Arduino

Episode 565: Measuring Destructive Testing Force with a 20 Ton Hydraulic Press

Episode 564: Build a VU Meter with LED Pixelated Nixie Tubes

Episode 563: Creating Augmented Reality Circuits with Meta Quest 2 and Unity

Episode 562: Pi Home Temperature Monitoring System

Episode 561: WiFi to Parallel Port Ascii Art Dot-Matrix Printer

Episode 560: Raspberry Pi Controlled Lego Train with Build HAT

Episode 559: Create a Magic Makeup Mirror with Pose Detection

Episode 558: 3D Object Rendering Using an FPGA

Episode 557: Create your own Handheld Serial Monitor for Project Debugging

Episode 556: Hacking a Hotel POS Tablet - How Hard Can it Be?

Episode 555: Dance Central Pose Estimation Game with Tensorflow and Raspberry Pi

Episode 554: Arduino Uno Mini Limited Edition LED Necklace

Episode 553: Adding a Parallel Printer Port to an Android Phone

Episode 552: Magical Potion Bottle Rack

Episode 551: Can We Rebuild a 1930s Accounting Machine?

Episode 550: DIY Electronic Controlled Motorized Wheelchair

Episode 549: Using a Teletype Machine as a USB Printer with Arduino

Episode 548: Electronic Fidget Cube, Building Your Ideas!

Episode 547: Creating a “Mummy” Wake Word Detector with Raspberry Pi and Edge Impulse

Episode 546: Mapping the Outputs of a 1960s Teletype Machine - How Hard Can it Be?

Episode 545: Designing a Custom PCB for Microsoft Jacdac

Episode 544: Reviving the 1984 IBM 5155 - How Hard Can It Be?

Episode 543: Lego Spike Prime Weather Station with Raspberry Pi

Episode 542: A Noise-Free DIY Switching Power Supply - How Hard Can It Be?

Episode 541: Vintage Laptop Battery Replaced with USB Power - How Hard Can It Be?

Episode 540: Object Detection for Smart Recycling

Episode 539: Training a Machine to Recognize Objects - How Hard Can It Be?

Episode 538: How to Build a Quadruped Robot - NO MATH!

Episode 537: Build a Phonograph Preamplifier - How Hard Can It Be?

Episode 536: Interactive Light-Up Window with Pose Detection using a Raspberry Pi and micro:bit

Episode 535: Repair a Sega Game Gear - How Hard Can It Be?

Episode 534: Open Source Inventory Warehousing System

Episode 533: Jumbo DIY LED

Episode 532: World’s First Single-Chip Apple II Boots!

Episode 531: Game Guy - The Unportable Game Boy

Episode 530: MQTT controlled LED Christmas Baubles with Raspberry Pi Pico

Episode 529: UPDI Program for new ATTiny

Episode 528: Let's Build an Electronic Fidget Cube!

Episode 527: Interactive Light Up Window using a Raspberry Pi and micro:bit

Episode 526: CNC Router Remote Control

Episode 525: DIY Helmholtz Snow Globe

Episode 524: Arduino IoT Cloud Weather Station

Episode 523: Make your Own Auto-Sensing Solder Fume Extractor

Episode 522: Siren Head Halloween Wearable Costume

Episode 521: DIY Static Grass Applicator

Episode 520: Adding Android Auto as Non-Permanent Add-On with Raspberry Pi

Episode 519: Make Your Own Ye Olde Book Nook Diorama with Arduino

Episode 518: Guitar Vacuum Tube Distortion Pedal

Episode 517: Emulate an EPROM - How Hard Could it Be?

Episode 516: Modding a Wireless Doorbell with Raspberry Pi and ESP8266

Episode 515: Upcycling a Lenovo PC into a Raspberry Pi WiFi Access Point

Episode 514: Making a 3D Graphics Card for the Atari 800 XL

Episode 513: Bike Speedometer with Arduino and GPS

Episode 512: You Cannot Buy This Vacuum Tube Tester. You Build It!

Episode 511: Raspberry Pi Powered Cheeseball Launcher

Episode 510: Laser Cutter Command Station

Episode 509: DIY Discrete Logic LED Countdown Timer

Episode 508: Raspberry Pi FPV Rover Easy Robot Arm Upgrade

Episode 507: Massive Raspberry Pi

Episode 506: DIY Star Trek Tricorder from Build Inside the Box

Episode 505: Super 8 Camera Digitizer

Episode 504: DIY Sump Pump Alarm

Episode 503: Meet Cheesoid - The Robot That Smells!

Episode 502: Make Your Bike a Pokebike!

Episode 501: Raspberry Pi NFC Button-Free Music Player

Episode 500: Build Inside The Box Challenge!

Episode 499: DIY Four Channel Arduino Servo Tester

Episode 498: Raspberry Pi Smart Water Dispenser

Episode 497: RFID Pocket Money Keeper

Episode 496: Compute Module 4 Powered 3D Printer Board

Episode 495: Magic GIF Ball Powered By Raspberry Pi

Episode 494: Keyboard Shortcuts Keypad with Raspberry Pi Pico

Episode 493: NeoPixel 7 Segment Display Clock Update

Episode 492: Arduino vs 555 Timer - Tiny Slot Car Racers

Episode 491: Arduino Single-Wheel Balancing Robot

Episode 490: DIY Raspberry Pi Pico Fizz Buzz Multiplication Game

Episode 489: Build An FPV Rover with Raspberry Pi

Episode 488: DIY Raspberry Pi Cyberdeck

Episode 487: DIY MagSafe Battery Charger

Episode 486: Make The Ultimate Phone Charging Camping Flashlight

Episode 485: How To Make A Custom PCB From Design To Assembly

Episode 484: Raspberry Pi Bird Watching Camera

Episode 483: DIY Miniature Multimeter

Episode 482: Gigantic 3D Printed 7 Segment Display Clock

Episode 481: DIY LOST Swan Station Split Flap Display Timer

Episode 480: DIY Toothbrush Timer

Episode 479: Raspberry Pi 2XL Robot Assistant Part 2

Episode 478: Upgrading A Christmas Train

Episode 477: Metal Plate Your 3D Prints with a DIY Galvanizing Machine

Episode 476: IoT Arduino NTP World Clock with SPI Display

Episode 475: DIY Wall Mounted Arduino Barometer

Episode 474: Continuum Robot Tentacle Prototype

Episode 473: Mendel 3D Printer Upgrade and Maintenance

Episode 472: DIY Hydration Reminder System

Episode 471: DIY Dance Dance Revolution Mat

Episode 470: Voice Activated Inspector Gadget Hat

Episode 469: Nintendo Super Scope Modded For Modern Televisions

Episode 468: Socially Distanced Halloween Candy Dispenser

Episode 467: Repairing the World's First Laptop! (Epson HX-20)

Episode 466: Arduino-powered Hexadecimal Color Code Clock

Episode 465: Lego Raspberry Pi HQ Camera

Episode 464: Particle Voice Recognition for Home Appliances

Episode 463: Raspberry Pi Speech to Text LED Face Mask

Episode 462: Joycon Controlled Electronic Rock'Em Sock'Em Robots

Episode 461: Portal 2 Security Camera with Raspberry Pi 2

Episode 460: Trinamic Open Source Ventilator (TOSV) Teardown

Episode 459: Raspberry Pi 4 VR Conference Call Assistant

Episode 458: DIY Arduino Automated Metal Bending Machine

Episode 457: Raspberry Pi 4 Animatronic Rosie the Robot from the Jetsons

Episode 456: Unhackable Arduino Switch Matrix

Episode 455: Arduino Unit Conversion Calculator

Episode 454: Soldering Up the rc2014 Homebrew Z80 Computer Kit

Episode 453: Build an Anti-Troll Bot Using TensorFlow and Arduino

Episode 452: Raspberry Pi 4 Experimental Resin 3D Printer Updated!

Episode 451: Build an Off Grid Wikipedia with Raspberry Pi

Episode 450: Sega GameGear Rebuild with LEDs

Episode 449: DIY Tamagotchi - Build a Virtual Pet

Episode 448: DIY Raspberry Pi 4 Boxing Game

Episode 447: DIY Stop Motion Rig with LattePanda

Episode 446: Raspberry Pi 2XL Robot Assistant Part 1

Episode 445: Raspberry Pi 4 Animatronic BD-1 Companion Robot

Episode 444: Raspberry Pi 4 DVR

Episode 443: Arduino Uno RC Remote - Can It Be Done?

Episode 442: Make Your Own Giant Servo

Episode 441: Raspberry Pi 4 International Space Station Tracker

Episode 440: DIY Arduino Helicopter Collective Joystick Control

Episode 439 - Mechanical Arcade Game with Barebones Arduino

Episode 438: Smartphone Controlled DIY Rover Using Websockets

Episode 437: DIY Motorized Zoom for Your DSLR

Episode 436: Automated Raspberry Pi Planet Tracking GOTO Telescope

Episode 435: Raspberry Pi 4 Music Player w/Analog Controls

Episode 434: Infineon Smart City Model

Episode 433: Arduino Based Love Tester

Episode 432: Super FX Sword using the BBC micro:bit

Episode 431: Room-Sized Studio Light Speakers Combo

Episode 430: Flaming Xylophone Rubens' Tube

Episode 429: YouTuber "On Air" Light with Particle Mesh Network

Episode 428: Raspberry Pi 4 CRT-based VR Headset

Episode 427: DIY Retro Gaming Portable on a Budget!

Episode 426: Retro TV Ads Holiday Ornament

Episode 425: Make Your Own Raspberry Pi 4 Photobooth!

Episode 424: DIY Escape Room Puzzle

Episode 423: Programmable Arduino Synthesizer Watch

Episode 422: Raspberry Pi E-Ink Task Organizer

Episode 421: Raspberry Pi 4 Commodore SX-64 Inspired Portable Computer

Episode 420: DIY Shapeoko CNC Pendant

Episode 419: Altair 8800 Laptop

Episode 418: Animatronic Terminator Skull with BeagleBone® AI

Episode 417: #Pipboy 2000 Mk II

Episode 416: DIY #3DPrinted Label Spooler

Episode 415: Iron Man Helmet Heads Up Display

Episode 414: Raspberry Pi 4 Experimental Resin 3D Printer

Episode 413: Animatronic Claptrap Case Mod Part 2

Episode 412: Get to Know Your ADC with a DIY Temperature Probe

Episode 411: Animatronic Claptrap Computer Case - Part 1

Episode 410: MacPro G5 Cheese Grater with Raspberry Pi 4

Episode 409: Commodore SX-64 Restoration

Episode 408: Hand Soldered LED Oscilloscope

Episode 407: The Ultimate Raspberry Pi 4 Laptop

Episode 406: Automated Robot Artist

Episode 405: RC Ornithopter Concept

Episode 404: Arduino Powered Close Encounters Midi Light Board

Episode 403: Upcycled IoT Coffee Pot Ramen Maker

Episode 402: PiPhone++ The Giant Raspberry Pi Flip Phone

Episode 401: Matrix Voice Controlled Robot

Episode 400: The Ultimate Raspberry Pi Stress Test

Episode 399: Candle-Powered Robotl

Episode 398: Let Me Out Hooman! Bluetooth Dog Doorbell

Episode 397: Steam Powered Retropie Console

Episode 396: Arduino Retro LED Matrix Handheld

Episode 395: Raspberry Pi Stop Motion Machine

Episode 394: Animatronic GLaDOS Head with Raspberry Pi

Episode 393: GameBoy Walkman

Episode 392: Multi-Line Telephone Intercom

Episode 391: First Person View RC Car with PS2 Steering Wheel

Episode 390: Retro Texting Smart Watch of the Future!

Episode 389: PlayStation Classic Portable Prototype

Episode 388: FPGA MIDI Music Synthesizer

Episode 387: Rotocell - The Rotary Cell Phone of the Future!

Episode 386: Xybernaut Wearable PC

Episode 385: 20 PCB Design Pitfalls

Episode 384: Retro Gaming Handheld Without a PCB

Episode 383: Gameboy Wireless Link Cable (DMG1)

Episode 382: Modding a Super 8 Camera into a Digital

Episode 381: Reverse Music Box

Episode 380: NES Zapper on RetroPie

Episode 379: Macroscope Soldering Tool

Episode 378: Invader ZIM Animatronic GIR

Episode 377: Altair 8800 Replica

Episode 376: 4D Gaming with the Matrix Creator

Episode 375: Hacked Fetal Detector Music Synthesizer

Episode 374: Raspberry Pi Donkey Kong Holiday Ornament

Episode 373: Raspberry Pi Fallout Terminal PC

Episode 372: Raspberry Pi Auto Etch A Sketch™

Episode 371: FPGA "Game Genie" for Atari 2600

Episode 370: Raspberry Pi NOAA Satellite Receiver

Episode 369: Recreating the Atari Portfolio

Episode 368: Arduino Automatic Wire Cutter and Stripper

Episode 367: Most Useless IoT Device Ever - Part 2

Episode 366: Infinity Icosahedron

Episode 365: Twilight Zone Fortune Telling Machine

Episode 364: Raspberry Pi Virtual Reality Arcade #VR

Episode 363 - Add a Motor to your Bike with Arduino

Episode 362: Most Worthless IoT Device Ever Pt. 1

Episode 361: R.O.B Rebuild and Upgrade

Episode 360: Make Your Own Raspberry Pi Cell Phone

Episode 359: Make Your Own CNC Pyrography Wood Burner

Episode 358: The Shrimp of Terror!

Episode 357: Raspberry Pi Asteroid Tracker

Episode 356: Bank to the Future with Arduino & TI

Episode 355: Raspberry Pi Pirate Radio

Episode 354: Tiny Vacuum Forming Machine

Episode 353: Program Your Own FPGA Video Game

Episode 352: Pripyat - DIY Geiger Counter

Episode 349: Raspberry Pi Selfie Rocket

See All Previous Episodes

Tags: episode releases, friday_release_archive, element14 presents, project videos, episodes, friday releases, episode release archive, episode archive, friday release archive, project_videos

Find EMI Fast with a Low‑Cost, Automated Way to See Where Your PCB Radiates

e14phil — Thu, 14 May 2026 12:48:29 GMT

Revision 5 posted to Documents by e14phil on 5/14/2026 12:48:29 PM

Join Clem as he builds an automated CNC‑style EMI heatmapping scanner to remove guesswork from near‑field probing during pre‑compliance testing. Using an Arduino Uno with GRBL, professional near‑field probes, and a low‑cost RTL‑SDR, the system scans a PCB in a controlled grid and turns raw measurements into clear EMI heatmaps. Along the way, Clem highlights real engineering challenges, including firmware choices, SDR software limitations, and the critical importance of lowering the noise floor through proper shielding, showing how automation and good measurement practice work together.

Watch the Build

https://youtu.be/Vh7laroqxZ0

Automating Near‑Field Probing

In this element14 presents project, Clem tackles one of the most frustrating and experience‑dependent problems in electronics design: locating EMI emission sources before they turn into expensive compliance failures. Anyone who has been through pre‑compliance testing will recognize the situation immediately. A specific frequency spike, or a narrow band, appears uncomfortably close to the regulatory limit. The test setup shows it clearly, but physically locating where that emission originates on the PCB is a very different challenge.

Traditionally, this process involves manually sweeping a near‑field probe across a powered board while watching a spectrum analyzer. It is slow, requires significant experience, and is highly sensitive to probe orientation and positioning. Small changes in angle or height can produce noticeably different results, making repeatability difficult.

Clem’s goal was to remove as much subjectivity from this process as possible. Rather than relying on careful hand movements and interpretation, he wanted a system that could probe a PCB in a controlled, repeatable way and generate structured data automatically.

“I want to make this process a lot more controllable, repeatable and less dependent on actual expert usage to find the culprit.”

The result is a dedicated EMC heatmapping scanner that behaves more like a CNC machine than a traditional test setup. Using Multicomp Pro near‑field probes and a precisely controlled motion system, the machine scans a PCB in a defined grid pattern, producing consistent measurements that can be directly compared across frequencies and design revisions.

Standing on Shoulders Then Starting Fresh

Clem is clear that the core idea behind the project is not new. Several years ago, other engineers demonstrated that an RTL‑SDR could be used as a low‑cost EMI receiver for comparative near‑field measurements. Inspired by this earlier work, Clem initially attempted to reproduce one of those implementations.

In practice, this proved difficult. Software libraries had evolved, dependencies had changed, and the original code no longer worked reliably. Even more importantly, the older project did not align with Clem’s vision for automation, flexibility, and structured scanning.

“I tried to get this to run. It’s dependent on some software that since had updates, so it doesn’t work as expected anymore, at least not in my setup.”

Rather than patching an aging codebase, Clem made the decision to start over completely. This allowed him to redesign both the hardware control and the software architecture around his own requirements, rather than being constrained by assumptions baked into someone else’s workflow.

The result is a system built cleanly and modularly from the ground up. Each part of the workflow, motion control, scan definition, data acquisition, and visualisation, is implemented as a distinct software component, making the overall system easier to understand, debug, and extend.

Smart Recycling, Smart Engineering

Mechanically, the scanner reflects a pragmatic engineering mindset. Clem reused components from previous projects wherever possible. The frame of an old 3D printer forms the mechanical base, with salvaged stepper motors and drivers handling motion. This approach keeps costs low and reinforces that the project is a functional tool rather than a polished commercial product.

The probe itself only moves in X and Y. The Z height is set manually once and remains fixed for the duration of a scan. This simplification reduces mechanical complexity and removes another variable that could affect measurement repeatability.

Once the user interactively defines the scan area by jogging the probe to the lower‑left and upper‑right corners of the region of interest, GRBL dynamically generates the zig‑zag toolpath. Clem deliberately chose GRBL 1.1 running on an Arduino Uno because it provides CNC‑style control without imposing the assumptions typical of modern 3D printer firmware.

“What I need is not homing and then executing a job. What I need is total control during the process, like a CNC where it can start and stop and resume.”

This design choice is reflected in the software as well. The system does not rely on homing at all. If position is lost, the user simply redefines the scan area. For EMI debugging, where scans often focus on specific subsections of a board, this flexibility is more valuable than absolute positioning.

A small camera is mounted above the device under test, but it is not used for alignment or vision‑based scanning. Instead, it serves a documentation role, capturing an image of the DUT after a scan so that measurement data can be visually associated with the physical board.

SDR Instead of Spectrum Analyzer

One of the most notable aspects of the project is Clem’s decision to use a low‑cost RTL‑SDR instead of a traditional spectrum analyzer. This is not positioned as a replacement for lab‑grade equipment, but as a practical alternative for comparative analysis and source localisation.

Clem explicitly warns against poor‑quality SDR clones, noting that unstable hardware can introduce measurement artifacts and waste debugging time. When paired with professional near‑field probes, however, a reliable RTL‑SDR proves more than capable of revealing relative emission hotspots across a PCB.

The software is designed to scan multiple frequencies in a single run. At each X‑Y coordinate, the system measures all selected frequencies before moving on to the next point. This approach is reflected in the scanner module, which parses the generated G‑code and interleaves motion with data acquisition.

Each scan produces a plain text file per frequency containing X and Y coordinates along with received power in dBm. A secondary script converts this data into heatmap images. This separation allows raw data to be preserved for further analysis while still producing visuals that are easy for humans to interpret.

Clem designed the Python code as a collection of reusable modules rather than a single monolithic script. While AI assistance helped with some of the repetitive coding, SDR‑specific functionality required significant manual correction, particularly where libraries had changed since earlier projects.

Lowering the Noise Floor

In the final section of the video, Clem turns his attention to a topic that is often misunderstood: noise floor reduction. He emphasises that meaningful EMI localisation is only possible if the measurement environment itself is properly controlled.

“If the noise doesn’t get any lower, you basically will always measure just a guess.”

Simply enclosing the system in a metal box is not sufficient. Effective shielding requires continuous conductive paths, low‑impedance connections between panels, and careful treatment of seams, gaps, and cable pass‑throughs. Clem demonstrates how improper bonding can allow high‑frequency energy to leak through even seemingly solid enclosures.

Using conductive tape, proper grounding techniques, and purpose‑built EMI gaskets, Clem shows how reducing the noise floor dramatically improves scan clarity. Once background noise is sufficiently suppressed, subtle emission sources become visible in the heatmaps, allowing engineers to draw much more confident conclusions.

This focus on shielding and attenuation reinforces one of the project’s key themes: automation alone is not enough. Reliable results depend on understanding EMI fundamentals and applying good measurement practice alongside clever tooling.

Taken as a whole, the automated EMI heatmapping scanner demonstrates a practical, fitness‑for‑purpose approach to a complex engineering problem. It does not claim to replace formal compliance testing, but it provides engineers with a powerful tool for understanding where emissions originate, how they change under different operating conditions, and whether design changes are having the desired effect before committing to expensive laboratory testing.

By combining controlled motion, repeatable measurements, and careful attention to the measurement environment itself, Clem shows that EMI debugging does not have to remain an opaque or purely experience‑driven exercise. Instead, it can be approached systematically, with data that supports informed design decisions earlier in the development process, and with some hardware that you have available.

Supporting Links and Files

https://youtu.be/Vh7laroqxZ0

Parts and Products Used

Product Name	Manufacturer	Quantity	Buy Kit
Ardunio Uno R3	ARDUINO	1	Buy Now
Test Equipment Kit, 4x Near Field Probe, 1m Cable, N-SMA Adaptor, Case	Multicomp pro	1	Buy Now

Tags: RTL SDR EMI testing, emi heatmap scanner, e14presents_mayermakes, ARduino GRBL CNC project, EMC heatmap visualisation, pcb emission testing, CNC near field probing, emc debugging tools, near field probe PCB scanning, EMI source localisation, software defined radio emi, automated EMI debugging, diy emc scanner, PCB emi troubleshooting, electronics compliance engineering, EMC pre compliance testing, friday_release

Find EMI Fast with a Low‑Cost, Automated Way to See Where Your PCB Radiates

e14sbhargav — Thu, 14 May 2026 12:48:29 GMT

Current Revision posted to Documents by e14sbhargav on 5/14/2026 12:48:29 PM

Watch the Build

Automating Near‑Field Probing

“I want to make this process a lot more controllable, repeatable and less dependent on actual expert usage to find the culprit.”

Standing on Shoulders Then Starting Fresh

“I tried to get this to run. It’s dependent on some software that since had updates, so it doesn’t work as expected anymore, at least not in my setup.”

Smart Recycling, Smart Engineering

“What I need is not homing and then executing a job. What I need is total control during the process, like a CNC where it can start and stop and resume.”

SDR Instead of Spectrum Analyzer

Lowering the Noise Floor

“If the noise doesn’t get any lower, you basically will always measure just a guess.”

Supporting Links and Files

Parts and Products Used

Product Name	Manufacturer	Quantity	Buy Kit
Ardunio Uno R3	ARDUINO	1	Buy Now
Test Equipment Kit, 4x Near Field Probe, 1m Cable, N-SMA Adaptor, Case	Multicomp pro	1	Buy Now

Find EMI Fast with a Low‑Cost, Automated Way to See Where Your PCB Radiates

cstanton — Thu, 07 May 2026 19:34:32 GMT

Revision 4 posted to Documents by cstanton on 5/7/2026 7:34:32 PM

Watch the Build

<replace with video embed

Automating Near‑Field Probing

“I want to make this process a lot more controllable, repeatable and less dependent on actual expert usage to find the culprit.”

Standing on Shoulders Then Starting Fresh

“I tried to get this to run. It’s dependent on some software that since had updates, so it doesn’t work as expected anymore, at least not in my setup.”

Smart Recycling, Smart Engineering

“What I need is not homing and then executing a job. What I need is total control during the process, like a CNC where it can start and stop and resume.”

SDR Instead of Spectrum Analyzer

Lowering the Noise Floor

“If the noise doesn’t get any lower, you basically will always measure just a guess.”

Supporting Links and Files

Parts and Products Used

Product Name	Manufacturer	Quantity	Buy Kit
Ardunio Uno R3	ARDUINO	1	Buy Now
Test Equipment Kit, 4x Near Field Probe, 1m Cable, N-SMA Adaptor, Case	Multicomp pro	1	Buy Now

Find EMI Fast with a Low‑Cost, Automated Way to See Where Your PCB Radiates

cstanton — Thu, 07 May 2026 19:16:31 GMT

Revision 3 posted to Documents by cstanton on 5/7/2026 7:16:31 PM

Watch the Build

<replace with video embed

Automating Near‑Field Probing

“I want to make this process a lot more controllable, repeatable and less dependent on actual expert usage to find the culprit.”

The result is a dedicated EMC heatmapping scanner that behaves more like a CNC machine than a traditional test setup. Using professional Multicomp near‑field probes and a precisely controlled motion system, the machine scans a PCB in a defined grid pattern, producing consistent measurements that can be directly compared across frequencies and design revisions.

Standing on Shoulders Then Starting Fresh

“I tried to get this to run. It’s dependent on some software that since had updates, so it doesn’t work as expected anymore, at least not in my setup.”

The result is a system built cleanly and modularly from the ground up. Each part of the workflow, motion control, scan definition, data acquisition, and visualization, is implemented as a distinct software component, making the overall system easier to understand, debug, and extend.

Smart Recycling, Smart Engineering

“What I need is not homing and then executing a job. What I need is total control during the process, like a CNC where it can start and stop and resume.”

SDR Instead of Spectrum Analyzer

Lowering the Noise Floor

In the final section of the project, Clem turns his attention to a topic that is often misunderstood: noise floor reduction. He emphasises that meaningful EMI localisation is only possible if the measurement environment itself is properly controlled.

“If the noise doesn’t get any lower, you basically will always measure just a guess.”

Supporting Links and Files