3/7/2026 - Assembled prototype and finished first stable version

I spent about three months working on this project in my spare time. The goal was to build a small desk retro-style clock that runs on an avr platform and feels simple, hackable, and fun for electronics enthusiasts.

During development I experimented with several basic hardware concepts: handling multiple buttons for user input, driving a 16x2 LCD through an I2C adapter, and using a passive buzzer for alarm sounds. One of the main challenges was designing a simple menu system that could be controlled with only a few buttons. I had to rethink the logic a couple of times until the navigation felt intuitive.

Another small challenge was dealing with the hardware side. Since I sourced parts locally, I had to adapt to the components that were available and test different wiring setups until everything worked reliably on a breadboard.

Over time the project evolved from a simple clock into something a bit more interesting: it now includes a clock, an alarm, and a stopwatch mode. The interface is intentionally minimal so it keeps that retro embedded-systems feeling.

For this submission I organized the repository, documented the wiring, and created a bill of materials so other people can easily replicate the build. The whole project can be assembled with inexpensive components and does not require a custom PCB, which makes it accessible for beginners or hobbyists who want to experiment with Arduino and basic electronics.

Overall this project helped me practice embedded programming, hardware debugging, and documenting a small open hardware project.

I also created my own FSM engine to make state transitions and handling easier.

3/24/2026 12:29 PM - FROM SCRATCH: Initial Idea

The project, called Owake, started from a simple but very real problem: waking up using a phone alarm was unreliable, since it was too easy to snooze and fall back asleep.

The idea was to build a dedicated alarm clock that runs on minimal hardware: an AVR/Arduino MCU, three buttons, and a 16x2 LCD. The goal was not just functionality, but also to create a pleasant and intuitive user experience, inspired by retro hacker-style devices.

Hardware Setup

The hardware setup was intentionally simple. Using an Arduino Leonardo, three buttons were mounted on a breadboard alongside a 16x2 LCD display.

Initial testing involved uploading compiled firmware versions to validate basic interaction. During this phase, issues with the standard HD44780 LCD library became evident, as it introduced unnecessary delays and performance overhead.

This led to the decision to later replace it with a custom implementation.

3/24/2026 12:42 PM - Interface & Menu Design

One of the main challenges was designing an intuitive menu system with limited input controls. I went through multiple iterations of the navigation logic until it felt natural and responsive.

On the hardware side, sourcing components locally meant adapting to what was available. This required:

• Testing different wiring configurations
• Debugging unreliable connections on the breadboard
• Adjusting the design based on real-world constraints The interface design focused on minimalism and clarity, using only three buttons to navigate and interact with the system.

To support this, a custom input handling library was developed to detect button press, release, and hold events. This abstraction made it easier to design responsive and fluid menu navigation.

The UX was designed to feel smooth and intentional despite the hardware limitations, reinforcing the retro embedded system aesthetic.

3/24/2026 12:59 PM - System Architecture

The system is built around a hierarchical finite state machine (FSM), which became the core of the project.

After several failed or inefficient designs, the final architecture evolved into a hierarchical double-dispatch FSM based on arrays of function pointers. Helper utilities were created to simplify state definition and integration.

This structure allowed for clean separation of states, scalable transitions, and maintainable logic, which was essential as the system grew in complexity.

Iteration & Debugging

Multiple challenges appeared during development.

The first thing i want to complain about is that debugging a software that runs on AVR is a hardcore task, in my case it was completely impossible and arbitrary. So i had to do some magic and Serial prints to find a bug, which was a success.

One of the main issues was the inefficiency of the standard LCD driver. To solve this, a custom LCD library was implemented, allowing fine-grained control over display updates. This made it possible to update only specific parts of the screen, such as changing 17:08 to 17:09 without redrawing the entire display, significantly reducing cycle cost.

Additionally, the custom button event system improved responsiveness and simplified state transitions.

There were also several iterations of the FSM design before reaching a stable and efficient implementation.

3/24/2026 1 PM - Final Integration

The system integrates three main features: alarm, digital clock, and stopwatch.

This is the stage where i spent the most time, fixing bugs and enhancing the ux to its best point at the moment.

The alarm system allows the user to navigate through a timestamp using two buttons and set the alarm with the third. A buzzer is triggered when the countdown reaches zero, and the user can cancel it and return to the main menu seamlessly.

The digital clock uses the MCU’s internal timer and includes a custom rendering system for large digits using the LCD’s 8 custom characters.

The stopwatch was the simplest feature, implemented using a 1ms timer interrupt. While a button is pressed, the counter increments accordingly.

Together, these components form a cohesive and efficient embedded system with a strong focus on usability and performance.

demo (on YT)