Author: Shaikha Mhara Al Nuaimi

My Concept

My project is an interactive maze game where the player controls Minnie Mouse using two physical potentiometers connected to an Arduino. The goal is to guide Minnie through the maze, collect all the items (cheese, stars, and hearts), and finally reach Mickey Mouse at the top of the maze. The game also uses LEDs to provide physical feedback: green for winning, yellow for collecting items, and red for hitting a wall. I chose this idea because I wanted to create something a game based on characters I love, so I picked minnie mouse and mickey.

Images and Videos of the project

Images of my project:

Video of my project:

Circuit

Schematic

My schematic includes:

• Two potentiometers connected to A0 and A1.
• Three LEDs connected to digital pins 9, 10, and 11.
• 330 ohms resistors for each LED.
• Shared ground and 5V rails.

User Testing Video

The steps in my game

Start screen:

Instructions screen: 

Maze game:

After collecting the collectibles:

After reaching Mickey Mouse (The End):

How the Implementation Works

• Interaction Design:

The player interacts with the game using two physical knobs. One knob controls Minnie’s horizontal movement, and the other controls her vertical movement. The LEDs provide real‑time feedback such as yellow when an item is collected, red when Minnie hits a wall, and green when the player wins. Mickey only appears after all items are collected, and then the player has to go to Mickey to finish the maze to give the player a reward feeling at the end. 

• Arduino Code Explanation:

The Arduino code reads the two potentiometer values and sends them to p5.js so the game can move Minnie inside the maze. At the same time, the Arduino listens for messages coming from p5.js. These messages contain the number of the LED pin that should blink when something happens in the game, such as collecting an item, hitting a wall, or winning. The Arduino then blinks the correct LED several times to give physical feedback to the player. This creates a simple but effective communication loop between the hardware and the game.

• Arduino Code Snippet:

// read the two potentiometers
int val1 = analogRead(A0);   // read first potentiometer from A0
int val2 = analogRead(A1);   // read second potentiometer from A1

// send both values to p5.js in one line
Serial.print(val1);          // send first number
Serial.print(",");           // comma so p5.js can split the values
Serial.println(val2);        // send second number and end the line

• Arduino Github link: 

https://github.com/mhraalnuaimi/arduino-maze/blob/main/tiny_trails.ino 

• p5.js Code Explanation:

p5.js receives the two values sent from the Arduino and uses them to update Minnie’s position inside the maze. Each value is mapped to the correct x‑ and y‑coordinates so her movement matches how far the player turns each potentiometer. After moving Minnie, the game checks for collisions with walls, collectable items, and Mickey to decide what should happen next. When an event occurs, p5.js sends a pin number back to the Arduino so the correct LED can blink, creating a simple and responsive connection between the physical hardware and the digital game.

• P5 snippet:

let data = port.readUntil("\n");  // reads one full line of data sent from the Arduino
let fromArduino = split(trim(data), ","); // splits the line into two separate values (x and y)
let xVal = int(fromArduino[0]); // converts the first value from a string into an integer for horizontal movement
let yVal = int(fromArduino[1]); // converts the second value from a string into an integer for vertical movement
let posX = map(xVal, 3, 1020, mazeLeft, mazeLeft + mazeImage.width); // maps the x value to a position inside the maze area
let posY = map(yVal, 3, 1020, mazeTop, mazeTop + mazeImage.height); // maps the y value to a position inside the maze area
minnie.move(posX, posY); // moves Minnie to the new mapped position on the screen

• P5 sketch embedded:

Used another account because the p5 I was using got throughout the semester got full.

Communication Between Arduino and p5.js:
Communication between the Arduino and p5.js happens in a simple two‑way loop. The Arduino sends two numbers from the potentiometers, and p5.js uses these numbers to move Minnie inside the maze. At the same time, p5.js sends a pin number back to the Arduino whenever something important happens in the game, like collecting one of the icons, hitting a wall, or winning. The Arduino reads this pin number and turns on the matching LED whether it was the green one for winning or yellow one for picking a collectible and red for touching any of the walls. This creates a basic but effective interaction where the hardware and the game respond to each other in real time.

Aspects I’m Proud of
I am proud of several parts of this project. The collision detection where it checks if minnie’s position overlaps with another object in the maze that includes the wall, the collectibles and mickey. I really liked that the LED sends feedback back to the player in order to show them what color is being lit up. The maze also scales well on different screen sizes, which makes the game easy to play on any device that can connect with the Arduino. During user testing, my sister understood the interaction very quickly, which showed me that the design is clear and easy to work with. Overall, I am really proud of this project because the game turned out better than expected.

Challenges Faced and How I Overcame Them
One of the first challenges I faced was with the potentiometers. The ones I ordered from Amazon were loose and unreliable, which made the game go on and off. I tried using the small Arduino potentiometers because they worked better, but they were too tiny and uncomfortable to turn. In the end, I had to order new potentiometers at the last minute, and those finally gave me smooth and stable control. Another issue was that my game wasn’t working at all at one point, Minnie was jumping all over the maze in random directions. I thought the problem was in my code, but it turned out to be a wiring mistake. The connection from the breadboard to the 5V pin was missing, so the potentiometers were sending unstable values. Fixing that single wire immediately stabilized the movement. I also ran into a major coding problem where a missing bracket caused an “unexpected end of input” error in p5. I solved this by checking each function and making sure every opening brace had a matching closing brace. Another challenge was getting the maze to scale correctly on different screen sizes. At first, the maze stretched or got cut off depending on the device. To fix this, I used Ai to calculate the two scale values: one based on the screen width and one based on the screen height. Then I chose the smaller of the two so the maze would always fit fully on the screen. This made the game look better and scaled proportionally no matter what device it was played on.

Areas for Future Improvement

There are several areas I would like to improve in the future. I want to add multiple levels of the maze, and more sound effects for reaching the different levels. I would also like to add a timer for the harder levels. Another idea is to add more physical feedback, such as additional LEDs for reaching the next level in another color other than green, yellow, or red.

Stipend Spend:

Blue Arduino Potentiometers: https://www.amazon.ae/dp/B07S69443J?ref_=pe_144460031_1285786251_i_fed_asin_title
Potentiometers: https://www.amazon.ae/dp/B0D4LKPLDT?ref_=pe_144460031_1285786251_i_fed_asin_title
Cardboard:
https://www.amazon.ae/dp/B0BWJS8W2M?ref_=pe_144460031_1285786251_i_fed_asin_title
Jumper wires: https://www.amazon.ae/dp/B0F3XDBQYX?ref_=pe_192358311_1415951701_t_fed_asin_title
Potentiometers kit (The ones I used for my arduino): https://www.amazon.ae/dp/B07ZKK6T8S?ref_=pe_151259381_1319653131_t_fed_asin_title&th=1

Citations
1. Item Pickup Sound
URL: https://opengameart.org/content/item-sfx
How I used it: I used this sound effect to play a small “pickup” noise whenever Minnie collects a cheese, star, or heart in the game.

2. Winning Sound
URL: https://freesound.org/people/Mihacappy/sounds/844146/
How I used it: I used this audio clip as the victory sound that plays when the player reaches Mickey after collecting all items.

3. Bump Sound
URL: https://pixabay.com/sound-effects/film-special-effects-retro-game-sfx-jump-bumpwav-14853/
How I used it: I used this bump sound to alert the player whenever Minnie touches a wall in the maze.

4. Majestic Rag (1914): Ben Rawls & Royal Neel (Wikimedia Commons)
URL: https://commons.wikimedia.org/wiki/File:%22Majestic_Rag%22_(1914),_by_Ben_Rawls_and_Royal_Neel.oga
How I used it: I used this music as the looping background soundtrack to give the game a fun and playful type of atmosphere.

5. Nerko One Font: Designed by Nermin Kahrimanovic (Google Fonts)
URL: https://fonts.google.com/specimen/Nerko+One?query=cute&categoryFilters=Feeling:%2FExpressive%2FPlayful&preview.script=Latn
How I used it: I used this font for the text on the instructions page to match the aesthetic of the Minnie‑themed design.

6. p5.js Image Resize Documentation
URL: https://p5js.org/reference/p5.Image/resize/ 
How I used it: I used this documentation to correctly resize images in the game so they scale proportionally on different screen sizes.

Ai usage: 

ChatGPT helped me by explaining the math I needed to make the maze image automatically resize so it fits the screen without stretching or getting cut off. It showed me that I had to compare the maze’s size to the screen’s size and then choose the smaller scale so the whole maze stays visible. I used this explanation to write the final scaling code in my game.

Here is the snippet:

let scaleW = width / mazeImg.width;
let scaleH = height / mazeImg.height;
let scale = min(scaleW, scaleH);

mazeImg.resize(mazeImg.width * scale, mazeImg.height * scale);

This code checks how big the maze image is compared to the screen.

• scaleW is how much the image needs to shrink to fit the width.
• scaleH is how much the image needs to shrink to fit the height.
• min(scaleW, scaleH) picks the smaller number so the whole maze fits without getting cut off.

Then the image is resized using that scale so it always fits perfectly on the screen without being cut off or too stretched.

ChatGPT also helped me by generating several images that I used in the game. These include the game title “Tiny Trails,” the Start button, the Arduino Connect button, the Instructions button, the Back button, and the How to Play title on the instructions page. It also generated the maze image, the characters Minnie Mouse and Mickey Mouse, and the collectable icons: the cheese, the heart, and the star. In addition, ChatGPT created The End title and both background images used on the start page and the maze page. I also used Ai to help generate the image of the bow I printed for my physical box I made and the polka dot pattern as well.

For my project, I created an interactive maze game where the player controls Minnie Mouse using two potentiometers connected to an Arduino. The maze appears on the screen, and the player must guide Minnie through it without touching the walls. The player collects items such as cheese, stars, and hearts, which trigger a yellow LED and a pickup sound. Hitting a wall turns on a red LED and plays a bump sound, and reaching Mickey at the end lights a green LED and plays a happy sound.

For user testing, I asked my sister to try the game. She immediately noticed that Minnie did not move smoothly. Instead of following the potentiometer movements, the character would jump or move to random parts of the maze. Even when she moved the knobs slowly, the character keeps moving as if it was lagged, making the maze impossible to complete or time consuming and not very easy. She described the controls as confusing and it wasn’t consistent. However, she said that the start page was clear and to connect the arduino it was easy and she mentioned that the instructions was clear aswell.

After watching my sister play, I realized the problem came from how I mapped the potentiometer values to the maze. The potentiometer sends numbers from 0 to 1023, but the way I converted those numbers into Minnie’s position on the screen was wrong. Because the mapping didn’t match the actual maze area, Minnie kept appearing in the wrong places. So basically the numbers coming from the Arduino did not match the part of the screen where the maze actually is.

From this user testing session, I learned that the mapping has to be extremely accurate when you connect real‑life controls to movement on the screen. Even a tiny mistake in the numbers can completely break how the game feels. I also realized how helpful it is to test with someone else, because they notice problems that I get used to. Even though the game was not working perfectly before and I realized that before the user testing, the testing helped me understand exactly what was wrong since my sister could see the same issue.

User Testing:

UPDATE:

Issue was from wiring. The connection from the bread board to the 5v was missing.

My Concept:

For my final project, I’m making a physically interactive maze game where the player controls minnie mouse using two potentiometers connected to Arduino, one for moving left and right and the other for moving up and down. The goal is to guide minnie through the maze to reach mickey, but the player also has to collect little items scattered around the maze before finishing. I might add like cheese or starts. Arduino reads the knob values and sends them to p5.js, which moves minnie on the screen, checks if she hits a wall, picks up a collectible, or reaches the end. When something happens, p5 sends simple messages back to Arduino so the LED and buzzer can react, for example like blinking when she hits a wall, making a small sound when she collects something, and playing a celebration melody when she reaches mickey at the end. What will be drawn by p5 is the maze, and screens. However, I might use the internet to help me find collectibles and photos of minnie mouse and mickey mouse to use for my game, which will make the experience feel like a real disney game.

P5 Explanation:

On the p5.js side, the sketch will draw the maze, will show minnie and mickey, and handles all the movement and collision detection. It receives the potentiometer values from Arduino and maps them to minnie’s position in the game, it will also check if she hits a wall, collects an item, or reaches the end. When these events happen, p5 sends “hit,” “collect,” or “win” back to Arduino so the LED and buzzer can react to these actions. The sketch also includes a start screen, instructions, and a counter showing how many collectibles the player has picked up.

Arduino Explanation:

For this project, Arduino’s job is to read the two potentiometers using analogRead() and send those values to p5.js through serial communication so minnie’s movement updates to how the player is controlling it. Arduino also listens for messages coming back from p5.js. When p5 detects that minnie hits a wall, collects an item, or reaches mickey, it sends “hit,” “collect,” or “win,” and Arduino responds by blinking the LED or playing sounds on the buzzer. Everything is based on what we practiced in class such as, reading analog inputs, controlling outputs with digitalWrite and PWM, and sending simple serial messages back and forth.

Progress update:

Right now, I’m in the preparation stage of the project. I’ve finalized the concept and planned out how the Arduino and p5.js parts will work together. I ordered the extra materials I need, including the second potentiometer, and while I wait for them to arrive, I’m going to work on the p5.js side. My focus at the moment is sketching the maze layout, setting up the basic structure of the game, and finding the character images, and collectibles. I will also plan out my code for Arduino. Once the parts arrive, I’ll build the physical setup for the potentiometers and begin connecting everything to Arduino so I can combine the full system.

Concept:

In this series of exercises, we explored how Arduino and p5.js can talk to each other through serial communication. Each exercise focused on a different direction of data flow. First, Arduino sent information to p5.js. Then we switched it so p5.js controlled something on the Arduino. Finally, we combined both directions to create a full bi‑directional system. Doing these three tasks helped us understand how physical sensors and digital visuals can work together to create interactive experiences.

For the first exercise, we made a sketch where a circle in p5 moves left and right based on a potentiometer connected to Arduino. The potentiometer is the only sensor being used here, and its value controls the horizontal position of the circle while the circle stays in the middle of the screen vertically. On the Arduino side, the potentiometer value is read and sent through serial communication. On the p5 side, that value is read from the serial port and used to control the x position of the circle.

For the second exercise, we made a sketch where p5 controls the brightness of an LED on Arduino. Instead of Arduino sending data to p5, p5 sends a value to Arduino. I used a slider in p5, and moving that slider changed the brightness of the LED. The slider sends a value through the serial port, and Arduino reads that value and uses analogWrite() to control the LED brightness. Since brightness needs a gradual range, the LED had to be connected to a PWM pin.

For the third exercise, we combined both directions into one interactive system. We used the gravity‑wind example from class and connected it to both Arduino and p5.js. The potentiometer controlled the wind force in the p5 sketch, so turning it left or right pushed the falling ball in that direction. At the same time, p5 sent a message back to Arduino every time the ball hit the bottom of the screen. This made the LED blink with each bounce, creating a small physical reaction that matched the animation. Seeing the LED flash at the exact moment the ball hit the ground made the connection between the screen and the hardware feel much stronger. This exercise showed how both sides can respond to each other in real time.

Code:

P5 exercise 1: 

P5 exercise 2:

P5 exercise 3:

Arduino Github Link Exercise 1: https://github.com/mhraalnuaimi/exercise1week11/blob/main/W11..01_serial_simple_potentiometer.ino 

Arduino Github Link Exercise 2: https://github.com/mhraalnuaimi/exercise2week11/blob/main/W11_02_Bidirectional_Com.ino 

Arduino Github Link Exercise 3:  https://github.com/mhraalnuaimi/exercise3week11/blob/main/exercise3week11.ino 

Setup:

Exercise 1:

Exercise 2:

Exercise 3: 

Demonstration:

Exercise 1:

Exercise 2: 

Exercise 3: 

Schematic:

Exercise 1:

Exercise 2:

Exercise 3:

Process:  

During these exercises, we followed the same steps for each project: wiring the components, writing the Arduino code, and then connecting everything to p5.js using WebSerial. For Exercise 1, we wired a potentiometer and tested the analog readings in the serial monitor before using them in p5. In Exercise 2, we focused on sending values from p5 to Arduino, so we tested the slider and made sure the LED responded smoothly. Exercise 3 was the most detailed because it used both directions of communication. We had to make sure the potentiometer values were clean, the wind force felt natural, and the LED blinked at the right moment. We also learned that adding a newline at the end of each serial message made the communication much more stable. Overall, the process helped us understand how to connect physical sensors with digital visuals step by step.

Code We Are Proud Of:

Code Snippet:

port.write("1");
setTimeout(() => port.write("0"), 100);

This is the part of the code we are most proud of because it shows the moment when p5.js talks back to Arduino. When the ball hits the bottom of the screen, p5 sends a “1” to turn the LED on and then sends a “0” to turn it off again. This creates a quick flash that matches the bounce.

Reflection and Areas of Improvement:

Working through these three exercises helped us understand how Arduino and p5.js can communicate in different ways. In Exercise 1, we learned how to read an analog value from Arduino and use it to control something in p5.js. In Exercise 2, we learned how p5.js can send values back to Arduino to control hardware like an LED. In Exercise 3, we combined both directions and created a full interactive loop where both sides respond to each other. This final exercise felt like the most complete example of how serial communication can be used in creative projects. If we continued building on these ideas, we could make more complex interactions such as small games, musical tools, or installations that react to multiple sensors. Overall, these exercises helped us build a strong understanding of serial communication and how physical and digital elements can work together. 

If we were to improve these exercises, we would try adding more sensors or combining different types of inputs to make the interactions more interesting. For example, we could add buttons, sound sensors, or even an ultrasonic sensor to create more complex reactions in p5. We could also improve the visuals by adding animations or smoother movement to the ball. Another improvement would be organizing the code better by separating the serial functions from the physics code to make everything easier to read. These changes would help make the projects feel more polished and closer to real interactive installations.

References:

All the concepts we used in these exercises came from the Week 11.1 and Week 11.2 lecture slides. These slides explained how serial communication works, how to use WebSerial in p5.js, and how to send and receive data between Arduino and p5.  

For my final project, I am creating a physically interactive maze game that uses both Arduino and P5.js. So I decided to pick minnie mouse and mickey mouse as my two characters. The idea is to guide minnie mouse through a maze using two physical potentiometers instead of a keyboard or mouse. The player’s goal is to move minnie mouse from the start of the maze to the end, where mickey mouse is waiting.

The interaction works in a simple cycle of listening, thinking, and responding. The Arduino will be the “listener” because it reads the positions of the two potentiometers. One knob controls left andright movement, and the other controls up and down movement. When the player turns the knobs, Arduino senses the changes and sends those values to P5.js. P5. will be the “thinker,” because it takes those values and turns them into movement on the screen. The game then responds by moving the character in real time and showing whether the player is controlling minnie mouse in staying inside the maze or hitting the walls. I want to consider adding a celebration melody when minnie mouse reaches mickey mouse. I might as well make the LED blink when Minnie hits a wall to alert the player about it.

The maze itself will be drawn in P5 using simple shapes or a custom layout. I will have a start screen and instructions screen. The character will move smoothly through the pathways, and basic collision detection will prevent it from passing through walls. When the player reaches the goal area, the game will display a small celebration animation or visual cue to show that the objective has been completed. The experience is meant to feel playful, fun and slightly challenging, since the player must learn how to control movement using physical knobs instead of controlling it with the laptop. I will probably take photos of minnie mouse and mickey mouse of the internet and use them as my characters.

Reading Design Meets Disability made me think differently about how society treats disability devices. One part that stayed with me says that trying to hide these devices can show “a lack of self confidence that can communicate an implied shame.” This made sense to me because I believe disability devices should be shown proudly. There is nothing to hide, and people should feel free to embrace what makes them unique. The reading helped me understand that hiding something can sometimes send a negative message, even if people do not mean it that way.

Another idea that surprised me was how design for disability can inspire mainstream design. The text explains how the Eames leg splint influenced famous furniture. I never expected a medical object to shape everyday design. This showed me that disability centered design can be creative and important, not only functional.

The reading also changed how I think about the look of medical devices. When Aimee Mullins chooses “off the chart glamorous” prosthetics, it shows how fashion can help people feel confident. If I had to wear a hearing aid or prosthetic, I would want it to be unique and fashionable too. Something that stands out in a good way and can influence others to do the same. This is why I think fashion designers, especially designer brands, should help create these devices. It would make people feel included and inspire many other small businesses and brands globally.

Overall, the reading taught me that disability and design do not need to focus on hiding. They can focus on expression, creativity and how each person shows their own personality with something so unique.

Concept:

In this assignment, we had to create a musical instrument using digital and analog sensors. We used push buttons as our digital sensors and a potentiometer as our analog sensor. We then decided to create a mini piano-like device that plays the four basic piano notes C, D, E, and F, and allows the user to adjust the pitch of these notes. In this project, there are four push buttons, each assigned to one note that only plays when the button is pressed, and a potentiometer that changes the pitch of the notes when it is turned.

Code:

Arduino File on GitHub

Setup:

Mariam’s Setup

Mhara’s Setup

Demonstration:

Mhara’s video demo:

Mariam’s video demo:

Digital Circuit:

Schematic:

Process:

In the process of this assignment, we decided to combine four buttons (digital) with one potentiometer (analog) to control a piezo buzzer. Each button plays a different note, and the potentiometer slightly adjusts the pitch so the sound changes depending on how much it’s turned. We worked together on the idea and the wiring, but we divided the coding so each of us focused on one part. Mariam handled the digital part (the buttons and the notes), and Mhara worked on the analog part (the potentiometer and the pitch control). After both parts were working separately, we combined them into one full sketch of code.

We then tested the circuit in Tinkercad to make sure all the wiring and logic of the code were correct. This helped us confirm that the buttons were reading properly and that the potentiometer was giving smooth values. Running it in Tinkercad also made it easier to fix small mistakes before trying it on the physical Arduino board.

At first, the audio wasn’t changing when the potentiometer was turned because the mapping was happening after the tone was already being played, so we rearranged the order of the code and that finally made the pitch respond. After that, the sound became too noisy and robotic, so we added a small adjustment range (90 – 105) to each note to make the pitch change smoother and less harsh.

Code Snippets:

While building the project, there were a couple of code snippets that stood out to us because they played an important role in making the instrument work the way we wanted it to. 

tone(buzzerPin, noteC * map(sensorValue, 0, 1023, 90, 105) / 100);

This was the part we were most proud of because it solved the “robotic” and “noisy” sound problem. Instead of letting the potentiometer completely change the note, we used a small adjustment (90-150) to bend the pitch smoothly. And this showed how the digital and analog inputs can work together in one line of code. 

Another part of the code is :

pitch = map(sensorValue, 0, 1023, 200, 2000);

This line shows how the analog input (the potentiometer) controls the sound. It takes the raw value from 0-1023 and maps it into a pitch range that the buzzer can actually play. This was important because the potentiometer originally wasn’t affecting the sound at all, and fixing the order of the code made this line finally work the way we wanted it to. 

Areas of Improvement and Reflection:

After completing this assignment, we were able to learn and explore different sensors and sounds. It was easy and smooth to work as a pair, as each person focused on one part and then we combined our work together. As for areas of improvement, we could make the sound of the notes smoother and more musical, since it still sounds slightly robotic, or add more notes to make it closer to a real piano. Another idea is to implement other sensors, such as an ultrasonic sensor, to play different notes or even melodies based on motion or distance. Working with audio and sensors is a fun part of Arduino, and it allows us to create many different ideas for various purposes. Overall, we are satisfied with our final outcome and the entire process of this project.

References:

Looked back at Week 10 slides about sound to recap what we learned.

Reviewed specific code concepts using the Arduino documentation:

https://docs.arduino.cc/language-reference/en/functions/math/map/ 

• How we used it: We used this to convert the potentiometer’s range into a smaller pitch-adjustment range that works smoothly with the buzzer.

https://docs.arduino.cc/language-reference/en/functions/advanced-io/tone/ 

• How we used it: We used this page to understand how the tone() function works and how to send different frequencies to the buzzer. 

https://docs.arduino.cc/built-in-examples/digital/toneMelody/ 

• How we used it: We looked at this example to understand how notes from pitches.h are used and how tone() can be combined with different frequencies to create musical sounds.

Ai usage:  Used ChatGPT to help navigate and resolve a major issue where the tones sounded too robotic and noisy. From this, we learned that using the map() function with a smaller range for each note helps create smoother, more controlled pitch changes.

When I thought about touchscreens before this assignment, I always felt they were fun and easy to use. I liked exploring things by touching the screen instead of using buttons or a mouse. Because of that, I assumed touchscreens were already the best version of future technology. After reading the texts, I started to notice how limited screens actually are. They only let me use one finger, even though my hands and body can do much more. This made me think about how technology does not really use our full abilities.

One idea that made me think was how the author described touchscreens as flat and numb. I never thought about how everything feels the same when I touch my phone. There is no real physical feedback. When I read that, I realized that I also feel limited by screens and I hope technology develops into something more than just glass surfaces. It made me wonder what it would feel like if my phone could respond physically, not just visually.

The readings also made me think about creativity. I believe creativity can be fully digital, like movies, where you do not need to touch anything to understand or enjoy it. But at the same time, I noticed that when I work on physical computing projects in class, using sensors and real materials feels more engaging. It uses more of my body, not just my eyes.

Another part that stayed with me was the idea of children using iPads. I think it can be bad because of radiation, but it can also be very educational if used the right way. The reading made me think more deeply about how screens might affect development, especially if kids only interact with flat surfaces.

Overall, these readings made me question my assumptions about future technology. I used to imagine better screens, but now I imagine tools that involve more of the body. It made me think that maybe the future should not be limited to touchscreens, and that we should explore new ways of interacting that feel more natural and physical.

My concept: 

For this week’s assignment, I worked on a small circuit that uses a button and a potentiometer to control two LEDs. The button works as a digital input, so the LED connected to it only turns fully on or fully off. The potentiometer is an analog input, so it gives a range of values, and that lets the second LED fade smoothly instead of switching instantly. Seeing both of them together helped me understand the difference between digital and analog in a very clear way. One is fixed, and the other changes gradually.

Code Snippet I’m Proud Of:

int potValue = analogRead(potPin);
int brightness = potValue / 4;
analogWrite(fadeLed, brightness);

This part made the most sense to me once I understood what PWM actually does just like how i learned on the slides. The potentiometer gives a value from 0 to 1023, but the LED only uses 0 to 255.  When I saw the LED fade smoothly as I turned the knob, it finally clicked for me how analog control works.

Process

I started this assignment by deciding which inputs and outputs I wanted to use. Since the goal was to work with both analog and digital inputs, I chose a pushbutton for the digital part and a potentiometer for the analog part. I wanted each one to control a different LED so I could clearly see the difference between the two types of signals.

I began by setting up the breadboard and making sure it had power. I connected the 5V pin from the Arduino to the positive rail and the GND pin to the negative rail. After that, I wired the button to pin 2 and added the 10k resistor to ground so it could work as a pull‑down. Then I connected the potentiometer to A1 and made sure the middle pin was going to the analog input. Once both inputs were connected, I added the two LEDs with 330 resistors to protect them.

At first, I tried to test everything on the physical Arduino, but the board started acting in a way that it wasn’t working and connecting to the laptop and kept shutting down, the green light would blink for a second and then everything will go off, and I wasn’t able to find the cable option on the ports shown to connect the code with my arduino, so that’s why it wasn’t working. After a lot of troubleshooting, I realized the problem was not my code or my wiring. The board itself was not responding properly. Because of that, I moved the project to Tinkercad so I could finish the assignment without dealing with hardware issues I could not fix. In Tinkercad, the circuit worked the way it was supposed to, and it helped me understand the logic more clearly.

My tinkercad:

https://www.tinkercad.com/things/b5J0eHZInWx/editel?lessonid=EFU6PEHIXGFUR1J&projectid=OGK4Q7VL20FZRV9&collectionid=undefined&title=Editing%20Components&sharecode=UdELcMJJ9AZbknNHQbrLb1glfjri4FwRHka6vCkfr5U

Sketch:

My circuit:

My code:

int buttonPin = 2;     // the button
int ledPin = 13;       // the digital LED
int fadeLed = 11;      // the fading LED
int potPin = A1;       // the potentiometer

int buttonState = 0;   // to store what the button is reading
int potValue = 0;      // to store what the potentiometer is reading
int brightness = 0;    // to store LED brightness

// pinMode( tells the Arduino how each pin will be used)
void setup() {
  pinMode(buttonPin, INPUT); //the button is an INPUT because I’m reading from it
  pinMode(ledPin, OUTPUT); // the LEDs are OUTPUTS because the Arduino controls them
  pinMode(fadeLed, OUTPUT); //this runs once when the Arduino starts
}

void loop() {

  buttonState = digitalRead(buttonPin); // this checks if the button is pressed or not, t will be HIGH when pressed and LOW when not pressed


// if the button is pressed this means the LED on pin 13 turns on
// if the button is not pressed this means LED turns off

This is a simple if/else condition.
  if (buttonState == HIGH) {
    digitalWrite(ledPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
  }

  // the pot gives a value between 0 and 1023
// this depends on how much I turn the knob

// I store it in potValue so I can use it for brightness
  potValue = analogRead(potPin);

  //analogWrite() only accepts values from 0 to 255 so dividing by 4 converts the 0–1023 range into 0–255
  brightness = potValue / 4;

//this sends a PWM signal to pin 11,the LED brightness changes smoothly based on the pot
// the higher pot value means brighter LED
  analogWrite(fadeLed, brightness);
}

Reflection / Future

This project helped me understand analog and digital inputs in a more real way. I already knew the definitions, but seeing how each LED reacted made it easier to get it. The digital input was very straightforward because the LED only turned on or off. The analog input felt more interesting because the brightness changed slowly when I turned the potentiometer. Using both at the same time made me feel more comfortable with how the Arduino reads different signals.

I also learned a lot about wiring and how small mistakes can mess up the whole circuit. I kept running into problems on the breadboard, and even when the wiring looked right, things still didn’t work. When the physical board stopped responding completely, I had to switch to Tinkercad. Even though that was frustrating, it helped me focus on the logic instead of fighting with hardware issues. It also showed me how important it is to check every connection carefully.

In the future, I want to try using more sensors and making the interactions more interesting. I also want to keep my wiring cleaner because it makes debugging so much easier. Now that I understand the basics better, I feel more ready to try bigger projects and see how these components can work together in different ways.

The first reading made me think a lot about how physical computing projects repeat every year. At first, I thought it meant people were running out of ideas, but the reading made me see it differently. I realized that people repeat projects because they get inspired by what others make, not because they lack creativity. I do not think ideas are limited, but I do think people naturally follow things they find cool or interesting. For me, it is okay to redo a project if you add your own twist, but I still prefer coming up with something new. If I worked hard on an idea, I would not want someone copying it too closely. The reading also made me understand that originality is not always about doing something completely new. Sometimes it is about how you change the idea, how you design it, and how you make it feel different from the rest. That part made me think more about how I approach my own projects in class.

The second reading made me think about how interactive art works and how much control the artist should have. I agree that artists should not tell the audience what to think, because everyone sees things in their own way. If you enjoy what you are making, you do not need other people’s opinions to change your message. I also liked the idea that the audience completes the artwork through their actions. It made me realize that interactive art is not just about the object or the device. It is also about how people move, react, and explore it. The reading made me think differently about designing interactive pieces, because it showed me that the audience’s reaction is part of the artwork itself. Both readings made me see that in physical computing and interactive art, the designer does not need to control everything. Sometimes the best part is letting people explore freely and create their own experience.