Final Project Journal

The idea of my project started about two years ago when I came across a YouTube video by the amazing Tomas Burns, where he showcased his little robot friend Alexatron. I was blown away by how alive the robot felt — the way it moved, “thought,” and especially the way it looked. The most captivating part for me was the animatronic eyes. Even though the eyes weren’t actually seeing anything, they looked so realistic that they gave the robot a sense of life. That left a big impression on me, and from that moment I knew I wanted to make something similar one day.

When I joined the Maker Diploma, I immediately thought back to Alexatron. I couldn’t build the full robot, but I decided to focus on the animatronic eye. The challenge was figuring out how to implement it — I didn’t just want to build eyes and stop there, I wanted to integrate them into something meaningful.

That’s when I stumbled upon another inspiring creator, Esser50k, and his amazing Halloween project. His idea of using just one animatronic eye on a pumpkin sparked a new direction for me. Instead of making a pair of eyes for a humanoid robot, I decided to use a single animatronic eye as the centerpiece of a game. That was the turning point, and from there my project “Follow the Eye” was born.

To make it more fun and engaging, I gave the project an arcade-style twist. Rather than just building the eye for display, I designed a game called “Follow the Eye.” The idea was to blend the realistic animatronic movements with an interactive, arcade-themed experience that challenges players and makes the project feel like something you could actually walk up to and play. 

The design process of my project began with shaping the game concept itself. The initial idea was to place the animatronic eye at the center, surrounded by eight LEDs representing eight different directions that the eye could look at. Between the eye and the LEDs, I wanted to add an LED matrix to give the whole project a retro arcade game feeling.

On paper, this looked simple. But once I calculated the actual requirements, it turned out to be very complex: the project would require 56 LEDs in total, in addition to the eye mechanism, an LCD display, and the game controller. This would have pushed the project far beyond the capabilities of the Arduino Uno.

To keep the project feasible, I decided to simplify the design. Instead of eight directions, I reduced it to four sides. The matrix was also replaced with addressable RGB LED sticks, which gave me the same retro arcade effect with much fewer connections. With these changes, the project became much simpler while still fitting within the limitations of the Uno.

Once the scale was settled, I moved to the CAD design in Fusion 360. I split the design into three phases:

1. The eye mechanism

2. The enclosure

3. Coloring and finishing

Eye Mechanism

At first, I thought this would be straightforward. I planned to take the STL designs from Esser50k’s open-source files, print them directly, and assemble. But I quickly realized I needed accurate dimensions to integrate the mechanism into the enclosure.

This process was repeated for all eight parts of the eye assembly

Once I had them as solid bodies, I built the assembly in Fusion using different types of joints (revolute, as-built, etc.) until i noticed that there was an important part missing and that is the servo so i jumped into grab cad and downloaded it then assembled the mechanism until it worked properly. Only then did I export the parts for 3D printing. Now I had a functional eye assembly as a reference to design the enclosure around.

Enclosure Design

For the enclosure, I initially debated between a regular square and a tilted diamond shape. I eventually chose the diamond because it gave the project a more “arcade machine” aesthetic. The enclosure consisted of 11 parts, all joined together with screws and nuts using T-slots.

Sides → Six panels of equal height, with cutouts for the power input jack and main on/off switch. To ensure accuracy, I imported models of components from GrabCAD, which helped me size the cutouts perfectly for laser cutting.

Control panel → Designed at an inclined angle, holding the LCD, push button, and joystick. Again, I used GrabCAD models to make sure everything fit neatly.

Top part → The most challenging part of the chassis. The LED sticks I used had unusual light output, so I needed a way to diffuse the light properly.

I solved this by designing the top in three layers:

1.Base layer → Similar to the bottom panel but with cutouts for LED sticks, direction LEDs, and the eye hole.

2.Mid diffuser layer → Originally planned with acrylic, but light didn’t diffuse well through colored sheets. Transparent acrylic also didn’t work, as it looked too raw. Here, our lab coordinator Dina suggested using colored file sheets as diffusers. These were thin, flexible, and vibrant enough to let the light pass through beautifully.

3.Frame layer → A top frame designed to firmly hold the colored diffuser sheet in place.

With this layered approach, the enclosure not only became practical but also achieved the retro arcade look I was aiming for.

Coloring and Finishing

After finishing the structural design, it was time for the easiest and most fun part: coloring. I experimented with different material presets and colors in Fusion 360 until I finally settled on a gold and black color scheme. This combination gave the project a bold, striking, and professional arcade-style look that really made the design stand out.

When the parts came out, I performed a quick fit test—and everything matched perfectly. With the structure ready, I moved on to coloring. The raw wooden look wasn’t convincing enough, so I applied a black and gold theme I had settled on earlier in Fusion. The first layer of paint didn’t meet my expectations, so I added a second coat, which looked amazing. To highlight the details, I used a metallic gold marker on the exposed edges and the tongues of the T-slots. This gave the enclosure a polished, arcade-inspired aesthetic.

Next came the animatronic eye. I sliced the STL files in Cura, carefully setting the printing parameters to ensure rigidity since many parts would be moving and interacting. The full print time was around seven hours—too long—so I split it into two files.

Once the first batch was printed, I noticed the servo slots and ball socket joints were too tight. With the help of my peer Mustafa, I used a file and sandpaper for post-processing until the pieces fit smoothly. The assembly worked perfectly after this adjustment.

To give the eye more realism, I added small details. The eyelashes were suggested by my peer Malak—an idea I initially doubted but which turned out to look fantastic.

The eyeball itself was the real challenge. At first, I tried a ping pong ball, but it was too large. Then inspiration struck: I reused the roller ball from a deodorant bottle. After cleaning and cutting it, I found it fit perfectly!

Painting the eyeball was another key step. Although I had painted the cardboard prototype myself, I wasn’t fully satisfied. So, I collaborated with my peer Mohamed Hazem, an artist, to hand-paint the eye based on reference images I provided.

He first tested his painting on a replica and then moved to the final eyeball.

The result was hyper-realistic, but something was still missing—the glossy shine of a real eye. Resin was too expensive, so I used super glue with a spray activator, which dried clear and gave a perfect glossy finish. Once glued onto the 3D-printed holder, the eye looked alive and incredibly realistic.

Finally, I added a diffuser, originally cut from a simple plastic file sheet, an idea suggested by Dina. I fitted it between the frame and the top cover, trimming the excess until it looked clean and professional.

In the end, the fabrication process transformed a digital design into a polished, arcade-themed animatronic eye game. Every step—laser cutting, 3D printing, painting, post-processing, and creative problem-solving—brought the project to life.

The electronic circuit of the game is relatively simple yet effective, designed to integrate all the interactive and visual elements into one cohesive system.

At the core of the system is the Arduino Uno, which acts as the main controller. It processes inputs from the user and sends signals to the action components. To manage the multiple servos needed for the eye mechanism, I used a PCA9685 16-channel servo controller, which expands the Arduino’s PWM capabilities and ensures smooth and accurate servo movements.

The four servos are responsible for the animatronic eye’s motion, allowing it to move realistically in different directions. User control is provided by a joystick (for directional movement) and a push button (for triggering actions in the game).

For visual feedback, the circuit includes:

• Four individual LEDs, each connected through 220 Ω resistors to protect them from overcurrent.

• Three NeoPixel RGB LED sticks, which bring dynamic lighting effects and arcade-style visuals to the project.

• An LCD with I2C interface, used to display game information and feedback to the player.

Power is supplied through a female DC jack connected to an adapter, with a switch included to turn the system on and off easily. A small breadboard and jumper wires were used for quick prototyping and connections between the components.

Together, these components form a smart interactive system:

• Inputs (joystick + push button) are read by the Arduino.

• The Arduino processes these inputs and outputs signals to the servos, LEDs, NeoPixels, and LCD.

• The servo controller ensures smooth motion of the animatronic eye.

• The lighting and display components provide real-time game feedback and create an arcade-themed experience.

1. Libraries & Setup
I used four key libraries:

• Wire.h for I2C communication.

• Adafruit_PWMServoDriver.h to control the PCA9685 servo driver.

• Adafruit_NeoPixel.h to control the RGB LED sticks.

• LiquidCrystal_I2C.h to display game messages and scores on the LCD.

In setup(), all components are initialized, including servos, LCD, joystick pins, LEDs, and NeoPixels. The LCD first shows “Eye Game Ready” before entering the menu.

2. Servo Control Functions (Eye Movement)

• safeAngle() and angleToPulse() keep servo angles within limits and map them to PCA9685 pulse widths.

• setServo() sends the pulse to the correct channel.

• shuteye(), openeye(), and blinkEye() simulate natural eyelid movement.

• randomEyeMovement() moves the eye randomly for 1.5 seconds before starting a round.

• lookDirection(int dir) makes the eye look in one of four fixed directions (North, East, South, West).

3. LED and NeoPixel Functions (Game Feedback)

• showTargetLED(int dir) turns on one of the four direction LEDs to match the eye’s gaze.

• clearTargetLEDs() resets all LEDs.

• showPixels(color) fills the NeoPixel sticks with a chosen color.

• pixelFlash(color, times) flashes the NeoPixels in red (wrong input / game over) or green (correct input / score increase).

4. Game Logic

• startRound() begins a new round: the eye moves randomly, then settles in one of the four directions, the corresponding LED lights up, and a timer starts.

• checkJoystickDir(int dir) checks if the joystick is pushed toward the correct direction.

• playGameMode(int mode) manages the reaction time and scoring based on the selected difficulty. If the player reacts correctly and quickly, their score increases. If they are wrong or too slow, the score resets and a “Game Over” or “Wrong” message is shown.

5. Menu System
The game starts in a menu (inMenu = true), where the player can:

• Use the Mode Button (btnMode) to cycle through the three difficulty levels: Easy (3 seconds), Normal (2 seconds), and Hard (1 second).

• Press the Joystick Switch (pinSW) to confirm and start the game.

During gameplay, pressing the joystick switch again exits to the menu.

6. Main Loop

The loop() function switches between menu mode and gameplay mode. In menu mode, the LCD shows the available difficulty. In gameplay mode, the program runs playGameMode() and continuously updates the eye, LEDs, NeoPixels, and LCD according to player input. 

To integrate the modules of the project, I began with the mechanical part by assembling the eye mechanism and mounting it securely onto an L-shaped plywood piece fixed to the base of the enclosure.

Once the structure was stable, I connected the servos to the PCA9685 servo driver and uploaded a simple test code. This allowed me to verify that each servo responded correctly, and the results were positive — the eye mechanism moved smoothly and precisely.

After confirming the mechanical side, I shifted to the electronics. I carefully wired the circuit components together, ensuring the layout was as neat and stable as possible to reduce loose connections. The Arduino Uno, servo driver, NeoPixel sticks, joystick, LEDs, push button, and LCD were all interconnected according to the design. I then uploaded the main code and ran small functional tests at each stage.

The testing results showed that all modules — the eye mechanism, servos, LEDs, joystick, and display — worked in harmony as expected. The eye followed the intended directions, the feedback through LEDs and NeoPixels was clear, and the game logic ran smoothly. The setup not only functioned correctly but also looked polished and arcade-like inside the enclosure.

Throughout the project, I actively asked for feedback from my peers and mentors, and many of their suggestions had a real impact on the final outcome. For example, the idea of adding eyelashes to the animatronic eye came from my peer Malak. At first, I thought it was unnecessary, but after trying it, I realized it gave the eye much more character and life — it turned out to be one of the best additions.

Another major contribution came from our lab coordinator Dina, who suggested using colored file sheets as diffusers instead of acrylic. This solved the problem of the LED light not shining brightly enough through acrylic and gave the project a much cleaner and arcade-like look.

I also collaborated with my peer Mohamed Hazem, who is an artist, to paint the eyeball. I initially tried painting it myself but wasn’t satisfied with the result. With his skills, we achieved a realistic, detailed, and glossy finish that brought the whole project to life.

On my side, I supported my peers by helping with sanding and post-processing their 3D printed parts, as well as giving advice on Fusion 360 assembly techniques that I had learned while working on the eye mechanism.

This back-and-forth exchange of feedback and help was one of the highlights of the project. It not only improved the quality of my own work but also created a collaborative environment where we all benefited from each other’s strengths.

NeoPixel LEDs Not Lighting Up

• Problem: The NeoPixel strip did not respond to test code.

• Solution: The LEDs required a stable 5V supply with common ground shared with the Arduino. After correcting the wiring and ensuring sufficient power, the NeoPixel strip lit up correctly.

Looking back, the biggest lesson is that you should always expect to iterate and adapt. Mistakes are part of the process, and being flexible enough to try different approaches (and sometimes unconventional solutions) is what keeps the project moving forward. My advice to others would be: double-check component sizing early, make sure power sources are common and stable, and always leave time for post-processing and adjustments. 

If I had more time to develop this project further, I would integrate a sound system to provide audio feedback and make the overall experience more engaging. I would also add a free control mode that allows the player to move the eye freely, giving them more flexibility and interaction outside the structured game mode. Additionally, I would enhance the light matrix to make it more interactive with the game, such as using dynamic light patterns or animations that respond in real time to the player’s actions. These improvements would elevate the project from being purely functional to becoming more immersive and entertaining.