2025 One Hertz Challenge: An Arduino-Based Heart Rate Sensor

There are two kinds of people in the maker world: the ones who hear “one hertz” and think “clock,” and the ones who hear
“one hertz” and immediately look at their own chest like, “Oh. Right. That thing.” The human heart is basically a
squishy biological metronome that (often) hangs out near the magical frequency of 1 Hzone beat per second. And if you’ve
ever tried to measure it with your fingers and a stopwatch, you already know the problem: humans are bad at counting when
they’re excited, distracted, caffeinated, or all three.

That’s exactly why an Arduino-based heart rate sensor is such a perfect entry point for the 2025 One Hertz Challenge. You’re
not just making a gadgetyou’re building a translator between a noisy, wiggly biosignal and a clean number that your brain
can brag about. Bonus points if you can hit that chef’s-kiss value: 60 BPM = 1.00 Hz. (It’s like tuning a
guitar… except the guitar is your circulatory system.)

What the 2025 One Hertz Challenge Is Really Asking

The idea is delightfully simple: build something where “something happens” once per second. That’s it. A constraint so small
it feels harmlessuntil you try to make it precise, repeatable, and interesting. The challenge invites everything from
hyper-accurate timing builds (“Timelords”) to absurd contraptions (“Ridiculous”), classic timepieces (“Clockwork”), and even
projects that lean on the legendary 555 timer (“Could Have Used a 555”).

What makes 1 Hz special is that it sits at the intersection of human perception and engineering convenience. One second is the
unit your brain already thinks in. Blink rate, walking cadence, impatient foot tappingso many everyday rhythms orbit around
this timescale. And then there’s your heart: a living oscillator that speeds up, slows down, and refuses to stay perfectly on
tempo (because biology never read your spec sheet).

The Hackaday-Featured Build: Simple Parts, Clever Presentation

The featured project (by Ludwin) is a compact heart rate monitor built around a Wemos D1 mini
(ESP8266) and a MAX30102 pulse sensor. It reads your pulse and displays it on a small OLED screen in
two formats: beats per minute (BPM) and hertz (Hz). That second readout is the entire joke
and the entire genius: if you can calm yourself to 60 BPM, you’re literally running at exactly one hertz.

It’s also intentionally “complete.” Rather than dangling off a breadboard like a science fair spider, it’s designed as a
standalone, USB-powered device housed in a compact 3D-printed enclosureportable, practical, and actually something you’d hand
to a friend without an apology tour.

How Optical Heart-Rate Sensing Works (Without Getting Spooky)

The MAX30102 uses a technique called photoplethysmography (PPG). Translation: it shines light into your skin
and watches how the reflected/absorbed light changes as blood volume pulses through tiny vessels. Each heartbeat slightly
changes how much light gets absorbed and reflected, producing a waveform that rises and falls with your pulse.

This is closely related to pulse oximetry, where red and infrared light are used to estimate oxygen
saturation. But for a 1 Hz challenge entry, focusing on heart rate alone is a smart move: it keeps the signal processing
simpler and reduces the risk of over-promising accuracy.

Important reality check: PPG is wonderfully accessible and also wonderfully dramatic. Your signal can look gorgeous one moment
and turn into modern art the next if you move, press too hard, get cold fingers, or let sunlight blast the sensor. This isn’t a
flawit’s the core learning experience.

Hardware Breakdown: What You Need and Why It Works

Core components

• Microcontroller: Wemos D1 mini (ESP8266) or a similar Arduino-compatible board
• Sensor: MAX30102 pulse oximeter / heart-rate module
• Display: Small I²C OLED (commonly SSD1306-based)
• Power: USB power (simple, stable, and convenient)
• Enclosure: 3D-printed case (optional, but it upgrades the “real device” feel instantly)

Power and communication in plain English

The MAX30102 is popular because it bundles the messy optical and analog work into a tight module: internal LEDs, photodetector,
optical elements, and low-noise electronics with ambient light rejection. It communicates over I²C, so your
wiring stays minimal: SDA, SCL, power, and ground.

If you’ve ever built an I²C project, this one feels familiar: the Arduino (or ESP8266) acts as the host, pulls samples from
the sensor at a chosen sample rate, and then turns those samples into something human-friendlynumbers and a display. Libraries
like Arduino’s Wire help with I²C communication, and SSD1306 display libraries do the same for your OLED.

Firmware Logic: Turning “Wiggly Line” Into “Nice Number”

A heart-rate monitor sounds like it should be a single line of codeuntil you meet reality. The raw signal is small, noisy,
and full of motion artifacts. So the firmware typically follows a pipeline like this:

1. Acquire samples from the MAX30102 (often IR channel for pulse detection).
2. Pre-process to reduce noise (simple filtering or smoothing).
3. Detect beats (find peaks that represent heartbeats).
4. Compute interval between beats (time between peaks).
5. Convert to BPM and optionally smooth with a rolling average.
6. Convert BPM to Hz for the One Hertz flex.
7. Display the results with sensible refresh timing (often ~1 update/second).

A practical beat-to-number example

Suppose your peak detector finds beats at timestamps (in milliseconds) like:
0, 980, 1965, 2950. The intervals are about 980–985 ms. Average interval is roughly 0.982 seconds.
BPM is 60 / 0.982 ≈ 61.1 BPM. Hertz is 61.1 / 60 ≈ 1.018 Hz. Congratulations: you are slightly
overclocked.

A rolling average (for example, averaging the last 4–8 beat intervals) helps stabilize the displayed value. That’s also why two
devices can both be “right” and still show slightly different numbers: they may average over different time windows.

The One Hertz Trick: BPM ↔ Hz Without the Drama

The conversion is beautifully boring:

The fun part is what that does to your perspective. A “normal resting heart rate” range is usually discussed in BPM, but in Hz
it becomes instantly intuitive: 60 BPM is 1 Hz, 90 BPM is 1.5 Hz, and 120 BPM is 2 Hz. You can feel that speed difference in
your body, and now you can measure it with your hardware.

Accuracy Talk: Comparing to Wearables Without Picking a Fight

In the project documentation, Ludwin compares readings to an Apple Watch and reports that the values track closely in real
time, with minor differences attributed to different smoothing and averaging intervals. That’s a healthy way to evaluate a DIY
biosensor: not “I replaced medical equipment,” but “my readings behave similarly under the same conditions.”

If you want your DIY monitor to feel more “watch-like,” focus on:

• Consistent sensor contact: same finger position, same pressure, minimal movement.
• Stable sampling: avoid blocking loops that delay reads.
• Smart averaging: rolling averages or median filters reduce jumpiness.
• UI pacing: update the display at human-friendly intervals (often once per second).

Maker Problems You’ll Hit (Because You’re Alive)

1) Motion artifacts

The sensor is trying to detect tiny changes in light absorption. A small finger shift can look like a “heartbeat” the size of a
mountain. Your algorithm needs to reject nonsense peaks or at least avoid panic-updating the display.

2) Ambient light and pressure

Bright sunlight, overhead LEDs, and inconsistent finger pressure can all distort the signal. A good enclosure and thoughtful
finger placement help more than people expect. Sometimes the best signal processing technique is… a better physical design.

3) “Why is it stuck at 0?”

Usually one of these: wrong I²C address, swapped SDA/SCL, missing pull-ups (often handled on breakout boards), power mismatch,
or the sensor simply not seeing a finger. Many example projects explicitly detect “finger present” by checking signal magnitude
before attempting beat detection.

Make It More “One Hertz”: Feedback, Games, and Gentle Mischief

The Hackaday write-up jokes that maybe the human is the real “one hertz device,” and a commenter even suggests adding a
feedback mechanism to “tune in” the frequency. That’s an excellent idea: instead of just displaying numbers, you can make the
device interactive.

A few upgrades that keep the project playful and on-theme:

• 1 Hz indicator: show a big “🎯 1.00 Hz” badge when BPM is within a narrow band around 60.
• Breathing coach mode: show a calm visual metronome and see if your pulse drifts toward 1 Hz over time.
• “Timelord” mode: display Hz to 3 decimal places and show short-term jitter (because biology is chaotic).
• Data logging: stream samples over serial/Wi-Fi and graph them for debugging and learning.

Safety Note: This Is a Learning Tool, Not a Diagnosis

DIY heart-rate sensing is a fantastic electronics and signal-processing project. But it’s not automatically a medical device,
and it shouldn’t be used to diagnose conditions. If someone has symptoms or concerns, they should talk with a qualified health
professional. Treat your build as a biosignal demo: educational, fun, and surprisingly enlightening.

Builder Notes: Real-World “Experience” (What It Feels Like to Build This)

If you build an Arduino-style heart rate sensor for the One Hertz Challenge, your first emotional milestone is
the moment you see a pulse-shaped waveform. It’s weirdly satisfying. You didn’t just blink an LEDyou measured
a living signal. And for about thirty seconds, you’ll feel like a wizard. Then you’ll move your finger half a millimeter and
the “wizardry” will instantly become a random-number generator with confidence issues.

The next “experience” is learning that biosignals are not polite. A heartbeat isn’t a perfect sine wave. The peaks aren’t
evenly spaced. The amplitude changes. Sometimes the waveform looks gorgeous; sometimes it looks like someone drew a skyline
while riding a scooter over cobblestones. This is where the project stops being “connect module, read number” and becomes a
crash course in signal conditioningeven if you’re doing it with simple tools like rolling averages and basic
peak detection.

You’ll also discover how much mechanical design matters. A snug enclosure that blocks ambient light and guides
finger placement can improve your results more than hours of tweaking thresholds. It’s the humbling maker lesson: sometimes
the best fix is not a new algorithmit’s a better bracket. When your sensor sits stable and your finger pressure is consistent,
your “software problem” suddenly becomes a “wow, that’s stable” moment.

Then comes the comedy phase: trying to hit exactly 1.00 Hz. You will sit there, staring at the display like
it’s a scoreboard, attempting to relax harder than you have ever relaxed in your life. Your pulse will absolutely notice you
watching it. It will speed up out of spite. You’ll learn that “calm down” is not a reliable API call. But if you add feedbacka
gentle metronome animation, a target zone indicator, or a “close enough” badgeyou can turn it into a game. That’s when the
project becomes sticky and fun: not just measuring, but interacting.

Debugging is its own rite of passage. When the display shows 0 BPM, you’ll check wiring. When it shows 240 BPM, you’ll suspect
your peak detector. When it flickers between 55 and 110, you’ll discover that you’re double-counting peaks (or counting noise).
Many builders end up printing intermediate valuesraw IR samples, filtered values, detected peak timesbecause it’s the fastest
path to understanding what the code thinks is happening. The best “experience” here is that you start to trust data
over vibes. You stop guessing. You measure.

And finally, there’s a quiet, satisfying finish: the device feels like a real object. USB power. A clean screen. A case you can
hold. A readout that makes sense. When you show it to someone, they immediately “get it.” They press a finger, watch BPM and
Hz appear, and grin when they realize their heart is literally operating in hertz. That’s the One Hertz Challenge payoff: you
took an abstract frequency constraint and tied it to something deeply human. One beat. One second. One tiny screen proving it.

Conclusion

The 2025 One Hertz Challenge is a celebration of constraint-driven creativity, and a heart rate sensor is a near-perfect entry:
it’s naturally close to 1 Hz, wildly variable, and packed with lessons in sensors, embedded programming, and signal processing.
The Arduino-based build highlighted by Hackaday shows how approachable biometric projects have becomeoff-the-shelf modules, a
capable microcontroller, and a small OLED are enough to turn your pulse into a frequency readout you can chase like a high
score.

If you build your own version, you’ll learn two truths: electronics can measure astonishingly subtle things, and your body is
not obligated to stay on tempo. Fortunately, that’s what makes it fun.