All Posts

Week 9 – Production

Initial Idea

The goal of this project was to explore the interaction between analog and digital sensors and how they can be used to control outputs creatively. Specifically, the task was to use at least one analog sensor and one digital sensor to control two LEDs, one through digital means (on/off) and the other through analog means (brightness control). The initial idea was to keep the components simple but effective: a push-button as a digital switch and a potentiometer as an analog input, controlling a red and green LED, respectively.

Video demonstration

Execution

The red LED was connected in series with a 330-ohm resistor and controlled by a push-button, which toggled it on or off based on the button state. The green LED was also connected with a 330-ohm resistor and its brightness was adjusted using a 10k potentiometer wired to an analog input pin. The analog value was read from the potentiometer and mapped to a PWM value to vary the green LED’s brightness.

Here is a diagram:

 

const int potPin = A0;
const int buttonPin = 2;
const int ledDigital = 10;
const int ledAnalog = 9;

bool ledState = false;

void setup() {
  pinMode(buttonPin, INPUT_PULLUP); // button active LOW
  pinMode(ledDigital, OUTPUT);
  pinMode(ledAnalog, OUTPUT);
}

void loop() {
  // Read potentiometer value
  int potValue = analogRead(potPin); // 0 - 1023

  // Map it to PWM range
  int brightness = map(potValue, 0, 1023, 0, 255);
  analogWrite(ledAnalog, brightness);

  // Read button
  if (digitalRead(buttonPin) == LOW) {
    delay(200); // debounce
    ledState = !ledState;
    digitalWrite(ledDigital, ledState);
  }

  delay(50); // loop delay
}

 

Highlights 

  • The logic worked exactly as planned: the button cleanly toggled the red LED, and the potentiometer provided smooth brightness control for the green LED.

  • The circuit was clean, and the schematic clearly represents the wiring and design intent.

  • I’m proud of how the components were chosen and integrated in a way that’s both simple and pedagogically effective, perfect for demonstrating basic input/output handling on Arduino.

What Could Be Improved

  • Debouncing the push-button in code could be refined further to prevent unintended toggles.

  • A creative twist (e.g., combining analog and digital inputs for more complex LED behaviors or using a different type of analog sensor like an LDR) could elevate the interactivity.

  • Next time, I might also add a small OLED screen or serial output for live feedback on sensor values for better debugging and visualization.

Week 9 Reading Response

Reading Tom Igoe’s “Physical Computing’s Greatest Hits (and Misses)” honestly made me feel a lot more relaxed about project ideas. At first, it seemed like a list of all the things people have already done too many times, like gloves that make music, video mirrors, or floors that light up when you step on them. But then Igoe flips that idea. He basically says it’s okay to revisit these themes because what makes them interesting isn’t the concept itself, but how you approach it. That felt very refreshing. It reminded me that originality doesn’t mean starting from nothing every time. It can come from how you add your own twist to something familiar.

What I also appreciated was how much these themes connect to actions we already do in real life, like tapping, dancing, waving, tilting, or even yelling. It’s amazing how intuitive some of these interactions are, and how physical computing works with that. You don’t have to explain much when someone naturally knows how to interact with your piece.

In “Making Interactive Art: Set the Stage, Then Shut Up and Listen”, Igoe talks more about the role of the artist or designer in this kind of work. The main idea that stood out to me was that we shouldn’t try to control how people respond or tell them exactly what to think. Interactive work is more like setting up a space or a situation and then letting people figure it out on their own. I liked the comparison to a theater director. You can give actors tools and a setting, but the emotional part of the performance has to come from them. The same thing goes for interactive art. It only works when people bring something of themselves to it.

Both readings helped shift the way I think about making interactive projects. It’s not just about cool tech or trying to be the most unique. It’s really about creating something that invites people to participate and explore. Ideally, they leave with their own story or feeling from it, not just the one I imagined in advance.

Reading Reflection: Week 9

Physical Computing’s Greatest Hits (and misses)

One idea that really resonated with me is the reminder not to give up on a project just because it’s been done before. I’ve done it myself in the past when i would get excited about an idea for an IM project, only to do my research and see that someone else had already made something similar. That would make me feel like it wasn’t “original enough,” so I’d opt out to do something different.

The reading made me realize that two people can execute the exact same concept in totally different ways. The author mentions how even common topics in physical computing can still offer surprises through personal variation. I especially liked the example of using your body or hand as a cursor as no two drawings will ever be the same, and that kind of interactivity can’t be duplicated.

I also really agree with his implication that what’s important is not what the computer can do, but what the person can do. It is more about how people respond, interact, and express themselves through interacting with technology.

Making Interactive Art: Set the Stage, Then Shut Up and Listen

The main idea that the artist shouldn’t interpret their own work reminded me of how some painters intentionally choose not to add descriptions to their works – they leave it up to the viewer to decide on their own meaning. In terms of Interactive Media, this made me think about how the project has to be self-explanatory, as all elements should guide the user without any extra instructions.

Another idea that creators should listen to how people respond to their work is something I don’t think I’ve ever done intentionally. I’ve tested projects to see if they work, but I haven’t truly observed how people feel or what unexpected things they do with it. It also reminded me of another reading we had earlier about interaction being a conversation, not just a monologue from the author. I think I would like to try building projects that leave room for interpretation and do unexpected things.

Week 9: Sensor Assignment

My Concept

The project is a thermometer system that uses an analog temperature sensor and a button switch to control three LEDs: blue for cold (22°C and below), green for moderate temperatures (24°C to 27°C), and red for warmer temperatures (27°C and above).

The button works as a power switch, making the LED that matches the current temperature light up. At first, I wanted all the LEDs to turn on when the button was pressed and then, after touching the temperature sensor, have only the LED for the detected temperature stay on. But that didn’t work out, so I adjusted the setup to make the button directly activate the correct LED based on the sensor’s reading.

Set-up

 

Code

Github Code

Highlight:

As the temperature sensor doesn’t directly give the temperature, I had to convert the initial number (an ADC reading) into volts, then into millivolts  and then use a formula to calculate the temperature in Celsius. After that, I converted it into Fahrenheit

reading = analogRead(sensorPin);  
volts = reading * aref_voltage / 1023.0;
millivolts = 1000 * volts;
degreesC = (millivolts - 500) / 10;
degreesF = (degreesC * 9 / 5) + 32;

Reflections

This project taught me how important it is sometimes to start completely from scratch. In my first attempts, the TMP sensor got overheated, which was most likely because I positioned some components in a way that caused issues in the circuit. I ended up having to rebuild everything a few times. It was frustrating at first, but ultimately a great learning experience. To refine my future projects, i’d love to experiment with more sensors in our kit and see how it goes. Overall, i enjoyed the creation of this project.

 

Reading Response 5 – Design & Foresight (Week 8)

Reading 1: “Attractive Things Work Better” by Don Norman
I really liked Norman’s idea that attractive things don’t just look good—they actually change how we feel and behave. Before reading this, I used to think usability was all that mattered, but now I see how a beautiful design can make me more patient and forgiving. For example, there’s an app on my phone with a super sleek interface. Even when it glitches, I’m willing to give it another chance because it looks so appealing. On the other hand, if an app looks outdated or dull, I find myself deleting it right away. It’s fascinating how aesthetics can create a kind of emotional “cushion” that keeps us calm and curious, which then helps us solve problems more easily.

Reading 2: Margaret Hamilton and the Apollo 11 Mission
Margaret Hamilton’s story reminded me that critical work often happens behind the scenes and doesn’t always get the attention it deserves. Her software literally helped save the Apollo 11 mission by planning for things that might go wrong—something no one else seemed to think about at the time. I love how she pushed for software to be taken seriously as an engineering field. Back then, many people saw coding as less important than other parts of spaceflight, but her hard work proved otherwise. It’s really inspiring to see how her ability to anticipate mistakes changed everything for the mission. I think we can all learn from that: even if other people don’t immediately see the value in what we do, persistence and foresight can make a huge impact—sometimes, it can even save the day.

Week 8 – Unusual Switch

Concept

The idea is straightforward: use the AirPods case itself as a physical mechanism to connect or disconnect two wires.

  • When the AirPods are open: The two green wires make contact. This allows current to flow in such a way that the LED turns on.

  • When the AirPods are closed: The two green wires are pushed apart (or pulled apart), so the circuit is broken, and the LED turns off.

Of course, your exact implementation may depend on how you place the wires on the AirPods case—some people prefer taping them near the hinge or using a small piece of foam to press them apart. But the principle remains the same: open case = wires connected, closed case = wires disconnected (or vice versa).

What You’ll Need

  • Arduino Uno

  • Red wire (5V supply)

  • Black wire (GND)

  • Blue LED

  • 330 Ω resistor

  • Two green wires (these become the AirPods “switch” leads)

    Demo:

Week 8 – Unusual Switch

Introduction:

The NYU library at peak hours , especially during the midterm week, turns into a Sunday bazaar with students pulling all nighters and some attending just for the vibes. It has been the case, that the number of students wanting to study always exceeds the number of study desks available. To address this, the library administration devised a policy – 25 minutes of unattended desk would result in transfer of that study place to another student. Many students toss in there belongings and go away. While the desk is not being used, it ends up not being utilized for studying. This way of booking and occupying places, is not only selfish but unethical. To address this issue, I wanted to resort to ‘out of the box thinking’. This is where I found a switch mechanism, apparently an usual one more befitting!

Working:

In order to be the switch to be unusual, it cannot be operated by hand. One of the indicators could have been the desk, but then I realized, that the chairs can be even more useful in the sense that it is definite that you have to sit down to work, compared to putting pressure over the desk with your items. Hence, as shown in the sketch, I utilized the pressure sensor, which has inverse relationship between its resistance and pressure applied onto its plate. Pressure decrease increases resistance. I added two leds, with one connected to pin-8 being red – indicating that the seat is occupied, and the other one connected to pin-12 indicating that the seat/workplace is free. The 10k resistors help prevent LEDs from burning and third resistor is connected to the pressure plate, to ground unnecessary voltage flux by the plate to 0V. This prevents anomaly and stops any non-necessary trigger sent over to A0 input. Since digitalRead had to be used, the simple ON or OFF state from the sensor was extracted and the state was sent over to the input ‘A0’. This input measures for 0s and 1s. When 1 detected, it triggers the logic inside the code.

Here is the schematic for the circuit:

Demo:

Code:

//alinoor

// declare variables
int sensorpin = A0;  // sensor pin
int sensor;   
// sensor readings
// LED pins
int led1 = 8;
int led2 = 12;
bool person_was_sitting; // to check if it is still in use while person away

void setup() {
  // set LED pins as outputs
  pinMode(led1,OUTPUT);
  pinMode(led2,OUTPUT);
 
  
  // initialize serial communication
  Serial.begin(9600);
}

void loop() {
  // read sensor value
  sensor = digitalRead(sensorpin);
  // print sensor value
  Serial.println(sensor);
  // turn on the red led and keep it on until the person is pressing against it
  // against it or its been 25 minutes since the last press.
  
  if(sensor>0){
    digitalWrite(led2,LOW);  //green led turns off
    digitalWrite(led1,HIGH); //red led turns on
    person_was_sitting = true;
  
  }
  else if(sensor < 1 && person_was_sitting == true){ //checks out only if now seat is idle and person is away for less than 25 min
  		digitalWrite(led1,HIGH);
    	delay (1500000); // delay for 25 minutes
        digitalWrite(led1,LOW); // red led turns off
    	digitalWrite(led2,HIGH); //green LED turns on
    	person_was_sitting = false;
    	

  }
 
}

The code is pretty much self-explanatory with the aid of the comments. To further explain the logic, the two LEDs are connected to pin 8 and 12. The sensor value store the digitalRead value measured for input to A0 pin. That value, either 0 or 1 (printed inside serial monitor as well for debugging), is used in if-else condition to perform certain task. The delay in else is in milliseconds equivalent of 25 minutes. For debugging 5000 millisecond was used which is equivalent to 5 seconds. If the sensor returns 1, bright red LED lights up to show ‘occupied’. It also sets the state of ‘person_was_sitting’ to true. When person no longer sitting, then else-if triggers and checks for both conditions. In the case that its been more than 25 minutes, and there hasn’t been any one sitting on the chair, then else-if isn’t checked for, and it continues to power the green LED. However, if a person just left, then a delay of 25 minutes is set in place, after which red light is turned off and the green one is toggled.

Future Improvements:

Potentially a brighter LED coupled with weight sensor to make it fool-proof. Students can swap chairs to prolong booking, which in my opinion would self-contradict their on idea of staying away from desk as they will have to comeback to swap again, but even then, adding in weight sensor can help monitor and record for previous weight. If someone else sits to prolong or to takeover someones space, an added buzzer can beep and notify the librarian of such act.

Week 8 – Reading Reflection

Her Code Got Humans On The Moon – And Invented Software Itself:

The story of Margaret Hamilton not only serves as great source of inspiration for woman in tech. but also to those who tend to walk a different path than the others. What was considered minute, soon ended up becoming center of attention as software oriented approach after the apparent success of Apollo launch, was placed emphasize on, and towards the implementation of  software centric system. A mother whose intention was to serve her family first, and make a difference is commendable; however in addition to the heart touching story, what caught my attention was the stubbornness. Sometimes its ok to believe in yourself and be stubborn. Had it not been for her toying around and discovering the potential problem with the simulator regarding the P01 switch control, maybe they wouldn’t have been able to find a fix within 9-hours. This taught me the importance of putting things to the test, and always opting for a back-up, rather than putting things to luck. A good system always has back-up incase of failure. In general, I found a confidence booster through this story of hers, and made me realize missed venues where I could have had been a trend setter instead of being a follower. This class allows me to build by will, and it is what I want to utilize to break and make just like Margaret!

Attractive things Work Better:

The reading discusses the universal cognitive bias where attractive items are interpreted as easy to use. Intelligently designed products allow producers to veil the flaws behind the curtain of attractiveness that products imposes onto its operators. In addition, that veil not only covers over the flaws, but also does the same to hide stressful, bottle-neck, and irritating situations as per what was described in the reading.  As mentioned in the reading,  ”pleasurable aspects of the design will make them more tolerant of difficulties and problems in the interface”. Come to think of it, I completely agree with this. Computers, despite complex algorithmic runtimes and clock-timings coupled with rising edges to get the minimal task carried out to a human mind may seem stressful. For those who develop, not so much so, but even then to process everything in our short term memory, can overwhelm any of the mind on the planet earth. Even its creator’s. Therefore we interact with what’s on the front-end. Even then, the interface differs. This is where I noticed contrast between iOS and Android operating systems. Both are very well capable, however, the minimalistic flat icon layout of iOS seems so clean and smooth, that we end up blaming android as a flawed system, even though both considerably have their own downsides. Moving away from non-tangible to tangible, the minimalistic aluminum body of Apple’s products make them pleasing to eyes and touch, despite the heaps missing array of sensors and functionalities that you can find on a 200$ android phone. To make my point clear, there is preference for both products, but Apple manages to hide its downsides with better design philosophy.  The reading does argue ‘Beyond Beauty’, and to that I think ‘reliability’ is the word I would reply back with. Not just the functionality, but a reliable functionality is also a core component, without which the age of product would short live, and its beauty would lead it to be decorated  on a shelf. Personally relating to it, my Parker ballpoint, after running out of ink, became of no such use. Nonetheless, I enjoyed the reading and believe, something reliable, functional, and soothing for the eye makes for a good product.

Week 8 – Reading Response

Attractive things work better.

I loved the article as it speaks on something very relatable and significant in the Design world and that is the intersection of design and beauty. I never really gave it much thought but after reading the article I now see this evident in my life too and that of friends around me. I appreciate how Norman categorised how affect impacts design and behaviour. In terms of behaviour, he explains how affect regulates how well we can solve problems and perform tasks. For instance, I find myself more motivated to handwrite when I have an aesthetically pleasing pen or pencil and the opposite is also true. In terms of design, affect impacts how easy it is to learn how to use an item. My takeaway from the reading is that designers should strive to strike a balance between optimum usability and also the appealing nature of their designs. 

Her code got humans on the moon

Such an amazing piece of writing highlighting the outstanding contribution of Margaret Hamilton in the development of software Engineering. There are so many lessons to learn from this writing but what stood out to me is the passion and sheer determination of Hamilton to push beyond the ordinary and uncover the complex technological milestones with so many odds stacked against her. I found it inspiring how she paid keen attention to the possible crash of code and was ready to solve it despite the skepticism she received from NASA. Had she not been that assertive, who knows what would have happened to the space explorers. On a broader scale I appreciate how the Apollo space program revolutionized both computing history and space exploration.So many insights to take on in life from the reading —encouraging me to push boundaries, embrace innovation, and persevere through challenges in any field.

 

Week 8 – Reading Response

Attractive Design

I  found the example of the three teapots particularly interesting because it shows how different designs serve different purposes.  The author describes one of the teapots as being deliberately unusable, the other more aesthetically pleasing, and the last one being practical and well thought out. Yet, he uses all of them at different times, proving that design is situational. This made me reflect on my own experiences, there are times when I  am most liekly to prioritize efficiency, but other times I would like to appreciate beauty or novelty in design. Essentially,  it’s not about a single “best” design but rather the right design for the right moment.

Her Code Got Humans on the Moon

Reading about Margaret Hamilton’s contributions really gave me a new perspective on software design and reliability. I had never thought about how early software engineering had to account for human error in such high-stakes environments. This made me think about how much of today’s UI/UX design is centered around the same kind of principles and ideas Hamilton had. In interactive systems, we rely on clear, intuitive design to prevent mistakes, just like the Apollo software had to ensure astronauts couldn’t accidentally erase critical data. Her work really highlighted the idea that good software isn’t just about writing code but also  about anticipating how users will interact with it and designing systems that are both strong and intuitive to use.