Laser Light Show: Capstone Project

In my final year at Ohio University, I worked on a senior design project that required a full-stack approach to hardware and software integration. Together with my teammates—Ian Gant, Aditya Sahi, and Drew Edmonds—we developed a laser-based game console capable of projecting vector graphics, animations, and multiple playable games using precision-controlled laser beams.

The system, which we named the Laser Light Show, combined embedded systems design, analog signal processing, optics, 3D modeling, software engineering, and real-time control. We set out to design something interactive and technically novel, and we succeeded by staying grounded in first principles and rigorous testing.

🎯 Project Overview

The core idea was to steer a focused laser beam using galvo-mounted mirrors to draw images in mid-air, fast enough to leverage persistence of vision. These vector drawings would be interactive—controlled via handheld input devices—and capable of supporting full game logic.

What started as a technical curiosity evolved into a fully functional embedded console. We supported:

• Pong – a two-player implementation with paddle physics and scorekeeping
• Breakout – single-player block-breaking game
• Flappy Bird – side-scrolling obstacle navigation
• Text and Shape Demos – static and dynamic ILDA-based animations
• RBG Colors - Three colored beams where combined using a prism. Each color channel could be controlled by varying the voltage into the corresponding colored lasers

🧩 Software System Architecture

From the start, we focused on modularity, real-time performance, and low-latency control. We outgrew the Arduino IDE quickly and moved the project into PlatformIO. This allowed me to build a maintainable C++ architecture that supported the growing list of subsystems.

Key Modules:

• Pointer: Handles low-level DAC control and galvo targeting
• Graphic: Abstract class for all drawable objects (e.g., shapes, characters, ILDA)
• Demo: Encapsulates all renderable sequences—games, animations, text
• PhysicsWorld: Custom 2D physics engine for collisions, forces, motion
• GameObject: Wraps graphics with velocity, acceleration, and collision data

Every game used these shared components. For example, Pong and Breakout both relied on PhysicsWorld for real-time object dynamics. Flappy Bird used axis-aligned bounding box collisions and continuous motion physics. The flexibility of this engine enabled us to add new content rapidly in the final weeks.

🛠️ Hardware Design and Mechanical Engineering

Ian Gant led the hardware architecture and physical design of the console, with my assistance on several aspects of the system integration and prototyping Our work included:

• Designing and assembling the motherboard, integrating DACs (MCP4922), op-amps (LM324), and power regulation circuits
• Implementing analog signal processing to convert 0–5V DAC outputs into ±5V differential signals for galvo drivers
• Designing and fabricating a rigid, thermally stable laser mount using 3D-printed components reinforced with aluminum plates

  

• Engineering a custom 3D-printed enclosure that included cooling airflow, heatsinks, component cutouts, and a laser-safe optical window

The reliability of the final hardware platform was the direct result of Ian’s iterative prototyping and mechanical foresight. His diagrams, schematics, and part layouts were essential in maintaining signal integrity and thermal performance.

Check out his work here, He is an extremely smart guy and deserves credit: https://github.com/Igant01

🕹️ Input, Output, and Control

• Controller Interface
  • Originally designed for Bluetooth, but switched to serial for stability
  • Custom-built controllers featured buttons and joysticks
  • Each controller sent a fixed-length bitstring over UART, parsed asynchronously

    

• LCD Interface
  • Touchscreen menuing system with real-time screen transitions
  • Callback-driven architecture for interactive buttons and sliders
  • Displayed BMP images and supported dynamic resolution scaling

• Audio
  • Played WAV files from SD card via I2S audio codec
  • Triggered by in-game events (paddle bounce, score, win/loss)

📚 Development History

• October 2022: Project idea proposed by faculty advisor. Initial discussions focused on static vector graphics.
• November 2022: Selected Teensy 4.1 microcontroller and began research on galvanometer mirror control and laser drivers.

  

• December 2022: Built a working prototype that could draw basic shapes. Established software architecture using PlatformIO and began writing modular C++ libraries. Characters where printed from a custom-vector font built from scratch

• January 2023: Implemented DAC communication and op-amp signal conditioning. Verified analog output range and started drawing dynamic shapes.

• February 2023: Transitioned from Bluetooth to wired controllers due to interference. Designed the first version of the controller interface.
• March 2023: Integrated LCD touchscreen and built a modular menu system. Rewrote portions of the drawing logic to support frame-based demos.

• April 2023: Final system integration. Resolved thermal drift, completed ILDA streaming logic, and finalized physical assembly. Added support for multiple games and animations.

🧪 Systems Integration

Final integration was one of the most difficult stages. Several issues had to be addressed:

• Laser Misalignment: Caused by thermal expansion in 3D printed parts. Fixed with rigid aluminum reinforcement.
• Signal Timing: Synchronized SPI DAC outputs using LDAC pin for precise galvo movement.
• Case Fitment: Resolved mechanical interference between large capacitors and enclosure walls.
• Memory Constraints: Streamed ILDA frames from SD card to avoid RAM overflows.

These were all debugged incrementally. Testing and verification at the system level—hardware, software, and UI combined—was essential.

🧠 Key Takeaways

• Modular design enables scaling: A clean software architecture allowed us to extend from simple shapes to complex games.
• Start integration early: Working subsystems can fail unexpectedly when combined.
• Mechanical tolerances matter: Laser optics are sensitive to even small alignment errors.
• Reliable input is non-negotiable: Swapping wireless for wired was the right tradeoff.

🧵 Closing Thoughts

The Laser Light Show Console was both an engineering challenge and a proving ground. It combined embedded control, real-time graphics, interactive input, and hardware design. The difficulties were numerous, which is why winning first place at the expo was all the sweeter.

I’m proud of how our team executed the project from concept to demo. The result wasn’t just technically sound—it was something people could interact with and enjoy. It taught me how to handle complexity, manage risk, and build systems that work under pressure. Ian, if your reading this, Thanks for being my teammate, your a wicked smart dude! I also want to thank our advisor Dan Allwine for his sage wisdom during the project.

— Dominic Benintendi