Context beforehand from my side:

For this IM Project, as I wanted to emulate the vibe of an Escape Room I deliberately didn’t make it as obvious what was supposed to be done. When you try to solve a puzzle, obviously you’re not supposed to spoonfeed the answer so I kept it kind of vague as to what was needed to be done. For my user testing, I asked my sister to try it out and see how she felt about it. But what I also should mention is that, she didn’t have really any knowledge of what Tinkercad is and its various components, so she went in completely blind.

Video of the User Testing (My sister):

Feedback from The User Testing:

In the end, she was able to figure it out on her own. From her feedback to me, she mentioned that she didn’t understand what each component meant. She understood the keypad and from prior knowledge, knew she needed to enter a code, however she did not know what the LED was or what its function was. She did in fact understood that she could twist and turn the potentiometer, but after she played around with them a little bit.

I think the experience overall is working well. The connections between components worked out and all of the components reacted on time. In terms of any imporvements, if I’m honest I think you could definitely add something that’s much more visually appealing like an LCD screen, however I faced issues with it and also didn’t understand how to connect all of it to the Arduino Uno so I omitted it in place of the serial monitor. And another thing, I think if there were more components added, then the experience wouldn’t be as mysterious for it’s own little puzzle to solve.

From parts I needed to explain, it was mostly grounded in telling her what each component was as she did not have any idea what they were. For any new user that might not be well versed in Tinkercad, that would definitely be a common problem. But I think the best way to mitigate this, is to simply have speech bubbles or a list of instructions (most likely in the description of the Tinkercad Project), explaining the main goal and the options the user can do to reach it. In this case of this, the end goal would be to figure out the code, and the user will be told what each component does and that they’re able to twist the dial and enter a code on the keypad.

Building a Theremin-Style Musical Instrument with Arduino

For this week’s assignment, I built a simple musical instrument using an Arduino SparkFun RedBoard. The goal was to make something you actually play in real time, not just a melody that runs on its own.

The Idea

I wanted the instrument to feel intentional. You turn a knob to pick a pitch, then press a button to sound it. Release the button and it goes silent. It is a small but satisfying loop that mimics the feel of a real instrument. The design was loosely inspired by a theremin, where pitch is continuous and the player decides when to trigger sound.

Components

The build uses five parts: a SparkFun RedBoard, a piezo buzzer, a 10k ohm potentiometer, a tactile push button, and a breadboard with jumper wires. The potentiometer is the analog sensor and the button is the digital sensor, which together satisfy both requirements for the assignment.

Demo

The Code

The sketch reads the potentiometer value on every loop, maps it to one of 22 notes across a C major scale from C3 to C6, and plays that note with tone() only while the button is held down. No extra libraries are needed beyond pitches.h for the note frequencies.

#include "pitches.h"

const int BUZZER_PIN = 8;
const int BUTTON_PIN = 2;
const int POT_PIN    = A0;

int scale[] = {
  NOTE_C3, NOTE_D3, NOTE_E3, NOTE_F3, NOTE_G3, NOTE_A3, NOTE_B3,
  NOTE_C4, NOTE_D4, NOTE_E4, NOTE_F4, NOTE_G4, NOTE_A4, NOTE_B4,
  NOTE_C5, NOTE_D5, NOTE_E5, NOTE_F5, NOTE_G5, NOTE_A5, NOTE_B5,
  NOTE_C6
};
const int SCALE_SIZE = sizeof(scale) / sizeof(scale[0]);

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  Serial.begin(9600);
}

void loop() {
  bool buttonHeld = (digitalRead(BUTTON_PIN) == LOW);
  int  potValue   = analogRead(POT_PIN);
  int  noteIndex  = map(potValue, 0, 1023, 0, SCALE_SIZE - 1);
  int  currentNote = scale[noteIndex];

  if (buttonHeld) {
    tone(BUZZER_PIN, currentNote);
  } else {
    noTone(BUZZER_PIN);
  }

  delay(20);
}

How It Works

The potentiometer outputs a voltage between 0V and 5V as the knob turns. analogRead() converts that into a number from 0 to 1023, and map() scales it down to an index between 0 and 21, selecting a note from the scale array. The button uses Arduino’s built-in INPUT_PULLUP setting, so it reads HIGH when open and LOW when pressed, with no external resistor required. While the button is held, tone() drives the buzzer at the selected frequency. Letting go calls noTone() and the sound stops immediately.

Reflections

The trickiest part was getting comfortable with the breadboard layout. Once that clicked, the wiring became straightforward. If I were to extend this project, I would add a second button to switch between different scales, which would open up more musical variety without much added complexity.

Learning Tinkercad, I built a Harry Potter theme song musical instrument that uses both digital and analog sensors to play the iconic melody. The PIR motion sensor (digital) detects when someone is nearby to trigger the song, while the potentiometer (analog) allows dynamic control over the playback speed and pitch variation, creating an interactive magical experience.

Check the Tinkercad here: https://www.tinkercad.com/things/7rPWu9K1P2T/editel?returnTo=%2Fdashboard&sharecode=CMCKEgjwUaqW1OCp9xhFPli3PX6svXP-iPPxgq9R69U

Digital Circuit

The circuit is built on a breadboard connected to an Arduino Uno. The design features: PIR Motion Sensor connected to Digital Pin 2 – detects motion to trigger song playback, Potentiometer connected to Analog Pin A0 – adjusts playback tempo/pitch modulation, Piezo Buzzer connected to Digital Pin 8 – outputs the Harry Potter theme frequencies, Power connections from 5V and GND to the breadboard power rails

The PIR sensor acts as a motion detector-when someone waves their hand over it, the circuit recognizes movement and initiates playback of the Harry Potter theme. The potentiometer serves as a control dial; turning it varies the speed at which notes are played or adjusts the pitch offset, giving the player expressive control over the melody.

PIR detection → Read potentiometer value → Play frequencies on buzzer.

Highlighted Code Snippet (Proud of This!)

// PIR sensor triggers playback
if (pirSensor == HIGH) {
  int tempo = map(potValue, 0, 1023, 200, 600);  // Potentiometer controls speed
  
  for (int i = 0; i < melodyLength; i++) {
    int notePitch = melody[i] + pitchOffset;  // Add potentiometer-based pitch variation
    tone(buzzer, notePitch, tempo);
    delay(tempo);
  }
}

The map() function elegantly connects the analog potentiometer reading to playback tempo, so rotating the dial smoothly speeds up or slows down the song. This creates a responsive, instrument-like feel rather than fixed playback.

int pirSensor = 2;
int potentiometer = A0;
int buzzer = 8;

// Harry Potter theme frequencies (simplified)
int melody[] = {294, 330, 392, 440, 494, 523, 587, 659};
int melodyLength = 8;

void setup() {
  pinMode(pirSensor, INPUT);
  pinMode(buzzer, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  int motionDetected = digitalRead(pirSensor);
  int potValue = analogRead(potentiometer);
  
  if (motionDetected == HIGH) {
    int tempo = map(potValue, 0, 1023, 150, 500);
    int pitchOffset = map(potValue, 0, 1023, -50, 50);
    
    for (int i = 0; i < melodyLength; i++) {
      int notePitch = melody[i] + pitchOffset;
      tone(buzzer, notePitch, tempo);
      delay(tempo + 50);
    }
    noTone(buzzer);
  }
}

Reflection

This project taught me how digital and analog sensors complement each other. The PIR sensor provides binary input (motion yes/no), while the potentiometer gives continuous analog data for fine-tuning. I was initially unsure if the PIR sensor would register properly in simulation, but discovered that sensor sensitivity is crucial – sometimes you need to calibrate which digital pin captures the signal. The biggest challenge was mapping the potentiometer smoothly to tempo without the song becoming too fast or choppy. Using Arduino’s map() function solved this.

Screen Recording 2026-05-01 at 12.13.31

 

Music Producer Progress

For this stage of the project, I actually went from just having an idea to having something that works, and that honestly changed how I see everything. Before, it all sounded pretty simple in my head, but once I started actually connecting p5.js with Arduino and dealing with real inputs, I realized how much the interaction itself matters. It’s not just about making things work, it’s about how they feel when you use them.

Right now, the core system is already working. I can record audio directly in p5, save multiple recordings, select one and have it loop, and then change its pitch in real time using the potentiometer. The Arduino buttons are also working, and depending on the mode (piano or drums for now), they trigger different sounds. On top of that, the audio is being visualized as a waveform that reacts live, which already makes everything feel more alive. It’s still pretty raw visually, but it already feels like a mini music tool. I’ll include a video demo showing how it works so far, and also the schematic of the Arduino setup.

The hardest part by far was getting p5.js and Arduino to actually connect. At first, nothing worked. The port wouldn’t open, the sketch wouldn’t connect, and I kept getting errors even though the Arduino code itself was fine. I tried different approaches, switching between p5.serialport and web serial, closing and reopening ports, checking permissions, restarting my computer, and even simplifying everything just to test if anything would connect. It took a while, but once it finally worked, everything else became way easier. That was definitely the moment where the project clicked for me.

Another thing that was tricky was making the buttons have different meanings depending on the mode. It sounds simple, but structuring it cleanly took some thought. I ended up designing it so Arduino only sends raw data, and all the logic happens in p5. That separation made the system way more flexible and easier to expand.

One thing I’m actually really proud of is how the mode system works. Instead of having a lot of controls, I have one set of buttons that changes function depending on whether you’re in piano, drums, or later bass mode. It keeps everything simple but still powerful. I also really like the recording system. Each recording gets saved in an array, and you can select it, loop it, deselect it, and change its pitch whenever you want. The fact that the pitch isn’t fixed and is controlled live by the potentiometer makes it feel much more interactive. The waveform visualization using FFT is also something I like, because even though it’s simple, it already makes the connection between sound and visuals feel real.

There’s still a lot to improve though. I still need to add the bass sounds, design the interface better, and make everything feel more intentional visually. Right now it works, but it doesn’t fully feel like a finished experience. I also want to add a clearer instruction/tutorial section, fix some timing issues with the sounds (some feel slightly delayed), and clean up the audio files, especially for piano and drums. Another big thing is allowing instrument sounds to also be recorded and looped, not just the voice. And visually, I want each element (voice, beats, piano, bass) to look different and more meaningful.

Now that the technical foundation is working, I feel way more confident moving forward. Before, I was mostly worried about whether I could even connect everything and make it function. Now that I’ve solved that, I can actually focus on making it feel good to use. My next steps are refining the interaction, improving the visuals so they’re less generic, making the controls more intuitive, and adding more layering so the final compositions feel richer.

SCHEMATIC LINK

VIDEO OF HOW IT’S WORKING

“A richer balance between problem solving and more playful explorarion could open up valuable new directions”

I really liked this reading and it really brought me a lot of interesting idea about the design of things.

First of all, when the author writes about disability and design for it, I think that the trend in this sphere that he describes is really traceble right now. He talks about glasses that made the “disability” treatment a universal accessory. Nowadays a lot of people wear glasses with no lenses or with no vision correction, and glasses are seen as a part of style. When I told my family I want some nice-looking glasses (that I wear for vision correction), my parents told me that in their childhood you would get laughed at and mocked for wearing them. And now this is a trend. I have to say that not a long while passed since their teenage, so this is really interesting how the perspective changes over the years. Additional, maybe more subtle “disability” to an extent, is teethwear. People use different things to cure their teeth/jaw, and also, I know that in my parents’ childhood it also was something people would laught at you for. Now people wear grillz, tooth gems, fashion fake braces, and this again shows how something evolved from disability to fashion.

I believe that bringing fashion and style in things like that is really important. It allows people with disabilities like that not to stand out in a bad way, it allows them to not be scared and insecure of their peculiarities. Protheses that are shaped in some beautiful forms or that are looking cool are all around now: I saw so much very cool looking leg and arm protheses on social media. However, this is also important to not cross the line: some things should kind of distinguish people with real disabilities from people who wants to be fashioable in a way just for safety reasons. It is important to know who needs some help or accomodations, and who is totally alright.

 

As for design simplicity, I also agree a lot with the author. I feel like most designs of technology are pretty simple but not always very accessible, especially for people with some special needs. Beside Apple, I think a lot of tech companies and developers adopt this philosophy. PS4 and PS5 are really simply designed: sleek silouhette with minimal distractions. But, such minimalism can cause a lot of confusion, where’s the buttons, how to insert the disk, how to turn it on, and how to connect the controller. It is not intuitive to someone who sees it for the first time. But the design is very simple, though I wouldn’t say it’s super accessible or universal.

On the other hand, there are devices that are not very simple but very accessible. Headphones like ones from JBL which has some icons on every button on the right side earphone: super intuitive and useful. And even like that, it is probably not the most accessible piece for left-handed people.

I think a lot of thought is needed to make the design simple, intutitve, and accessible at the same time. Even if it turns out out not to be “all things to all people”, if it “some things for some people” it is successful already. However, I think it is also worth mentioning that simplicity is not always the best choice. I think that sometimes more burdened and robust, complex designs can be both accessible and exteremely good. In the world where everything simplifies and is minimalistic it’s really important to not forget that something more pompous can be simple and accessible too.

Concept:

Something I adore doing for fun is solving escape rooms with friends. While my escape/loss ratio is good enough😉, I was inspired a lot by the locks I see in escape rooms. My favorite part of the escape rooms is when you solve the puzzles and go to the next room by unlocking the lock. Usually you find a string of numbers from a different puzzle and then twist the lock to unlock it. But I wanted to flip the concept, and try by twisting the dials, to find the combination and enter it in to “escape”. So that’s how my idea came about pretty much haha.

Implementation:

The project will be completely done in Tinkercad and will utilize a few old things that we’ve seen on class but also a few new things I wanted to try out.

The way how the game would work is, each Potentiometer will act as a lock you can twist around (from this point, I’ll refer to the Potentiometers as ‘locks’).

Each lock will have a value you have to get. Now on the LCD Display I’ll have the current value that the user is twisting displayed. Then once the user twists to the right value, the Piezo will make a beep. But for the value to be correct and locked in, the user needs to twist it, listen to the sound and press the button. If the value is correct, then the LED will light up and that same value will be displayed on the screen.

From what I’ve researched, the Potentiometer can have values from 0 to 1023. But on Tinkercad, there’s an array of values that can be inputted only with mouse input.

Those values are: 0, 20, 41, 61, 82, 102, 123, 143, 164, 184, 205, 225 and so on…

Each lock will have a different value from this array of integers. When the correct value is guessed (by virtue of the LED lighting up), it will be displayed on screen. Most likely I’d do something like:

Lock 1: *the value of Lock 1*, Lock 2: *the value of Lock 2* and Lock 3: *the value of Lock 3*

After all three values have been guessed, then the user will input them on the keypad. When all three values have been entered, then a victory sound will be played by the Piezo.

Challenging parts to the Project:

I would say the most challenging part of the project is definitely understanding how to use the LCD screen and also the Keypad. I’ve not tested or played with them before but I can mitigate this by looking up the reference sheet for each Arduino part. Alongside this, I can use videos that explain these parts so I can understand how they work, but mostly so I can see how to code for them is written.

I think overall this will be a fun project to go with and experiment with these new parts in Tinkercad. Hopefully something interesting as like a minigame can come off from it.

Living in an age where everyone strives for superficial perfection (generally). With social media influencers, plastic surgery (which, don’t get me wrong, has its advantages, though when one transgresses and obsesses with plastic surgery to an unhealthy degree, it becomes a concern), and many medical procedures, striving for minimizing the appearance of a disability to conceal it.

It was a breath of fresh air to see a reading that is also bringing up elements of design for objects or utilities associated with disabilities. I remember when I myself was very young, and we would decorate and adorn the casts or bandages of classmates who had injured themselves, and was taken back to that era via this reading.

Particularly, the reading is highlighting a change from a “medical” to a “social model”, when it pertains to the design and one’s approach to disability. Two main points that the reading explores is how disabilities and design can be shaped by different perspectives in a increasingly complex world like our own, as well as how design can do more than just fix a patient, it can give them the confidence to be open about a particular disability, instead of concealing it.

For my final project, I propose building Flash Match, an phyiscal Arduino-based reflex and memory game that combines elements of Simon Says with a reaction time challenge. The game uses four coloured LEDs (red, yellow, green and blue) and four corresponding push buttons as the core interface. Each round begins with a countdown, after which the Arduino displays a sequence of flashing LEDs that grows by one light every round. The player must press the matching button for each LED in the correct order and as quickly as possible. The reaction speed directly determines the points awarded per press, with faster responses earning higher scores. A wrong button press ends the game immediately, at which point the player’s total score is shown on a LCD display . Additional components include a buzzer for audio feedback.

The most challenging part about the game is figuring out how to use the LCD display in ardruino and making sure the game feedback is quick enough to give the user a good experience.

For my final project, I want to create a digital candle that responds to natural interaction. The idea is that the candle appears on screen, flickers like a real flame, and the user can blow toward a microphone sensor to turn it off. After a few seconds, the flame slowly comes back. I chose this idea because it is familiar and calming, and it uses a very natural gesture that people already understand.

Technically, I will use a microphone sensor connected to Arduino to detect blowing. The Arduino will send this data to p5.js, where the visuals are created. The flame will be drawn using simple shapes and animation, with small changes in size and movement to simulate flickering. When the system detects a strong breath, the flame will fade out smoothly. I may also add a soft ambient sound to make the experience feel more immersive.

 

Mockups:

*Generated with CanvaAI for mockup and reference purposes only, unless otherwise stated.

Concept: As a final project, I have decided to make an infinite 2D driving game set in a desert. The player drives along an infinite stretch of highway, with tasks and layovers appearing intermittently. These objectives include passive tasks like birdwatching and buying cacti from shops on the highway, and eating at restaurants, to more complex tasks like taking up small gigs at each stop, such as cleaning dishes, cooking, and replacing car tires.

Players also have the option to customize the model, make, and color of their cars. The highway is divided into 2 lanes, with forward heading traffic in both. The player may occasionally find a slower car in front of them, and can switch lanes to overtake.

Design & Description: The style of the game is simple, with pixel art-style, simple movement and task-completion mechanics. The game’s graphics and core processing will take place on P5js, while an Arduino setup will feature a makeshift steering wheel and buttons for the controls.

Aspect Ratio: 16:9

Potentially Challenging Part: I anticipate that the most challenging part of this build would be the Arduino components, setting them up and connecting them correctly, and allowing for serial communication to occur properly between my laptop (which is not particularly known for its compatibility) and the Arduino Uno board.