shuang's itp jorney
welcome to my chelsea hotel
chelsea is a name given by naive shuang
hope you enjoy your stay
I was heading back home from the floor late on a foggy and drizzling night alone on my bike. Under the manhattan bridge, I heard the train howling and fleeting away from the chaos it left behind. In contrast, the road was still and tranquil with only a few white plastic bags running alongside the rats. I stopped on the south end of the bridge because I saw the red gloom on the traffic light standing in the middle of the road piercing through the milky air. As the only person present, I obeyed the order that the lonely light painstakingly hoped to maintain not out of obedience but appreciation and pity.
I am emphasizing the moment of the traffic light maintaining the order even when there are no participants by creating a traffic light that only lights up when people are far away and dims when people come close. The lonely traffic light meant to ask questions about gazes, absences, and the relationship between participants and order. Though there might not be an answer, I am approaching the suspension with an existential philosophy hoping my piece is on the journey of finding the meaning.
The project is using Arduino, three colors parallel-circuits LEDs, time-of-flight distance sensors. The enclosure is made from hardboard and straight lattice wood bending technique.
I definitely cross into some trouble making it. The green light is still very dim right now because of the nature of the LEDs. I had to manipulate the sensor data multiple times. As you may see how originally I cut out the clear acrylic circles for the bulb assembly, there was no way for me to attach them to the hardboard enclosure. I had to re-design them into a board that looks like the image on the right. Nunu worked really hard on the 3D-printed enclosure that eventually cracked.
Most of the frustrations I got from this project educated me and gives me a better project development flow. I am now more comfortable with medium-scale project developments starting with planning and management. I remembered I was most stressed about ideation before this idea came to me. I suppose ideation is still something I should work on and practice more with my coming years at ITP and in the future in general.
The documentation studio helped me with the video above. I am still waiting on an edited clip - which I will put in on this page too. They have been a great resource to ITP students for project documentation. I am definitely asking for help from them in the future. They also helped me shoot some fun photos with the traffic light.
All in all, I had a lot of fun thinking about, designing, making, coding, and fabricating this project. For the future, I am thinking about further developing the concept and this project, and maybe bringing more intriguing objects to this idea. For starters, David from the floor gave me a red light bulb from a real-size traffic light.
We went over the project ideas across three classes. I have decided to make a traffic light that dims when people come closer.
The conceptual explanation will be formally written up later. General idea is that I want to emphasize gazes and the absence of participants. I am potentially hoping I could further develop this project in the future with other weird items too.
The video on the left shows a mock-up with three single LEDs. The video on the right is the second week of work where I parallel connected 15 red LEDs for the red bulb on the traffic light after several experiments.
As the image and the video shown, I have only worked up the cover for the casing. I will need to figure out more about the enclosure next week.
I was thinking about making it real size, but the power management is rather tricky. Unless I could figure out how the relay works, parallel circuit it is.
As for the hardware:
For the sensor, Yeseul recommended the ToF sensor. This one should be a one since it has a Maximum Sensoring Distance of 2m.
Aside from that, all I need is
-
15 LEDs from different colors
-
Arduino Nano
What we used other than these:
-
Breadboard
-
Short wires in two colors at least
-
Clear acrylic board
-
Potentiometer for prototyping
Schedule:
Week I Week II Week III
planning → circuit prototype and making → eclosure planning/making/printing
Todo:
-
Design the enclosure [thinking about 3D printing]
-
Maybe learn about relay(?)
-
Finish the circuit
-
Put everything together
-
Write about it!
sensor
dim
I stalled for making a post for this project simply because the project turned out more wholistic than I suspected, but it came together quickly after a long harrowing process. The metamorphosis is so fast that I am overwhelmed by the change.
I was struggling with the delayed button states in the earlier week. The problem quickly got solved after I realized I did not include the p5 serial code in the folder. After I fully incorporated the code. The sketch started working smoothly. The rest of the work just came in naturally.
Nunu also made improvements on the fire animation from the previous iteration. We also added the flowers and a start screen. On the start screen, the retro flashing title adopted a pixelated font. The final sketch visual looks like the video on the left. The final work playtest is shown by the video on the right.
The Fabrication process also came in naturally. I have only made a simple hand-cut cardboard prototype for the final product. The final product is made from laser-cut acrylic that I believe was purchased and left by Coco and Ellie from our class.
class eight - joystick
nov 2nd
After trying the handshake in class, I am getting ready for the game idea Nunu and I are planning to do for project 2.
I did the joystick lab to see how to put the joystick in use. I found the pressing of the button has a really slow response. I am not sure how it will work with the p5 sketch. I am imagining it will only be slower in that case. I might need to figure out a better way to deal with that.
...
void loop() {
// read the first pushbutton:
int buttonState = digitalRead(2);
// if it's changed and it's high, toggle the mouse state:
if (buttonState != lastButtonState) {
if (buttonState == HIGH) {
// if mouseIsActive is true, make it false;
// if it's false, make it true:
mouseIsActive = !mouseIsActive;
Serial.print("Mouse control state: ");
Serial.println(mouseIsActive);
}
}
// save button state for next comparison:
lastButtonState = buttonState;
int sensor1 = analogRead(A0);
delay(1);
int sensor2 = analogRead(A1);
int xAxis = map(sensor1, 0, 1023, -5, 5);
int yAxis = map(sensor2, 0, 1023, -5, 5);
// print their values. Remove this when you have things working:
Serial.print(xAxis);
Serial.print(" ");
Serial.println(yAxis);
}
The OLED screen is very cool. Getting it to work, however, is a very bad experience. Because the display is quite wholistic on its own, it is hard when it doesn't light up. The Arduino application won't report any error message since the code was correct. I had to change a screen to debug since the first one I used just won't light up. When I changed to the second one, I plugged in the wrong port at first. Anyway, it works now. It is a really cool tool. I see a lot of potential in this component.
I also tested the arcade button for the project. For some reason, the response is really slow. I need to connect it to p5js to see if that is the case.
var serial;
var portName='/dev/tty.usbmodem11401';
var outData;
function setup() {
createCanvas(400, 400);
serial= new p5.SerialPort()
serial.on('error',serialError)
serial.open(portName)
}
function serialError(err) {
println('Something went wrong with the serial port.'+ err);
}
function draw() {
outByte=mouseX;
background(outByte,0,0);
serial.write(outByte);
}
void setup() {
Serial.begin(9600);
}
void loop() {
// Serial.print(Serial.available());
// analogWrite(A0, 255);
if (Serial.available() > 0) {
// if there's serial data available
int outbyte = Serial.read(); Serial.write(outbyte);
// send it back out as raw binary data
analogWrite(A0, outbyte);
//use it to set the LED brightness
}
}
The class exercise is extremely helpful. The lab for this week is more confounding for the mere fact that there are three various interfaces, and one of which is a web-based interface(???):
-
Arduino Software
-
Serial Control
-
P5js webpage
Do not take this wrong! I love p5js. I think the fact that it is all web-based and light-weighted is so glamorous and utilitarian. But using p5js as the serial communication tool with Arduino seems to be a weird exquisite-corpse act.
The concepts themselves are not as intricate as I thought they would, and I could see how serial communication would so enabling in the future. I'm excited to be less slavish and more original with serial communication soon.
Practice in class recreated
MouseX is controlling the brightness & screen color
Serial output to Arduino
Typing in H &L will turn on and off the LED
Serial Input from Arduino
The potentiometer value shown on terminal
class four - project1
oct 5th
design!
presenting: the sketchiest sketch in this world.
The idea actually comes from the first assignment: creative switch. Essentially, this project is a bunch of switches. Originally, I was thinking about a dancing device where connecting different body parts will produce different sounds. The idea developed into this implementable version of a hand device.
After discussing with the class, our team improved/expanded our design into a two hands instrument. I was tasked to do the original part where each finger has one switch.
prototyping on breadboard
each bottom makes a tone
...
void loop() {
int n1=digitalRead(2);
int n2=digitalRead(3);
int n3=digitalRead(4);
Serial.println(n1);
if(n1 == 0){
tone(speakerPin, notes[0]);
Serial.println(n1);
}else if(n2 == 0){
tone(speakerPin, notes[1]);
Serial.println(n2);
}else if (n3 == 0){
tone(speakerPin, notes[2]);
Serial.println(n3);
}
When making the prototype, I was originally using the input ports: D14 - 16 for the digital input. Weird enough, the input won't get updated after the first hit. The input would remain HIGH. Changing it to the digital(ONLY) port solves the problem, but I am not sure why.
In this stage, I also tried the amplifier lab trying to enhance the volume. It did not work. I think the problem lays in the shitty speaker. Maybe I should try to recreate the amplifier may be using a better speaker? I have just learned how to attach the jack...
left hand product without the amplifier
It worked!
I added the amplifier.
The graph on the tutorial was wrong. It needs to be plugged from the other side.
As we combined our works to present the final product, we also made some adjustments (position of the board, direction of wires, etc) to the physicality of the product to increase its usability and ornamental value.
My teammate was tasked to work on the right-hand device. We decided to use a Triple-Axis Accelerometer: adxl345 to measure the acceleration of the device, and use its output value to compare to a threshold to make a sound. They crossed into the same problem when adding the transistor for the amplifier.
final symphony with team
class three - lab3
sep 25th
void setup() {
Serial.begin(9600);
}
void loop() {
// get a sensor reading:
int sensorReading = analogRead(A0);
// map the results from the sensor reading's range
// to the desired pitch range:
float frequency = map(sensorReading, 0, 1023, 100, 1000);
Serial.println(frequency);
tone(8, frequency, 10);
}
After checking the pressure sensor and the speaker, the code created this simple sound machine that could make a sound based on how hard the sensor was pressed on. The result is not so obvious since the volume is quite low.
With a similar principle, I also tried with a photocell. The pitches changes are more obvious with the photocell after adjusting the range of the map based on the photocell I used.
#include "pitches.h"
// notes in the melody:
int melody[] = {
NOTE_E3, NOTE_E3,0,NOTE_E3, NOTE_C3, NOTE_E3,0,NOTE_G3,0, NOTE_G2};
// note durations: 4 = quarter note, 8 = eighth note, etc.:
int noteDurations[] = {3,3,3,4,8,8,4,4,4,4};
void setup() {
// iterate over the notes of the melody:
for (int thisNote = 0; thisNote < 10; thisNote++) {
// to calculate the note duration, take one second
// divided by the note type.
//e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
int noteDuration = 1000/noteDurations[thisNote];
tone(8, melody[thisNote],noteDuration);
//pause for the note's duration plus 30 ms:
delay(noteDuration +30);
}
}
void loop() {
// no need to repeat the melody.
}
Mario Music
I briefly wrote about Daniel Rozin's wooden mirror in my undergrad thesis, in which I read the piece as something that blurs the boundary between digital and physical by reconstructing the digital existence of the viewer in a physical domain. Having practiced more hands-on with the motor, I had a better understanding of how the very deconstruction and reconstruction work together. There are other logistics one needs to think of when conceiving an idea, but I do feel like little steps like this are bringing me closer to the “enlightenment”.
#include <Servo.h>
Servo servoMotor; // creates an instance of the servo object to control a servo
int servoPin = 3; // Control pin for servo motor
void setup() {
Serial.begin(9600); // initialize serial communications
servoMotor.attach(servoPin);
}
void loop()
{
int analogValue = analogRead(A0); // read the analog input
// print it
int servoAngle = map(analogValue, 700, 1023, 0, 179);
Serial.println(servoAngle);
servoMotor.write(servoAngle);
}
class three - in class
sep 19th
void setup() {
pinMode(9,OUTPUT);
pinMode(10,OUTPUT);
pinMode(A0,INPUT);
Serial.begin(9600);
}
void loop() {
int r=analogRead(A0);
Serial.println(r);
analogWrite(9,r/4);
float p=map(r,0,1023,0,255);
analogWrite(10,p);
}
Mapping
Very intuitive and similar to the visual mapping in processing and p5js.
The code shows the two ways of mapping the pot value in a workable range to the LEDs. The red light's resistor is controlled by the value of pot/4. The yellow light's resistor is controlled by the map function where it maps the value originally from 0 to 1023 into 0 to 255.
class two - prework & lab 1
sep 15th
pre-assignment play
A simple circuit with two 1.5v batteries, a 220 resistor, a red led light, and a switch.
The video on the left shows that one 1.5v battery will not light up the led light but two 1.5v batteries in a series circuit will illuminate the led. [Increased voltage?]
While it works now, the process was hard. Referring to the images to the right: to start off, connecting the batteries was really hard for me, and I am very aware of how unsafe this is LOL ⚠️. Secondly, I connected the switch falsely at first. It will always create a complete circuit. Luckily, the problems were fixed.
assignment: setting up a breadboard
After learning about the components, I started dabbling with the breadboard and creating a circuit with it. Something that really stopped me from proceeding is that the battery turns out to be dead (which I did not find out until 30 min of replugging everything), and the DC power jack is out...
I ended up using a power switch as a power source with help from David who was working there as a shop manager. As soon as the "power shortage" is resolved, the second difficulty emerged. For some reason, all the 7805 CT regulators we have in the shop is outputting 9.6-9.8v instead of 5v which is what they are designed to output. I ended up using a LD33V as a regulator for the breadboard practice illuminating the led.
assignment: creative switch
Here comes the big one. My switch is a paper clip. When the clip is idle, the bulb will light up as a reminder of one's constant anxiety. The circuit is simple enough; in fact, even simpler than my pre-assignment foreplay for the day.
The problem remains with the connectivity between the circuit itself and the battery. Plus, it is really hard to troubleshoot and narrow down the problem with something that sized smaller than my palm. I burnt my left-hand middle finger trying to hold onto the positive pole and had to re-solder repeatedly.
I think as the clip is also a conductor (covered with insulating coating), this little switch almost shorted itself after I filmed this video. I was cleaning the poles using a drill with a wire brush bit before re-soldering the wire onto the battery since the previous solder fell off inside of the glue gun (which by the way is such a bad idea I realized. It insulate, hence, obstruct the connection, and also is extremely hard to clean off the pole). Some of the coatings might have been ground down.
class one
sep 8th
We kicked off today with a thinking exercise inspired by Rube Goldberg Machines. Our group designed an industrialized bagel machine, where bagels can be prepared hassle-less-ly. (I was eating a bagel during the break. Ironically, I prepared the bagel myself this morning with greek yogurt, prosciutto, and cheddar.)
The exercise is cool and all. I felt kinda bad because it very much reminded me of the endless cycle of production in the capitalist context. It is like seeing how does industrialization slowly eats up and mutated the food culture. Merely, the idea of producing food in the streamline is weirdly disgusting but satisfying(??)... Maybe this is one of the enchanting curses of capitalism.
class two - lab2
sep 19th
digital input/output virgin test
Having no experience with Arduino - THE physical computing, I had a rough but fun start. I set up the board with a simple push button to learn about digital output and input. The concept itself is very intuitive, but I crossed into problems with the initiation. The USB cords do not recognize my Arduino device, resulting in the failure in uploading post a successful compilation. David working in the shop helped me recognize the problem and troubleshoot to a successful test.
digital input/output bulbs example
I found the code structure is very similar to Processing. The similarity is personally poetic since I consider this as my first toe tip into the water of physical computing; whereas, I started my (software) coding experience with Processing.
I often found my life experience whirling into beautiful loops, even recursion since my new experience seems to be building on top of the similar past experience. How romantic is that?
In the two bulbs example, the switch controls the two states where only one of the bulbs will light up at a time. The example was intuitive and figurative since both the digital input and output can be physically seen and obtained.
After following the examples' instructions, I managed to change the pins with other numbers using the chart below to obtain the same effect. Just like I still refer to the p5js or processing documentaries to this day, I know the documentary below will be very handy in the future.
void setup() {
pinMode(2, INPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
//setting input output based on where
the wire is connected
}
void loop() {
// read the pushbutton input:
as condition for two situations
if (digitalRead(2) == HIGH) {
// if the pushbutton is closed:
digitalWrite(3, HIGH);
digitalWrite(4, LOW);
// turn on yellow and off red
}
else {
// if the switch is open:
digitalWrite(3, LOW);
digitalWrite(4, HIGH);
// turn on red LED and off yellow
}
}
I was confused about the difference between analogRead - analogWrite and digitalRead - digitalWrite.
My understanding is that analog gives an int value while digital gives a boolean value.
Only the ports that start with "A" (such as A0 on the top left corner) will do analog values. Seems like all the ports will be capable of reading/writing digital value. The fact that some of the ports shares both digital and analog signals are quite confusing.
If not specified, the default is that the number is referring to the digital input/output. PS: the tilde signed ones are the (Pulse Width Modulation) PWM: D16, D17, D6, etc are capable of changing analog signal to digital signal.
void setup() {
pinMode(9,OUTPUT);
pinMode(A0,INPUT);
Serial.begin(9600);
}
void loop() {
int r=analogRead(A0);
Serial.println(r);
analogWrite(9,r/4);
}