For my final project, I had my friend Taif and few others test out my Arduino-based bomb defusal game. Overall, the feedback was quite positive and also highlighted some good areas for improvement.

All of the players were able to figure out the core mechanics pretty quickly. The buttons worked smoothly and felt responsive. Most people could navigate the game on their own without much explanation, which was great to see. The Button Smash, Note Match, and Morse Code modules were especially well-received and fun for the players.

One thing that confused some users was the Math Riddle module. The instructions weren’t as clear for that one, such as how to choose the answer, and players weren’t sure what to do at first. Another part that could be improved is the final code entry step – it wasn’t obvious to everyone when or how they were supposed to enter it.

Some suggestions I got were:

• Add better instructions at the start for each game or stage.

• Make the countdown more dramatic and obvious with more frequent or intense LED flashing near the end.

Things to be implemented : LED lighting for more visual feedback and a more visible timer, also I feel l might reduce the overall time to solve the puzzles since users usually finished before the time ran out quite easily.

Even though some elements  weren’t implemented yet, the players enjoyed the concept and the tension of the timer. Overall, user testing helped me find small tweaks to make the game smoother and more fun.

User Testing Video : https://drive.google.com/drive/folders/1tCRKILVrXj7VhVwkL0nhwQ5oa913earC?usp=share_link

Overview

This project was inspired by the retro Etch-A-Sketch with a modern twist. Instead of knobs, individuals control the drawing with two potentiometers (for X and Y movement) and a switch for toggling between drawing states. Individuals were tasked with exploring interactive hardware-software integration by translating analog sensor input into graphical visual output. After hearing questions and feedback, I aim to further improve real-time drawing accuracy and the user interface by reducing latency, refining the toggle function, and thinking about how to better intuitively represent drawing progress.

Video Link: https://drive.google.com/file/d/10zKjQpbPppzI0duzytp0_6KQYVFO1qMh/view?usp=sharing

Strengths

1.  Utilization of the [p5.webserial] library facilitated the reading of serial data from the Arduino without the need for desktop software.
2. Potentiometers were providing accurate analog input, and mapping to screen coordinates was achieved after calibration.
3. Intuitive buttons for starting, connecting/disconnecting the port, and resetting the canvas make the experience even more seamless.
4. A new drawing color is created with each button push, creating a fun and dynamic drawing experience.

Additional Improvement

1. Provide on-screen instructions on how to connect to the Serial monitor
2. Provide instructions and indicators on the model itself (indicators of the potentiometers and button)
3. Make a small hole for the USB Type-B cable to pass through, to prevent messiness
4. Add a little cover over the model to cover up the wires in the arduino board
5. The earlier versions exhibited clear lag or delay when drawing. This was addressed by optimizing serial communication and removing the [multiple.readUntil()] calls within the draw loop.
6. The initial drawing of the red cursor was removed to avoid the distraction it caused from the artwork. It was ultimately removed for relying on the user to sense movement with the potentiometer.
7. Still some minor jitter or lag on switching draw mode. Adding smoothing or filtering noise would likely enhance accuracy.
8. The mode switch from welcome screen to the drawing view functions but may appear polished visually in usability terms for a better user experience.

Future ideas

• Add an on-screen cursor to show position without drawing.
• Add a on-screen button to save the drawing as a PNG.

Overview

Berry Blessings is an Arduino joystick-controlled p5.js game where a duck must collect 10 berries to unlock a magical portal to the real world. Once the player reaches the portal, an Arduino-powered robot is meant to activate and move toward a fairy setup, creating a double world experience.

After receiving feedback that the previous storyline was too abstract and difficult to understand, I redesigned the narrative to be more intuitive and enjoyable. The new version provides a clear goal which is collecting berries to unlock a portal and eventually a satisfying real-world reward.

Two users participated in a no-instruction playtest of the p5.js portion of the game.

What Worked Well

• Joystick Controls: Users figured out joystick movement after some experimentation. Movement felt smooth once they adjusted to it.

• Berry Counter: The on-screen “Berries: X / 10” counter gave clear feedback and helped users understand progression.

• Visual Design: The duck animations, bright environment, and sign reading “Collect 10 berries to pass” helped anchor the gameplay and made objectives more understandable.

• Revised Storyline: The updated goal and real-life payoff made the experience feel more engaging and easier to follow.

Challenges & Observations

• Joystick Direction Mapping: Both users were initially confused by which way the duck would move relative to joystick direction.

  Planned fix: Add visual direction indicators (e.g. arrows or compass).

• Robot Frustration (During Earlier Testing): Friends testing the robot portion before the Arduino broke reported frustration with its slow, unstable movement.

  Plan: Replace with a more reliable wheeled robot for smoother performance.

• Duck Centering Bug: One user pointed out that the duck appeared too far from the center when changing directions.

  Fix: Adjusted duck positioning to remain centered during direction changes.

• Hardware Damage: The Arduino Uno was accidentally damaged due to adjusting connections while powered on, so it could not be used during this round of user testing.

Fixes & Next Steps

Already Implemented:

• Rewrote the story to improve clarity and engagement.

• Added a sign by the portal to explain the berry objective.

• Included a working berry counter.

• Fixed duck position offset when changing directions.

In Progress:

• Sourcing a new Arduino Uno to replace the damaged one.

• Planning to switch to a wheeled robot for improved reliability.

• Will add visual joystick direction indicators to help users orient themselves.

I will post an update before next class once the hardware is replaced and re-integrated.

Project concept

This project was inspired by a real experience on my family’s farm—I saw foxes approaching our chickens at night, and my dad was complaining on how to deal with the situotion it made me think about how to create a simple way to detect movement at a low cost and respond immediately. I wanted something that could work without constant supervision, so I came up with the idea of using an ultrasonic sensor and lights to react when something gets close.

From there, I built a mini garden setup using individual RGB LEDs and connected it to P5.js for visual feedback. I started with a different idea—using sound and an LED strip—but changed direction after facing hardware limitations. and honestly I love how it turned better. That process helped shape the final concept,i also wanted to create something similar to lava lamps that’s why ii ended up doing the visuals in p5.js similar to the blobs in the lava lamps which now works as both an interactive installation and a practical assistive device for animal and crop protection.

My final project is the Motion-Activated Mini Garden/farm Visualizer, an interactive installation that responds to movement and presence using an ultrasonic sensor. – house and the garden I built . When someone approaches the garden, the LEDs light up based on proximity—closer movement causes brighter, more vibrant lights, while standing farther away results in dimmer, calmer effects.

-blue is for far away

-green in for in the middle

-red is for very close

The schematic digram:

Aruidno code:

// HC-SR04 Ultrasonic Sensor Pins
#define TRIG_PIN 7
#define ECHO_PIN 8

// RGB LED Pins
#define RED_LED_PIN 3
#define GREEN_LED_PIN 5
#define BLUE_LED_PIN 6

long duration;
int distance;

void setup() {
  Serial.begin(9600);

  // Sensor Pins
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);

  // RGB LED Pins
  pinMode(RED_LED_PIN, OUTPUT);
  pinMode(GREEN_LED_PIN, OUTPUT);
  pinMode(BLUE_LED_PIN, OUTPUT);

  turnOffAll(); // Ensure LEDs are off initially
}

void loop() {
  // Trigger the ultrasonic sensor
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);

  // Read echo and calculate distance (cm)
  duration = pulseIn(ECHO_PIN, HIGH);
  distance = duration * 0.034 / 2;

  // Print distance to serial
  // Serial.print("Distance: ");
  Serial.println(int(distance));
  // Serial.println(" cm");

  // LED logic based on distance
  if (distance < 10) {
    setColor(255, 0, 0);   // Close → Red
  }
  else if (distance >= 10 && distance <= 30) {
    setColor(0, 255, 0);   // Medium → Green
  }
  else {
    setColor(0, 0, 255);   // Far → Blue
  }
  delay(100);
}

// Control RGB LEDs using digital logic
void setColor(uint8_t r, uint8_t g, uint8_t b) {
  digitalWrite(RED_LED_PIN, r > 0 ? HIGH : LOW);
  digitalWrite(GREEN_LED_PIN, g > 0 ? HIGH : LOW);
  digitalWrite(BLUE_LED_PIN, b > 0 ? HIGH : LOW);
}

void turnOffAll() {
  digitalWrite(RED_LED_PIN, LOW);
  digitalWrite(GREEN_LED_PIN, LOW);
  digitalWrite(BLUE_LED_PIN, LOW);
}

p5.js code:

let serial;
let distance = 0;

function setup() {
  createCanvas(windowWidth, windowHeight);
  background(0);

  serial = new p5.SerialPort();
  serial.on('connected', () => console.log("Connected to Serial!"));
  serial.on('data', serialEvent);
  serial.open("/dev/tty.usbmodem101"); // Change to your actual COM port
  console.log();
}

function draw() {
  background(0, 30);

  // let size = map(distance, 0, 1023, 10, 100); // Adjust if your micValue goes up to 1023
  let size = 30;
  let col;
  if (distance < 10) {
    col = color(255, 0, 0); // Low
  } else if (distance < 30) {
    col = color(0, 255, 0); // Medium
  } else {
    col = color(0, 0, 255); // High
  }

  fill(col);
  noStroke();

  for (let i = 0; i < 20; i++) {
    ellipse(random(width), random(height), size);
  }
}


function serialEvent() {
  let data = serial.readLine().trim();
  if (data.length > 0) {
    distance = int(data);
    console.log("mic:", distance);
  }
}

A short clip showing someone approaching the mini garden. As they move closer, the LED lights respond by changing color, and the screen displays animated, color-shifting blobs in sync with the movement:

https://drive.google.com/drive/u/0/folders/1Kk2lkQgoAyybXSYWVmY2Dog9uQVX_DMq

The process:

How does the Implementation work

An ultrasonic sensor detects how close a person or object is to the garden. This distance value is read by the Arduino and mapped to RGB LED colors. The same data is also sent over serial communication to P5.js, which animates abstract blobs on the screen. These blobs shift in speed, size, and color based on how close the user is, creating a consistent and engaging visual language that mirrors the physical lighting

interaction design :

The design of the project relies on intuitive interaction. Users are not given instructions—they are simply invited to explore. As they move closer to the garden, the changes in light and digital visuals guide them to understand the system’s behavior. This makes the experience playful and discoverable.

Link to video : https://drive.google.com/file/d/1wrsx0LpX8-KULwrtQ7UhdwTtWr0vSpkc/view?usp=sharing

To evaluate the user experience of ExpressNotes, I conducted testing sessions where participants interacted with the system without receiving any instructions or guidance. The goal was to observe how intuitive the system is and identify any points of confusion. Users were introduced to the setup with the Arduino buttons, potentiometer, and the connected P5.js visual interface on a laptop. Most users hesitated at the beginning, unsure of how to begin the interaction, with the “Connect to Arduino” button being overlooked by several participants.

Once the connection was established and users began pressing buttons, they quickly recognized that each button triggered a unique piano note along with a visual effect on the screen. This immediate feedback created a sense of play and curiosity, and users began experimenting more confidently. The relationship between physical input and audiovisual output was generally clear, although the specific mappings between notes and visuals were not always understood without further exploration or explanation.

The potentiometer was another area where users expressed confusion. While some participants guessed that it controlled volume, others assumed it affected brightness or visual intensity. The lack of on-screen feedback for the potentiometer made its purpose harder to identify. Adding a visual indicator—such as a dynamic volume bar—could significantly improve clarity and reinforce the connection between the physical control and the system’s response.

One common suggestion from users was to enhance the physical design of the interface. Several participants mentioned that the Arduino board and buttons looked too technical or unfinished. They recommended covering the board with a piano-style overlay so the buttons resemble piano keys. This would not only make the device more visually appealing but also give immediate context to new users, helping them understand that the interaction is musically driven.

ExpressNotes was well received as an interactive and expressive experience. Users enjoyed the audio-visual feedback and were intrigued by how the visual patterns changed with each note. However, clearer onboarding, labels for controls, a visual volume indicator, and improved hardware presentation would help users engage more quickly and confidently. These observations will guide improvements to make the project more accessible, intuitive, and enjoyable for first-time users.

Concept

For my final project, I developed an interactive flocking simulation that users can control through hand gestures captured via their webcam. The project uses computer vision and machine learning to detect and interpret hand positions, allowing users to manipulate a swarm of entities (called “boids”) by making specific hand gestures.

The core concept was to create an intuitive and embodied interaction between the user and a digital ecosystem. I was inspired by the natural behaviors of flocks of birds, schools of fish, and swarms of insects, and wanted to create a system where users could influence these behaviors through natural movements.

Demo: