Description:

The final piece consists of a chair sitting in a sectioned off/isolated space. The chair has switches positioned all around it that activate different soundscapes when pressed – when more than one of the buttons is pressed, there is a heightened experience. The chair in essence operates as a musical instrument. The responsive button combinations are listed below:

Button 1 = Sound 1

Button 2 = Sound 2

Button 3 = Sound 3

Button 4 = Sound 4

Button 5 = Sound 5

Button 2, Button 5 = Sound 6

Button 1, Button 3 = Sound 7

Button 2, Button 4 = Sound 8

Button 1, Button 5 = Sound 9

Button 1, Button 3, Button 4 = Sound 10

Button 2, Button 4, Button 5 = Sound 11

Button 1, Button 2, Button 5 = Sound 12

Button 1, Button 2, Button 4, Button 5 = Sound 13

Button 2, Button 3, Button 4, Button 5 = Sound 14

Button 1, Button 2, Button 3, Button 4, Button 5 = Sound 15

Here are three of the sound pieces that I made:

Documentation:

Reflection:

This project was difficult for me in several ways – I had trouble with the initial ideation, and then further executing my idea in a timely manner. I now also understand the importance of accounting for the evolution of an idea; I was not involved with the process long enough to apply the understanding of my object as it relates to a user, until much later in the project timeline. I also recognize that my desire and stress to make everything that I am creating perfect is often times hindering, especially when I’ve taken on a project that is out of scope. In future projects, I want to be better about making maquettes and more detailed sketches, as this will help me visualize my physical product at earlier stages in the making process.

In retrospect, I also wish I would have considered more how I wanted my physical object to be engaged with in a continuous manner. I was initially planning on attaching a series of LED’s activated by buttons, that make a sound once all pressed. After I pursued that idea, I realized it was not my intent for the piece, as it placed a limit on the amount of interaction that can occur with the chair. I have realized that intent and execution should operate in conjunction, this should inform the final product.

Process Documentation:

Chair in its initial stages

Chair being spray painted

Chair being reupholstered

Chair being reupholstered

Buttons mechanisms being coded

Logic Schematic:

Code Submission:

I was assisted/ guided in writing this code with the help of Sidney Church, professor in the School of Art.

Transmission Code: This code is embedded in the Arduino attached to the chair, and it transmits wireless signals to the receiver Arduino when a button is pushed or let go.

<iframe src=https://create.arduino.cc/editor/stuart1999/dbfb46ef-d854-4b04-8636-2f6c55aaca97/preview?embed style=”height:510px;width:100%;margin:10px 0″ frameborder=0></iframe>

Receiver Code: This code is embedded in the Arduino plugged into my computer, and it receives wireless signals from the transmitter Arduino when a button is pushed or let go. This information is used by the processing code to determine when/when not to play the sound tracks.

<iframe src=https://create.arduino.cc/editor/stuart1999/d0cf05fe-7680-4ea4-8376-542a8d41c880/preview?embed style=”height:510px;width:100%;margin:10px 0″ frameborder=0></iframe>

Processing Code: This code is what plays the audio tracks when there are received signals that the buttons are pushed/not pushed.


//Bring in libraries for additional functionality
import processing.serial.*; //this will allow us to monitor the serial connection
import ddf.minim.*;//this will allow us to play audio files

}

What Is The Thing?

A system to comfort, entice, and demand conditions of physical trust.

Three pointy-looking stools around a room, each topped with grass, each with a bit of text and an interactive thing on top of it. One stool has a mirror and a veil, one has an old green telephone, and one has a little child’s microphone with a switch. Interacting with these things makes little bells ring in other locations in the space. The bell sounds come from small speakers in the shapes of cubes hanging from the ceiling. Finally, there is a little oval bed on the floor nearby, with a grass mattress and a pillow. When you lay on the bed, there are little speakers by your ears that immerse you in natural sounds, and little bass speakers in the bed that give you a massage. When people use the things on the stools, it affects the sounds and feelings you get laying in the bed. If all the things on the stools are being used at once, a person in the bed will hear a special bell and will get a quiet secret message.

The stations are positioned around the space, so they can be discovered and interacted with individually, with their effects adding up on the edge of view or hearing. The texts by the stations are printed on small blocks, depicting Helvetica font in a mac os TextEdit window.

The texts:
Phone – you could call them after work to catch up
Microphone – you could give them permission by saying it first
Mirror – you could look them in the eye as they ring you up
Bed – you could get some rest

WHAT DOES THIS LOOK LIKE?

Objects in their natural environment

Objects in their natural environment, detail

The bed station in use

objects in use

VID_20190926_183515

WHAT WAS THE PROcess?

Step one: I was interested in machines that would have a contemplative, peaceful quality to them, and which would involve a viewer’s physical body. First, I came up with a number of impractical and expensive projects that I didn’t know how to do. A few of those are noted below.

bad ideas that don’t work

Step two: I decided to focus on feeling rather than technology, and see if that resulted in project ideas that were a little easier to build. Thinking about recent moments in my life: at the grocery store, on the phone to a parent, calling a dear friend who I miss but have difficulty reaching out to out of the blue, I thought I could give myself some options for how to live with a little more openness, and hypothetically (working ahead with deductive reasoning) a little more joy.

better ideas that might work

Armed with this functional plan, I got to work. I built the stools with bandsaw and router, cut out the speakers with a mitering tablesaw, and used a CNC router to make the arcs to frame the bed.

This might shock you, but it turns out that having a robot cut plywood for you is easier than cutting it yourself. I ended up adopting a few edits to the design for the handmade pieces along the way as I ran into trouble with hand fabrication. For example, the speakers were initially planned to have a pyramidal shape. Lacking the expertise to make extremely acute bevel cuts in 1/4″ plywood, I ended up going for a cube design. It took some sanding to get the glue stains off, but it more or less worked. I stuffed the boxes with fluff and put a knot in the internal cable for strain relief, and the speakers sounded OK and could hang on their own weight.

Design for the stool legs and the initial, more complex speaker shape (and driver layout) is below. The simpler driver layout meant I didn’t get a true full-range output– maybe a filter above 5k or so– but for the bell sounds, it wasn’t a serious problem for sound quality.

In order to have the simple logic switches on the stools trigger complicated sounds, I decided to use standard theater show control software, and use an arduino as just a trigger machine– like a drum pad on a MIDI controller. The arduino sent particular char values to a computer over the serial port when various logic conditions were met. I made a patch in Max/MSP to interpret the serial data and turn it into MIDI commands, which I then sent to QLab, the industry standard theater-sound program. In QLab, I could level and layer sound, and add effects like reverb to particular bits of audio that needed to be “smoothed out”. Everything needed to be smoothed out.

Another issue: this computer setup is ugly! It needed to be hidden somewhere far, far away. Initially, I thought it would be a good idea to use radio to make the stools wireless and able to go far afield. Instead, as I ran out of time, I noticed that our studio has a lot of XLR cables– so I made all the stools have XLR terminations, so I could use the existing cable to run them, wired, up to fifty feet away. This took some trial and error, as the inevitable impedance drop on the long cable messed up some of the more fragile voltages… For the microphone, I found that the amplifier chip had to be on the computer side of the cable run, or else the XLR wouldn’t properly carry its power supply. Ah well.I used a MOTU USB sound card an a six-channel restaurant power amplifier to get sound around to all the speakers– including to the four speakers down in the bed. That’s three channels: left and right for the ears, and one subwoofer channel split to two speakers, one under the pillow and one under the participant’s right hand (covered with grass of course). The specific rigging and placement for these speakers came from a lot of trial and error! I initially expected the subwoofers to be able to resonate the floor under the bed, but in a concrete basement gallery, this turned out to be wishful thinking. I found that a subwoofer under the head was most effective at making the whole body feel like it was being shaken; but in order to keep it from being overwhelming, I buried it inside extra grass under the pillow. The ultimate effect was that participants thought the hand buzzer was the only one that was active, while still having an immersive full-body experience.

And as for the triggered music, it sounds like this when it’s all playing:

And this is the secret message:

HOW DID THIS WORK, LIKE, LITERALLY?

With a microphone –> electret preamplifier; phone –> basic switch; and mirror –> ultrasonic rangefinder for when the “veil” is drawn back.

Logic diagram for the monstrosity

arduino – at least how it looks

For the arduino, it’s pretty simple: there are three inputs, on pins of your choosing. All outputs are via Serial back to the computer.

#include <NewPing.h>

const int triggerPin = 12;
const int echoPin = 13;
const int buttonOnePin = 2;
const int micPin = A0;

const int micLimit = 20;
const int pingFar = 20;
const int buttonFilterTime = 3000;
const int pingFilterTime = 3000;
const int micFilterTime = 4000;

bool buttonActive = false;
bool micActive = false;
bool pingActive = false;
char nextCmd;
char lastCmd = 0;

int serialvalue;
int started = 0;
int pingDist = 0;
int micVal = 0;
NewPing sonar(triggerPin,echoPin,500);

//time measures for filtering
long timeElapsed = 0;
long buttonTime = 0;
long micTime = 0;
long pingTime = 0;

char currCmd, prevCmd;

void setup() {
  // put your setup code here, to run once:
Serial.begin(9600);
pinMode(buttonOnePin, INPUT);
}

void loop() {
  //get sensor data
  int buttonOne = digitalRead(buttonOnePin);
  micVal = analogRead(micPin);
  micVal = abs(micVal-512);
  pingDist = sonar.ping_cm();

  //open serial connection, wait for input before sending
  if(Serial.available()){
    serialvalue = Serial.read();
    started = 1;
    }
  //send trigger char to serial if sensor conditions met
  
  if(started){

    timeElapsed = millis();
    buttonActive = (timeElapsed-buttonTime)<buttonFilterTime;
    pingActive = (timeElapsed-pingTime)<pingFilterTime;
    micActive = (timeElapsed-micTime)<micFilterTime;

    //Serial.println(micVal);
    Serial.println(pingDist);
    
    if(buttonOne==HIGH && !buttonActive) {
      buttonTime = timeElapsed;
      Serial.write('A');
    } else if (buttonOne==HIGH){
      buttonTime = timeElapsed;
    }
  
    if (pingDist!=0 && pingDist>pingFar && !pingActive) {
      pingTime = timeElapsed;
      Serial.write('B');
    } else if (pingDist!=0 && pingDist>pingFar){
      pingTime = timeElapsed;
    }
  
    if (micVal>micLimit && !micActive) {
      micTime = timeElapsed;
      Serial.write('C');
    } else if (micVal>micLimit){
      micTime = timeElapsed;
    }

    if (buttonActive && micActive && !pingActive) nextCmd = 'D';
    else if (buttonActive && pingActive && !micActive) nextCmd = 'E';
    else if (pingActive && micActive && !buttonActive) nextCmd = 'F';
    else if (buttonActive && micActive && pingActive) nextCmd = 'G';
    else nextCmd = 0;

    if (nextCmd != lastCmd) Serial.write(nextCmd);
    lastCmd = nextCmd;
    Serial.write('\0');
  }


  delay(100);

}

Max Code:

<pre><code>
----------begin_max5_patcher----------
1022.3oc0ZtrjapCDFds8SgJs1mozUtjU4dVkmfSNUJYaEGRgAJPNwoRk28i
QfmaAyzjoAlYicg.yOeRs96VB+qkKnqyOZqnjWP9WxhE+Z4hE9lpaXQ6wKn6
MG2jZp7WFcuspxryRW0btrC6SxRsN+IE2zX9A24V4ssVXba9ZR1tOWZ23ZjT
oXWwVQDBY8W51CthQ9u1eSxVun4q+1+HDm0r4d69Ygs4tPoWe8Utel5akRqa
32KWV+wp+N1b1i9mSZHgKBwgXYfpFx1uT7dIlOaDGfHwhAPLa1HViGwhnPvD
yimMhUHRrZ.DGMaDKQjX1.HNX1HVfGw7PFbh0yFwbDIVN.hUiNwY1ebRo+.3
rbm8jljOQ+RY9dxGMGI7OQI7N6Cjc1Gvdv9.kNt9KtTzamv0onebjt9fykm0
I.7+xDth3lgO04O674+xIbWax1g0.Ip3IfiWzyN5ZyjBht3mezofSGmMI3cA
OlJaJ4CCvTU7vyGCZxeF2meRX+LuZz8Vq498Hws3NbG1aYvOE39c3v84ovP3
V8Tf62hD2p6vcTebGLYbewplPppXg2JiqZJSH9J8kgVO9q0CUy5PQMMsCj85
UqhlSu5zby1lvFDwNzOtFz6FznTO+x.yfmAV87q3v1krACuYu.i2fjwKCtwq
L9oPFmWiC3mGsgjoUFM2fm3xMCXIp8tL8.edFt1uR0d8njWtjxjL2Sx4vR3y
gkAy8b3WgTnrb.gxyd0xEkmhcHaMNC4kE4EGJ3CXnum8dQKU2JvlyC5cuWBo
iZEh4E1LbJRT2TcXT.fw14aeD2jlWgza4Ry32B3dWwqTNWai3dqqLmvYLj16
TkrN1sck.A59fVOItVt7c6RsHYJ2RGChoL856So4Turs7y1Ly5FRXSP1nKZW
WlXRIqIwAWXPmObaaelXdnunqvdiz48lHFfos+zzzjr6+9q8OX0se29jp7Ck
aNqQ6FFRt4QaqsxkjYbImRbey0vaunN61gJTD.gpeymOZgBgPDGAgBfHDFDo
YPTBCglHcTPBFpWI8iWIE.ktW+ad4Vaoep+3KsT2szrIP5tUV73TlCIDJ.iQ
VPSJzXnD.gvvgTBwKVgw7OIn4eXXcIg3FGNFS+.obP2JqFekUcqrb7U9dgYW
KsdBjNpaoCl.oEcKc33Kc8+YOBGaOdXROFd7RPE9fQ1a4TUPhTNUBIfDqhQ9
QHDgQ1QAnL9BLThMYJAPnHDzgGOUDwilLkBlLkzSlRpISIHylDX3DwAMaBkn
bHVdiRMffrlBe3Uf0rKKlhhuaKqZ+4dQo6MeKuoNhU9CSxZNz+9ank1umb95
09VLka9ZhytwcnrYybNF075Jn6yOIb1gjVpOo7uW9+fD.h2C
-----------end_max5_patcher-----------
</code></pre>

description:

My piece is made up of a video and three physical circuits.

One circuit is an AND circuit; the next, an OR circuit; and the next, a NOT circuit. AND, OR, and NOT are three of the most basic circuits, which all electronic systems are made of.

These circuits are placed onto clear one foot by one foot squares, and are made of copper tape, switches, a light bulb, and battery. The light either turn on or off depending on which switch one closes opens.

The video shows a performance where several people walk the same path as electrons on a circuit board. They move through every path possible in the AND, OR, and NOT circuits.

more documentation of the work:

and gate

not gate

or gate

interaction

seventh documentation = link to video piece

Reflection

Initially, it was challenging to integrate binary logic into the conceptual focus of my piece. I tend to think of binary in a very binary way: as problematic. I struggled to come up with a project that was deeper than a surface level criticism of simplistic logic structures. In thinking about the rigidity of binary logic, I began to notice the humor and beauty that it structures the movements of electrons (some of the most mysterious entities in science). Electrons move in an electron cloud, where their position and direction cannot be known simultaneously. And yet, they can also exist within different circuit structures, their flow allowing lightbulbs to turn on and the electronic signals in our brain to fire. And I began to think about how this parallels the way humans are – both fluid and able to move through many different societal structures. I decided to make my art piece a meditation on this parallel, by showing both a video of humans moving as electrons and also three different basic interactive circuit boards. 

In working on this project, I’ve realized that it is hard for me to work on a peice unless I feel my initial idea is initially completely formed. I have also learned that, sometimes, ideas clarify, and become stronger than anything one could of thought of at first, through the act of making. I did not create any iterations of my piece before the final, and I see this as contributing to my piece’s weakness. Despite my effort, the lack of a thoughtful connection between the interactive circuits and the video create a shallow impression of simply illustrating different circuit diagrams rather than a mediation on the authority and lack of authority of the structures that form both circuits and society. I have realized that approaching making as a series of small steps, and leaving room for the evolution of an idea as you are building the piece, will make the work stronger. I think if I had done this, I would have considered the relationship between the circuit pieces and the video even more and been able to have my idea evolve and strengthen before the critique. 

For my next project, I will work on creating more detailed prototypes and work in thinking through making. I am excited for what comes next. 

Note: I am planning on creating a revision of this piece, as I feel something important is here, but it has not been articulated the way it needs to be. Right now, I am thinking of having the video projected on a person’s back. They are hooked up to a heartbeat sensor, and this sensor dictates when a light turns on and off, and this light illuminates the branch of a tree. This feels right to me, and I am excited to work on this early next week.

logic schema:

photos of process:

initial ideation of performance

idea of specific labels on circuits – did not use

pedestal light idea, did not use. Starting to work through the process of choreographing this piece

choreographing the performance piece

new piece iteration idea/ imposing the projection onto the surface of skin

THIS IS MY SON / PLEASE HELP HIM BREATHE

THIS IS MY SON / PLEASE HELP HIM BREATHE – electronics, cardboard, car headlight (2019)

TIMS/PHHB Demo

Narrative Description

I am standing in a room with you. In my arms, I am holding this car headlight, the size of a baby. You can see the inside, though, which is full of rough, sharp edges of broken plastic and wires. At where the head of a baby would be is a board with eight lights, four red and four green. The red lights are on, and the green are off.

There is also a white cardboard box with four blue buttons, which are all a bit uncomfortably far apart. Above the buttons I have written the words “THIS IS MY SON,” and below, “PLEASE HELP HIM BREATHE.” When you press one of the buttons, one of the red lights turn off, and one of the green lights turn on. However, when you stop pressing the button, the red light turns back on, and the green light turns off.

Close up of the interface. Box made of a leftover sustain pedal shipping box.

Each button is operated by a two-state switch.

Where the action happens. Power is ran into a USB block.

Inactive state when powered on.

Scale to me.

Process Reflection

Ho boy, what a process.

I don’t believe I began this project with the intention of making it easy for me. Perhaps it was all in the excitement of ideation that, in a way, the world seemed wide open for me to utilize it at its fullest. And then, of course, I realized I had a far smaller understanding of electricity than I initially considered, already acknowledging it was small to begin with. This coming to terms happened several times throughout the project, and in the midst of several other large scale projects that I was involved with, I found myself constantly having to distill what I wanted to do down to something more manageable for my mental state.

Poem written as the background for a mural, alternative medium for this piece.

This essentializing allowed me to explore different possible mediums in an effort to come up with a project that could actually exist in the world. One of the more… adventurous included creating a mural out of the found materials I had been gathering up to this point, with a poem that I had written on the spur of the moment. In a sense, this allowed me to realize a version of the piece that laid everything out on the table, and in turn liberated me in the rebound as I created the more concise, slightly-more-sophisticated end product. As I work with technology and materials that I couldn’t be more unfamiliar with if I tried, I hope to utilize a similar way of thinking earlier on in the process to give myself more time on a path I can commit myself to, rather than trashing concepts within a few days and despairing.

On a more positive note, I did find a love of mapping out the wiring onto the breadboard with this project. With the time I had, making all of the connections neater and compact ended up becoming wildly satisfying, and I hope to take that further in the next project I work on. In the same vein, however, I hope to utilize more of my software experience as well; initially, I was hesitant to create something that utilized my laptop, but it is becoming more and more clear that the ideas I want to execute will necessitate it in some way, shape, or form.

Initial sketches, ideating on bird form. The lower drawing was an idea for a Cerberus-like sculpture.

Maquette for the initial form of the bird.

Approach

Approach to the Project

Users “Climbing” 01

Users Exploring the Topography of the Table

Users “Climbing” 02

Users Navigating and Testing Switches

Users “Climbing” 03

Users’ Dancing Fingers

Climbing Table In-Use

Climbing Demonstration

Close Up of How Switches Are Embedded

Embedded Lever and Switch

Blindfold

Simple Perspective of the Blindfold

Inner Workings of the Climbing Table

Perspective Showing the Electronics that Make the Climbing Table Work

Description

Abstract Description

A table has little switches on it. People who can’t see sit around the table and play with the switches. When the right pairs of switches are pushed and switched on, the people at the table hear a sound. When other groups of switches are pushed, the table shakes.

Narrative Description

The Climbing Table is an interactive installation which invites up to four people to sit at a short table and to blindly explore a topographic landscape of CNC-milled plywood that features embedded buttons and switches. By pressing buttons and turning on switches in the correct combination, sounds are emitted from the table which ultimately play a chord. The concept strives to bring people close together and portray the individual unintentional and intentional actions that contribute to a larger effort. Ultimately, the project strives to represent the complexity of working with others and navigating tasks with a lens that magnifies the interaction and connection between people.

Process Images

Initial Concept Sketches:

The initial idea was to have a larger table with embedded LEDs, speakers, and vibration speakers. In developing the concept, various aspects of the idea were tweaked to address ideas of teamwork and group dynamics. For example, the proportions of the table were changed to a square in plan so that everyone had equal access to the buttons, which were placed in an array format.

Axonometric Sketch of Outputs

Elevation of Placement/Planning of Outputs

Plan View of Envisioned Interaction

CNC Regrets:

To make the cost of buying materials for the table cheaper, I laminated 8 sheets of 6 mm thick plywood, but the glue job was not perfect. The material warped a bit because I just clamped the material together after applying glue (should have used vacuum table). As a result, due to the intricacy of the topography that I modeled, some small chunks of plywood were detached during the CNC job. The detail in the model also caused the CNC job to take over 4 hours. While the process would have been faster and more efficient using foam, the ultimate texture, look, and feel of the table was definitely augmented by the material properties of the plywood.

Collage of Table Post-CNCing

Soldering Switches:

Collage of Soldering Switches

I ended up deciding to use 12 switches, 6 of the smaller switches that can remain on or off and 6 of the slightly larger push lever switches that function as buttons. The process of soldering everything together as one can imagine was difficult for someone who had not soldered before, but it worked out in the end. During this process, I heavily considered using 12 of the lever switches for convenience sake, however, I was interested in how the more continuous switches would change the interactions between users and how people’s decisions could make or break whether or not a speaker worked, so I kept both types.

Table Legs:

Detail of Leg Secured to the Table

Although ideally the table legs would have been more seamlessly integrated into the table in a fashion that didn’t penetrate through the topographic surface, in the interest of time and focusing on other aspects of the design that were more significant, I decided to use a few screws to attach the surface to the 2X2’s that I had chopped to size. I was worried about stability, but the legs worked really well.

Wiring:

As one can imagine, with 12 switches, 8 speakers, 2 Arduinos, and a bunch of wires can get really messy. There were times when I had to use tape to bundle pairs of wires together to make sure I could navigate through the jungle of wires and electronics. It ended up working out, although it would have been better to test everything at a singular scale to make sure that everything was wired correctly and the code worked before scaling up.

Process Perspective of Computer and Wiring Progress

Process Reflection

I thought I knew what I was getting into when I decided to take on this concept. The digital fabrication would be a lengthy process, the shear quantity of switches would make a simple logic diagram very complex, and the integration of the two systems would be a rough one. I definitely underestimated how much work it would take to execute on it though. The modeling and CNC-ing of the table wasn’t actually that difficult, but access to machines and technology struggles in general definitely pushed the project back. The sanding and post processing of the table was then expedited to make time for the technology to come in. I wasn’t able to spend as much time as I would have liked, but it was fairly straightforward and there were other things that were more pressing.

When it came to technology, this was where I learned the most lessons. Not only in regards to the wiring of the electronics and coding the Arduino, but also general lessons to carry forward. I learned that having everything working electronically separately from its housing is great, but then integrating it into the housing becomes a very fragile and frustrating process. I think in the future, I should try and start small and slowly build up the projects along with the technology, although perhaps more cumbersome, by working on the digital fabrication and electronic parts in parallel, I would have foreseen issues that came up like how I planned on embedding the switches or how I would house the tangled mess of wires and electronics. I also learned about general tips and tricks about wiring and electronics to put more effort upfront and have an easier time troubleshooting later on. Knowledge-wise, I learned a lot about how the logic chips work and got to try out some cool things which was great!

Looking forward, I was really inspired by other people’s projects that integrated more full body activation of its users. I also felt that my project was more of a social experiment and lacked the force of a strong message/theoretical underpinning. Moving forward, I want to inject more meaning and purpose into my projects, so that they are more impactful experiences and bring a different perspective on a complex issue. Lastly, in regards to creatively using electronics to make cool experiences, I want to strive to do more with less. I got really caught up in having a lot of options, more buttons, and more switches which ended up making the project difficult to pull off (although it did add more things to find and explore). I think if I had used maybe 4 switches, one for each person, and had embedded AND, OR, NAND, XOR, etc. logic chips based on combinations of the switches, that it could have been a much more refined project that would be more interesting and playful.

Logic Schematic

Proposed:

The proposed logic schematic included more vibration as well as light for each switch. As the design began to progress, I found that the LEDs weren’t making sense as a concept unless they were strong enough to produce sensible heat and so that eventually was taken out. The vibration was scaled down as well due to lack of time and planning on testing various vibration methods.

Process Logic Schematic

Final:

The final logic schematic shows what was left at the end. The vibration was intended to be controlled by OR logic instead of AND due to constraints of vibration speakers, however some errors in either code or understanding of sending signals to the speakers used for vibration made it not function in reality. The OR logic was not applied through chip though, and was through Arduino programming/code.

Final Logic Schematic

Primary Arduino Code (Speakers)

//Climbing Table by Alex Lin
//This code inputs signals from various input pins, checks for HIGH or LOW,
//then sends a signal to a speaker if the input is HIGH. This code is sourced
//from the following site: https://courses.ideate.cmu.edu/16-223/f2019/text/exercises/Arduino/event-loop-programming/event-loop-programming.html#exercise-event-loop-programming
//and was developed by Professor Garth Zeglin. It allows for multiple speakers 
//to be controlled by one Arduino board. 
//The pins are matched in numerical order (A0 > 2, A1 > 3, etc.)

#define outputPin1 7
#define outputPin2 2
#define outputPin3 3
#define outputPin4 4
#define outputPin5 5
#define outputPin6 6

#define inputPin1 A0
#define inputPin2 A1
#define inputPin3 A2
#define inputPin4 A3
#define inputPin5 A4
#define inputPin6 A5

long next_output_time_1 = 0;        // timestamp in microseconds for when next to update output 1
long next_output_time_2 = 0;        // timestamp in microseconds for when next to update output 2
long next_output_time_3 = 0;        // timestamp in microseconds for when next to update output 1
long next_output_time_4 = 0;        // timestamp in microseconds for when next to update output 2
long next_output_time_5 = 0;        // timestamp in microseconds for when next to update output 1
long next_output_time_6 = 0;        // timestamp in microseconds for when next to update output 2

long output_interval_1 = 1012;       // B interval in microseconds between output 1 updates
long output_interval_2 = 1351;       // G interval in microseconds between output 2 updates
long output_interval_3 = 851;       // interval in microseconds between output 1 updates
long output_interval_4 = 2551;       // interval in microseconds between output 2 updates
long output_interval_5 = 2025;       // interval in microseconds between output 1 updates
long output_interval_6 = 1703;       // interval in microseconds between output 2 updates

int output_state_1 = LOW;           // current state of output 1
int output_state_2 = LOW;           // current state of output 2
int output_state_3 = LOW;           // current state of output 1
int output_state_4 = LOW;           // current state of output 2
int output_state_5 = LOW;           // current state of output 1
int output_state_6 = LOW;           // current state of output 2

void setup() 
{
  Serial.begin(9600); // initialize serial communications

  //Setting up pins
 
  pinMode(outputPin1,OUTPUT);
  pinMode(outputPin2,OUTPUT);
  pinMode(outputPin3,OUTPUT);
  pinMode(outputPin4,OUTPUT);
  pinMode(outputPin5,OUTPUT);
  pinMode(outputPin6,OUTPUT);

  pinMode(inputPin1,INPUT);
  pinMode(inputPin2,INPUT);
  pinMode(inputPin3,INPUT);
  pinMode(inputPin4,INPUT);
  pinMode(inputPin5,INPUT);
  pinMode(inputPin6,INPUT);
}

void loop()
{
  // read the current time in microseconds
  long now = micros();
    
  Serial.println(analogRead(A0));

  // Polled task 1 for output 1.  Check if the next_output_time_1 timestamp has
  // been reached; if so then update the output 1 state.
  if (now > next_output_time_1 && analogRead(A0) > 0) {

    // reset the timer for the next polling point
    next_output_time_1 = now + output_interval_1;

    // toggle the output_state_1 variable
    output_state_1 = !output_state_1;

    // update output pin 1 with the new value
    digitalWrite(outputPin1, output_state_1 );
  }

  // Polled task 2 for output 2.  Check if the next_output_time_2 timestamp has
  // been reached; if so then update the output 2 state.
  if (now > next_output_time_2 && analogRead(A1) > 0) {

    // reset the timer for the next polling point
    next_output_time_2 = now + output_interval_2;

    // toggle the output_state_2 variable
    output_state_2 = !output_state_2;

    // update output pin 2 with the new value
    digitalWrite(outputPin2, output_state_2);
  }

  // Polled task 3 for output 3.  Check if the next_output_time_3 timestamp has
  // been reached; if so then update the output 3 state.
  if (now > next_output_time_3 && analogRead(A2) > 0) {

    // reset the timer for the next polling point
    next_output_time_3 = now + output_interval_3;

    // toggle the output_state_2 variable
    output_state_3 = !output_state_3;

    // update output pin 3 with the new value
    digitalWrite( outputPin3, output_state_3);
  }

    // Polled task 4 for output 4.  Check if the next_output_time_4 timestamp has
  // been reached; if so then update the output 4 state.
  if (now > next_output_time_4 && analogRead(A3) > 0) {

    // reset the timer for the next polling point
    next_output_time_4 = now + output_interval_4;

    // toggle the output_state_2 variable
    output_state_4 = !output_state_4;

    // update output pin 4 with the new value
    digitalWrite( outputPin4, output_state_4);
  }

    // Polled task 5 for output 5.  Check if the next_output_time_5 timestamp has
  // been reached; if so then update the output 5 state.
  if (now > next_output_time_5 && analogRead(A4) > 0) {

    // reset the timer for the next polling point
    next_output_time_5 = now + output_interval_5;

    // toggle the output_state_2 variable
    output_state_5 = !output_state_5;

    // update output pin 3 with the new value
    digitalWrite( outputPin5, output_state_5);
  }

    // Polled task 3 for output 3.  Check if the next_output_time_3 timestamp has
  // been reached; if so then update the output 3 state.
  if (now > next_output_time_6 && analogRead(A5) > 0) {

    // reset the timer for the next polling point
    next_output_time_6 = now + output_interval_6;

    // toggle the output_state_2 variable
    output_state_6 = !output_state_6;

    // update output pin 3 with the new value
    digitalWrite( outputPin6, output_state_6);
  }
}

Secondary Arduino Code (Vibration)

//Climbing Table by Alex Lin
//This code inputs signals from various input pins, checks for HIGH or LOW,
//then sends a signal to a vibration speaker if the input is HIGH. This code is sourced
//from the following site: https://courses.ideate.cmu.edu/16-223/f2019/text/exercises/Arduino/event-loop-programming/event-loop-programming.html#exercise-event-loop-programming
//and was developed by Professor Garth Zeglin. It allows for multiple vibration speakers 
//to be controlled by one Arduino board.
//A0 and A1 are matched to outputPin1 and A2 and A3 are matched to outputPin2

#define outputPin1 5
#define outputPin2 10

long next_output_time_1 = 0;        // timestamp in microseconds for when next to update output 1
long next_output_time_2 = 0;        // timestamp in microseconds for when next to update output 2

long output_interval_1 = 50000;       // interval in microseconds between output 1 updates
long output_interval_2 = 45000;       // interval in microseconds between output 2 updates

int output_state_1 = LOW;           // current state of output 1
int output_state_2 = LOW;           // current state of output 2

void setup() 
{
  Serial.begin(9600);
  
  pinMode(outputPin1,OUTPUT);
  pinMode(outputPin2,OUTPUT);

  pinMode(A0,INPUT);
  pinMode(A1,INPUT);
  pinMode(A2,INPUT);
  pinMode(A3,INPUT);
}

void loop()
{
  // read the current time in microseconds
  long now = micros();

  Serial.println(analogRead(A0));

  // Polled task 1 for output 1.  Check if the next_output_time_1 timestamp has
  // been reached; if so then update the output 1 state.
  if (now > next_output_time_1 && (analogRead(A0) > 0 || analogRead(A1) > 0)) {

    // reset the timer for the next polling point
    next_output_time_1 = now + output_interval_1;

    // toggle the output_state_1 variable
    output_state_1 = !output_state_1;

    // update output pin 1 with the new value
    digitalWrite( outputPin1, output_state_1 );
  }

  // Polled task 2 for output 2.  Check if the next_output_time_2 timestamp has
  // been reached; if so then update the output 2 state.
  if (now > next_output_time_2 && (analogRead(A2) > 0 || analogRead(A3) > 0)) {

    // reset the timer for the next polling point
    next_output_time_2 = now + output_interval_2;

    // toggle the output_state_2 variable
    output_state_2 = !output_state_2;

    // update output pin 2 with the new value
    digitalWrite( outputPin2, output_state_2 );
  }
}

Collage:

Photo Credit + Collage Credit: Christina Brown

A collage that I had envisioned in the beginning coming to life. It would have been very difficult to get a completely plan view with long exposure, but this begins to capture that original diagram.

Overlayed Collage of Users Interacting with the Climbing Table

Pine, Tile Board, misc. Electronics
6′ Physical Installation and Sculpture
Introduced with a 2 mins. Spoken Word Performance

2019
Individual Project
Rong Kang Chew

A human-sized lightswitch stands in front of you. This is life, and Life Requires your Input. What happens when you lift up the lightswitch – it’s heavy and needs both hands – but nothing changes. You notice two footswitches. It’s awkward to try to step on both of them and lift up the lightswitch at the same time. Finally – something happens a few feet away, behind the switch! But wait – you can’t see it, you’re frozen in your position. A small light turns on, and you here a faint buzz, but it’s barely there and you can’t witness it for yourself. Is all this effort worth it? Do you need to do everything at once? Does life require all your input at the same time?

You’re tired – maybe you want to take a break.

The Concept

This interactive sculpture explores a physical representation of our commitments, responsibilities and tasks in our life. There is a semblance of a logic gate here, which was a requirement for this piece. Logic exists in our desire to sometimes do everything – essentially to do this AND that AND this AND that. This desire can sometimes be overwhelming or paralyzing. What’s worse is that if you can’t see the fruits of your labor – and it causes you to consider and question all of your efforts.

The Process

While brainstorming for this piece, I began to think about the relationships that I have in life. For this concept, I was thinking about the relationships within my life and how I have to manage all of them. I began to think about how sometimes I spend a lot of time on certain projects, only for them to disappear after some time. How could I represent this in a physical sculpture?

(There were certain ideas I had a stronger desire to explore – but were more difficult to implement with more complex electronics. Learning to let go of certain ideas in the moment was difficult but a necessary process to have an installation in time.)

I decided to go with something more literal – switches that represent life. The original concept was to juxtapose the size of inputs and outputs. An extremely large input would produce an extremely small output, and vice versa. These two processes or transformations would be placed next to each other to show how we usually don’t get what we expect. A maquette of this type of portrayal was made to visualize how this juxtaposition might look like.

As the deadline approached, I decided that it would be necessary to cut down the sculpture to something achievable. Upon the advice of my instructor Heidi, I decided to focus on the large to small input. This would require me to build a large physical switch from scratch out of wood and smaller electronics. I added the dimension of the footswitches to freeze the guest and prevent them from looking at the output.

Under the guidance of my other instructor Zach, I was able to draw up some plans for the support and front panel of this physical switch. We bought a white front panel for this switch to emulate a wall switch, which was quite an adventure to haul over from Home Depot.

The woodworking process was the most challenging, having never worked with wood and power tools beyond drilling the occasional hole. I had to ask for a lot of help in order to get started, but fortunately was able to learn quickly. Within the timeframe, I was unable to come up with a precise CAD model of the work, so I had to improvise and make changes as I discovered available materials issues with the piece, like the height of the hole for the switch and so on. Learning to be flexible and making quick informed decisions proved to be helpful.

The final piece came together after a several long hours of hard work, and I was happy that it was functionally complete. There were some sacrifices made –  the light switch knob remaining black instead of having a white housing, the front panel had to be sawed in half, and footswitches were used instead of arcade buttons. But these sacrifices did ensure the work was complete on time and looked complete for the showing. The final switch was installed together with its output box about 6 feet away, wires hidden away with gaffer tape.

As part of the showing, I decided the night before that I had to introduce the piece with some words. The piece was quite literal, so visually, it looked just like a switch and would likely just be read as is without additional meaning. In order to convey the emotional aspect of the piece – I gave a 2-minute long spoken word piece, talking through my emotions and thoughts as I approached the switch and “wanting to do everything”. I was glad to have given this performance, as I believed it helped everyone to understand the piece and connect with the underlying concepts better.

If I had more time, I would like to have further completed the appearance of the switch. There are some missing pieces, like the housing of the switch that instead used a piece of fabric as the screen – that made the switch a little less desirable looking. The output box was also missing a physical motion output I was intended to produce and complement the light and sound outputs. However, I guess the missing output also adds to the “disappointment” message from the outputs of life.

Another aspect of the piece that I thought a lot about was that during the performance, there was moments of unexpected laughter as certain words or statements were said. I felt that this broke the atmosphere that I was trying to build, but perhaps this is a way that the audience would process those thoughts. If I were to perform this piece again, I might employ music in order to create a more controlled atmosphere.

Overall, as a first step into the journey between performance art, sculpture and physical computing, I would consider this piece to be a successful exploration that did convey a specific message about what kind of inputs and expectations we have in life. The piece maybe did portray some of my current frustrations with life, but creating it did help me think about it, and made it OK to have some smaller outputs out of life.

Final Presentation Photos:

Final Documentation Photo:

How to interact with the machine:

How to use the machine:

The white acrylic box has total of three switches on the front side of the machine. By switching one of the switches it will activate the machine. The first switch from the top has a sleepy face on the left and a smiley face on the right. The second switch has a money bag sign on the left and a no money bag sign on the right. The third switch has a moon sign on the left and a sun sign on the right.

Each switch is intended to express the user’s physical state when interacting with the machine. Depending on which switch is on/off, the machine will determine whether the user is allowed to have coffee or water.

Process images:

The final process of finishing and assembling all the acrylic cladding that disguises the workings of the machine.

Putting the switches on the machine, which provides a simple interaction. Before, I had ideas of more complicated interacting methods.

The inside of the machine. The placement of the pumps and the liquid containers were important.

Finally installing the pumps and putting on the switches to the breadboard.

Getting started. I didn’t know how the switch or breadboard worked. Began with using Zach’s acrylic switches to just understand how it works.

Figuring out the logic before starting anything. I had the idea of what to do, but didn’t know how to implement it.

Process Reflection: 

One of the difficulties in the process was implementing the ideas and converting it to a logic schematic. Coming up with the idea or fabricating the machine was not as difficult, since I had some experience in fabrication and design; however, it was difficult in expressing the idea in a logic schematic and working with circuits, because of my lack of expertise in electronics.

This project definitely helped me working with electronics and I hope to gain more experience. I would also like to experiment with diverse ways of interaction. I resorted to simple switches because I didn’t have enough time and knowledge in working with electronics.

Logic Schematic:

Users enter a dimly lit space with the goal to light up cylindrical paper lamps by matching the right wires together. Each wire is paired by having the same material on each end. Music could be activated if the user switches the correct lamp on and off quickly as a bonus feature.

The piece aims to stimulate the design process: 1) the designer enters a new problem space and begins to search for answers blindly. 2) Through intuition, the designer generates possible solutions that may or may not be fruitful to the design. 3) Further down the process the goal becomes clearer and refining the design becomes easier, reflected by the increase in light to identify the correct wires to pair together.

Music samples used in the project are made by students from Exploded Ensemble class.

Final installation

The organization helps with transportation and storage

Process

As it was my first time working with a breadboard and anything circuit related, it was intimidating to begin to think about how to realize the logic chips into the project. Under many guidance and help sessions, it is gratifying to see the results and things I learned along the way to realize the project. The messiness from tangled wires resembles how I felt towards the end of the project as if I could begin to piece out some answers and navigate myself through the technical and logic-driven aspects of my own project. The fabrication aspect of the project was easier compared to the technical circuitry as it is familiar grounds for me. With the amount of wire and length, they are things got messy very quickly, thus an organization system of zip lock bags are used to help with transportation and storage of the project.

Fabrication

Assembling lamp bases

Close up on acrylic control tower

Attaching velum to wooden bases

Assembly of all fabricated lamps and control units

Wires and Circuitry