← projects

Intelligent 3D LED Smart Alarm Clock

2023 · archived

Software architecture and integration · Cornell ECE 5725

A triangular alarm clock built from three RGB LED panels that senses its orientation and turns physical movement into self-righting time, falling sand, and interactive animations. Built with Ding Yang and Keyun Gao.

project site github

What it is

Three 16×32 RGB LED panels form a portable triangular clock around a Raspberry Pi 4. An onboard IMU tracks its pose, allowing the display to respond to which side is facing the viewer and how the object is being held.

Movement as an interface

In clock mode, the digits move to the visible face. Rotate the clock vertically and those digits fall apart like sand; return it to a level position and they reconstruct themselves. Other modes turn the same pose data into a scrolling zen image and a field of simulated snowflakes that falls and bounces as the enclosure moves. Physical buttons control the alarm and display modes.

The clock displaying time while resting horizontally.
Horizontal
The time display scrolling while the clock remains horizontal.
Horizontal scroll
The displayed digits falling like sand as the clock rotates from horizontal to vertical.
Horizontal → vertical
The displayed digits reconstructing as the clock returns from vertical to horizontal.
Vertical → horizontal
Setting the alarm hour with the physical controls.
Set hour
Setting the alarm minute with the physical controls.
Set minute
A Tai Chi image scrolling across the three LED panels in Zen mode.
Zen mode
Simulated snowflakes falling and bouncing in response to the clock's orientation.
Snowflake mode
Three connected RGB LED panels displaying a digital time during development.
The three-panel display running as a clock.
A Raspberry Pi, LED matrix driver, buttons, wiring, and an RGB panel being assembled on a lab bench.
Integrating the Raspberry Pi, matrix driver, controls, and display.

Software architecture

I was responsible for the software. I designed a Python control layer that initialized the IMU, GPIO, fonts, and canvas; managed pose, buttons, application state, alarms, and concurrent display modes; then streamed completed frames through a FIFO. A separate C++ process read those frames and drove the RGB matrices through the low-level display library. This boundary kept interaction and animation logic independent from the timing-sensitive hardware renderer.

Software architecture diagram showing the Python control program, its state and animation threads, FIFO interprocess communication, and the C++ RGB matrix renderer.
The software architecture: Python owns behavior and state; C++ owns the hardware display path; a FIFO connects the two processes.

The team

Ding Yang designed the mechanical enclosure and transition effects; Keyun Gao developed the IMU-driven snow simulation and helped integrate the hardware. I owned the software architecture, implementation, and end-to-end integration.

Full demo

The working prototype in the lab. This local copy replaces the video that no longer loads on the original course page.

Original project

Read the full Cornell project report or browse the source code on GitHub.