Final Project: Etch-A-Sketch+ (Thomas Waugh)

Etch-A-Sketch+

                  

Our project, the Etch-A-Sketch+ is based on the traditional Etch-A-Sketch, however ours has additional features and is more visually stimulating. The controller of a traditional Etch-A-Sketch only has two knobs, ours not only has an extra knob but also four extra buttons. The wiring is pretty sample, after all, the physical component is little more than a bonafide fightstick that one would use for a game such as Street Fighter.

The code is pretty basic. There are three knobs. The first controls the size of the circle, the second controls the x-value of the circle and the third controls the y-value. The first button randomizes the background color of the program. If the button is held down it strobes the light rapidly, producing a cool effect (epileptics be warned). The second button creates a horizontal line of circles which behave identically to the primary circle. The third does the same as the second but in a small X shape. The fourth button randomizes the inside color of the circle. The controls are very intuitive and can be mastered within seconds.

import processing.serial.*;

String myString = null;
Serial myPort;

int NUM_OF_VALUES = 7;
int[] sensorValues;

int snakeLength = 0;

int red = 0;
int blue = 0;
int green = 0;

int redBG = 255;
int blueBG = 255;
int greenBG = 255;

void setup() {
  //size(700, 700);
  fullScreen();
  background(255);
  setupSerial();
  delay(150);
}

void draw() {
  updateSerial();
  printArray(sensorValues);
  if(snakeLength == 35){
    changeBG();
    background(redBG, greenBG, blueBG);
    snakeLength = 0;
  } else {
    snakeLength++;
  }
  
  fill(red, blue, green);
  ellipse(sensorValues[1], sensorValues[2], (sensorValues[0]/4)+25, (sensorValues[0]/4)+25);
  
  if(sensorValues[3] == 0){
    randomBG();
    background(redBG, greenBG, blueBG);
  }
  
  if(sensorValues[4] == 0){
    horizontal();
  }
  
  if(sensorValues[5] == 0){
    crossShape();
  }
  
  if(sensorValues[6] == 0){
    changeColor();
  }

  
  filter(ERODE);
  delay(15);
}

void keyPressed(){
  if(key == '1'){
    randomBG();
    background(redBG, greenBG, blueBG);
  }
  
  if(key == '2'){
    horizontal();
  }
  
  if(key == '3'){
    crossShape();
  }
  
  if(key == '4'){
    red = int(random(0, 255));
    green = int(random(0, 255));
    blue = int(random(0, 255));
  }
}

void horizontal(){
  ellipse(sensorValues[1]+50, sensorValues[2], (sensorValues[0]/4)+15, (sensorValues[0]/4)+15);
  ellipse(sensorValues[1]+100, sensorValues[2], (sensorValues[0]/4)+10, (sensorValues[0]/4)+10);
  ellipse(sensorValues[1]+150, sensorValues[2], (sensorValues[0]/4)+5, (sensorValues[0]/4)+5);
  ellipse(sensorValues[1]+200, sensorValues[2], (sensorValues[0]/4)+5, (sensorValues[0]/4)+5);
  ellipse(sensorValues[1]-50, sensorValues[2], (sensorValues[0]/4)+15, (sensorValues[0]/4)+15);
  ellipse(sensorValues[1]-100, sensorValues[2], (sensorValues[0]/4)+10, (sensorValues[0]/4)+10);
  ellipse(sensorValues[1]-150, sensorValues[2], (sensorValues[0]/4)+5, (sensorValues[0]/4)+5);
  ellipse(sensorValues[1]-200, sensorValues[2], (sensorValues[0]/4)+5, (sensorValues[0]/4)+5);
  ellipse(sensorValues[1], sensorValues[2], (sensorValues[0]/4)+15, (sensorValues[0]/4)+15);
}

void crossShape(){
  ellipse(sensorValues[1]+50, sensorValues[2]+50, (sensorValues[0]/4)+15, (sensorValues[0]/4)+15);
  ellipse(sensorValues[1]-50, sensorValues[2]+50, (sensorValues[0]/4)+15, (sensorValues[0]/4)+15);
  ellipse(sensorValues[1]+50, sensorValues[2]-50, (sensorValues[0]/4)+15, (sensorValues[0]/4)+15);
  ellipse(sensorValues[1]-50, sensorValues[2]-50, (sensorValues[0]/4)+15, (sensorValues[0]/4)+15);
  ellipse(sensorValues[1], sensorValues[2], (sensorValues[0]/4)+15, (sensorValues[0]/4)+15);
}

void changeBG(){
  redBG = redBG + int(random(-3, 3));
  blueBG = blueBG + int(random(-3, 3));
  greenBG = greenBG + int(random(-3, 3));
}

void randomBG(){
  redBG = int(random(0,255));
  blueBG = int(random(0,255));
  greenBG = int(random(0,255));
}

void changeColor(){
  red = int(random(0, 255));
  green = int(random(0, 255));
  blue = int(random(0, 255));
}

void setupSerial() {
  printArray(Serial.list());
  myPort = new Serial(this, Serial.list()[ 2 ], 9600);
  

  myPort.clear();
  myString = myPort.readStringUntil( 10 );
  myString = null;

  sensorValues = new int[NUM_OF_VALUES];
}

void updateSerial() {
  while (myPort.available() > 0) {
    myString = myPort.readStringUntil( 10 ); // 10 = 'n'  Linefeed in ASCII
    if (myString != null) {
      String[] serialInArray = split(trim(myString), ",");
      if (serialInArray.length == NUM_OF_VALUES) {
        for (int i=0; i<serialInArray.length; i++) {
          sensorValues[i] = int(serialInArray[i]);
        }
      }
    }
  }
}

void setup() {
//  Serial.begin(9600);
//  pinMode(2, INPUT_PULLUP);
//  pinMode(3, INPUT_PULLUP);
//  pinMode(4, INPUT_PULLUP);
//  pinMode(5, INPUT_PULLUP);
//}
//
//void loop() {
//  
//  int sensor0 = analogRead(A0); // size potentiometer sensorValues[0]
//  int sensor1 = analogRead(A1); // x potentiometer sensorValues[1]
//  int sensor2 = analogRead(A2); // y potentiometer sensorValues[2]
//  int sensor3 = digitalRead(2); // button 1 sensorValues[3]
//  int sensor4 = digitalRead(3); // button 2 sensorValues[4]
//  int sensor5 = digitalRead(4); // button 3 sensorValues[5]
//  int sensor6 = digitalRead(5); // button 4 sensorValues[6]
//
//  Serial.print(sensor0);
//  Serial.print(",");
//  Serial.print(sensor1);
//  Serial.print(",");
//  Serial.print(sensor2);
//  Serial.print(",");
//  Serial.print(sensor3);
//  Serial.print(",");
//  Serial.print(sensor4);
//  Serial.print(",");
//  Serial.print(sensor5);
//  Serial.print(",");
//  Serial.print(sensor6);
//  Serial.println();
//
//  delay(100);
//}

Recitation 10: Making a Media Controller (Thomas Waugh)

 

Technology is completely the base of this assignment. Everything about it screams technology, I mean, it’s literally two pieces of software communicating with each other resulting in the manipulation of an image. I find this assignment to be particularly tech oriented as this is one of the first assignment to incorporate not only arduino and processing code but also outside media. This combination of things has really opened up a whole new world of possibilities. Before, with the limited tools available, there were less options when one wanted to get creative with their project. Now, however, with the ability to implement all these things together to create a project the possibilities for creativity are much, much greater than before.

// IMA NYU Shanghai
// Interaction Lab
// For receiving multiple values from Arduino to Processing

/*
 * Based on the readStringUntil() example by Tom Igoe
 * https://processing.org/reference/libraries/serial/Serial_readStringUntil_.html
 */

import processing.serial.*;

PImage gene;

String myString = null;
Serial myPort;


int NUM_OF_VALUES = 3;   /** YOU MUST CHANGE THIS ACCORDING TO YOUR PROJECT **/
int[] sensorValues;      /** this array stores values from Arduino **/

int filterNO;

void setup() {
  size(600,600);
  gene = loadImage("gene.jpeg");
  background(0);
  setupSerial();
}


void draw() {
  updateSerial();
  printArray(sensorValues);
  println();
  println();
  println();

  background(0);
  rectMode(CENTER);
  image(gene, mouseX-(sensorValues[1]/4), mouseY-(sensorValues[0]/4), sensorValues[1]/2,sensorValues[0]/2);
  
  if(sensorValues[2] < 150){
    filter(THRESHOLD);
  }
  
  if(sensorValues[2] > 150){
    if(sensorValues[2] < 300){
      filter(GRAY);
    }
  }
  
  if(sensorValues[2] > 300){
    if(sensorValues[2] < 450){
      filter(INVERT);
    }
  }
  
  if(sensorValues[2] > 450){
    if(sensorValues[2] < 600){
      filter(POSTERIZE, 80);
    }
  }
  
  if(sensorValues[2] > 600){
    if(sensorValues[2] < 750){
      filter(ERODE);
    }
  }
  
  if(sensorValues[2] > 750){   
    filter(DILATE);
  }
}


void setupSerial() {
  printArray(Serial.list());
  myPort = new Serial(this, Serial.list()[ 2 ], 9600);
  // WARNING!
  // You will definitely get an error here.
  // Change the PORT_INDEX to 0 and try running it again.
  // And then, check the list of the ports,
  // find the port "/dev/cu.usbmodem----" or "/dev/tty.usbmodem----" 
  // and replace PORT_INDEX above with the index number of the port.

  myPort.clear();
  // Throw out the first reading,
  // in case we started reading in the middle of a string from the sender.
  myString = myPort.readStringUntil( 10 );  // 10 = 'n'  Linefeed in ASCII
  myString = null;

  sensorValues = new int[NUM_OF_VALUES];
}



void updateSerial() {
  while (myPort.available() > 0) {
    myString = myPort.readStringUntil( 10 ); // 10 = 'n'  Linefeed in ASCII
    if (myString != null) {
      String[] serialInArray = split(trim(myString), ",");
      if (serialInArray.length == NUM_OF_VALUES) {
        for (int i=0; i<serialInArray.length; i++) {
          sensorValues[i] = int(serialInArray[i]);
        }
      }
    }
  }
}


// IMA NYU Shanghai
//// Interaction Lab
//// For sending multiple values from Arduino to Processing
//
//
//void setup() {
//  Serial.begin(9600);
//}
//
//void loop() {
//  int sensor1 = analogRead(A0);
//  int sensor2 = analogRead(A1);
//  int sensor3 = analogRead(A2);
//
//  // keep this format
//  Serial.print(sensor1);
//  Serial.print(",");  // put comma between sensor values
//  Serial.print(sensor2);
//  Serial.print(","); // add linefeed after sending the last sensor value
//  Serial.print(sensor3);
//  Serial.println();
//
//
//  // too fast communication might cause some latency in Processing
//  // this delay resolves the issue.
//  delay(100);
//}

Recitation 9: Serial Communication (Thomas Waugh)

// IMA NYU Shanghai
// Interaction Lab
// For sending multiple values from Arduino to Processing


void setup() {
  Serial.begin(9600);
}

void loop() {
  int sensor1 = analogRead(A0);
  int sensor2 = analogRead(A1);

  // keep this format
  Serial.print(sensor1);
  Serial.print(",");  // put comma between sensor values
  Serial.print(sensor2);
  Serial.println(); // add linefeed after sending the last sensor value

  // too fast communication might cause some latency in Processing
  // this delay resolves the issue.
  delay(100);
}

//// IMA NYU Shanghai
//// Interaction Lab
//// For receiving multiple values from Arduino to Processing

///*
// * Based on the readStringUntil() example by Tom Igoe
// * https://processing.org/reference/libraries/serial/Serial_readStringUntil_.html
// */

//import processing.serial.*;

//String myString = null;
//Serial myPort;


//int NUM_OF_VALUES = 2;   /** YOU MUST CHANGE THIS ACCORDING TO YOUR PROJECT **/
//int[] sensorValues;      /** this array stores values from Arduino **/


//void setup() {
//  size(500, 500);
//  background(255);
//  setupSerial();
//}


//void draw() {
//  updateSerial();
//  fill(0);
//  noSmooth();
//  strokeWeight(10);
//  point(sensorValues[0]/2, sensorValues[1]/2);
//  printArray(sensorValues);

//  // use the values like this!
//  // sensorValues[0] 

//  // add your code

//  //
//}



//void setupSerial() {
//  printArray(Serial.list());
//  myPort = new Serial(this, Serial.list()[ 2 ], 9600);
//  // WARNING!
//  // You will definitely get an error here.
//  // Change the PORT_INDEX to 0 and try running it again.
//  // And then, check the list of the ports,
//  // find the port "/dev/cu.usbmodem----" or "/dev/tty.usbmodem----" 
//  // and replace PORT_INDEX above with the index number of the port.

//  myPort.clear();
//  // Throw out the first reading,
//  // in case we started reading in the middle of a string from the sender.
//  myString = myPort.readStringUntil( 10 );  // 10 = 'n'  Linefeed in ASCII
//  myString = null;

//  sensorValues = new int[NUM_OF_VALUES];
//}



//void updateSerial() {
//  while (myPort.available() > 0) {
//    myString = myPort.readStringUntil( 10 ); // 10 = 'n'  Linefeed in ASCII
//    if (myString != null) {
//      String[] serialInArray = split(trim(myString), ",");
//      if (serialInArray.length == NUM_OF_VALUES) {
//        for (int i=0; i<serialInArray.length; i++) {
//          sensorValues[i] = int(serialInArray[i]);
//        }
//      }
//    }
//  }
//}

Arduino-Processing Drawing Module (Thomas Waugh Final Project Proposal Essay)

Thomas Waugh
11/16/18

Arduino-Processing Drawing Module

For my final project I want to create a machine which uses inputs from arduino and the keyboard to create an interactive image in processing. I’ve found that even just pushing a button to turn on an led is an engaging and surprisingly fun experience so I thought that if I made a machine with several buttons and several potentiometers it could be really fun to play with. I want to map each button to a different function for example, maybe have one of them rotate through a random set of color values, have another one rotate the whole image until released and also one last button which clears the whole image. I want the two potentiometers to act like the knobs on an etch-a-sketch (the x,y values of the cursor will be controlled by values read from the potentiometer). I also want to add functions that come without interaction, by that I mean I want to have functions being called at all times from the draw function, for example maybe have the background pulse a color. I also want to incorporate keyboard functions for additional movement and functionality.

One more aspect I would like to look into would be whether or not I can incorporate music into my project. I would like to do something similar to what happens in the game Chroma Lab. In this game, it is a sandbox color game, very similar to this project. In this game, music is a central part and the orbs in the game flash along to the bpm to make the user experience much more engaging as the game comes alive to the user’s choice of music.

The aim of this project is to make a machine which can make cool psychedelic images with as little effort as possible. Like my previous project, the focus is to make it as intuitive as possible. If a first-time user can touch it for the first time and completely understand the project that would be ideal. This is a textbook example of interaction. It reads the action from the user and gives a reaction through the processing output window. After successful completion, I hope to master my own project and create an album with screenshots from my project that I can then throw into photoshop and enhance to create some really cool pictures.

Recitation 8: Final Project Process (Thomas Waugh)

A. How has your work in this course involved your definition of interaction?

My definition of interaction was integral in many parts of this course. Just about every one of the recitations or in-class assignments was a textbook example of an interaction. This class has opened my eyes to the vast amount of possible interactions and has made me think about the possibility from interactions in completely new ways.

B. Based on the initial definition and your experience developing and executing your midterm project, how has your definition of interaction evolved?

My definition of interaction was an action and a reaction. My experience in Interaction Lab has led me to understand that it is actually more complicated than that — just because something has an action and a reaction doesn’t mean it is really a good interaction. A good interaction is a set of actions and reactions that is helpful, necessary, or entertaining. My midterm project wasn’t helpful or necessary, but it was entertaining. I have learned that the best projects are not just one, but all three. I project which is helpful, necessary and entertaining is the best kind of project — a project which helps you do something which was previously a chore in a fun new way is the best kind of project one can ask for.

C. Research two other interactive projects, one that aligns with your definition of interaction and one that differs from it.

I think that one project that comes to mind when I use my new definition of interaction was the battery trash robot somebody made during midterm. It took an initially joyless task and with a few simple interactions the process becomes fun.

I think one project which does not go along with my definition of interaction is a simple button on an arduino that lights up a button. While this is technically an interaction, it is not helpful, necessary, or entertaining.

D. Write a “new” definition of interaction in your own words. Draw from your account above and try to evolve your definition beyond the current convention. It should be polished and professional: imagine it will be printed on IMA Interaction Lab’s next course syllabus!

A new definition of interaction could be: any object with an action and a reaction which improves one’s quality of life. I think that this definition is better because it involves one subjective category and can add more interpretation and diversity to projects.

Recitation 7: Processing Animation (Thomas Waugh)

Recitation Exercise:

The Juul follows the mouse pointer and plays an animation when the mouse button is pressed. The background text changes to a random color every time a key is pressed.

(code below.)

Recitation Homework:

(Recitation_Exercise)_VOD

(code commented out below.)

 

int r = 0;
int g = 0;
int b = 0;

void setup(){
  size(600,600);
  background(255);
}

void draw(){
  
  background(255);
  fill(0);
  text("r:" + r, 0,30);
  text("g:" + g, 0,65);
  text("b:" + b, 0,100);
  writeJuul();
  
  drawJuul(mouseX, mouseY);
  
  if(mousePressed) {
    for(int i = 0; i < 50; i++){
      noStroke();
      fill(random(150,200),random(20,50)); 
      int g = int(random(-10,10));
      int h = int(random(-10,10));
      ellipse(mouseX+g, mouseY-95-(i*4)+h, i*2, i*3);
    } 
  }
}

void drawJuul(int x, int y){
  fill(80);
  rect(x-15,y-95,30,190);
  fill(r,g,b);
  rect(x-15,y-95,30,30);
  fill(240);
  rect(x-13,y-70,26,8);
  fill(0);
  rect(x-2, y-70, 4, 8);
  fill(255);
  ellipse(x, y-35, 5,5);
  
}

void writeJuul(){
  textSize(30);
  stroke(0);
  fill(r,g,b);
  for(int i = 0; i < 14; i++){
    text("Juul", 15, 135+(i*35));
  }
  for(int s = 0; s < 8; s++){
    for(int i = 0; i < 17; i++){
      text("Juul", 80+(s*65), 30+(i*35));
    }
  }
}

void keyPressed(){
  r = int(random(0,255));
  g = int(random(0,255));
  b = int(random(0,255));
  fill(0);
}

//int x = 300;

//int posX = 300;
//int posY = 300;
//boolean expand = true;

//boolean rUP = true;
//boolean gUP = true;
//boolean bUP = true;


//int r = 10;
//int g = 10;
//int b = 10;

//void setup(){
//  size(600,600);
//  background(255);
//  strokeWeight(20);
//  colorMode(HSB, 100);
//}

//void draw(){
//  background(100);
  
//  if(rUP == true){
//    if(r < 100){
//      r++;
//    } else {
//      rUP = false;
//    }
//  }
  
//  if(rUP == false){
//    if(r > 20){
//      r--;
//    } else {
//      rUP = true;
//    }
//  }
  
//  if(gUP == true){
//    if(g < 100){
//      g++;
//    } else {
//      gUP = false;
//    }
//  }
  
//  if(gUP == false){
//    if(g > 20){
//      g--;
//    } else {
//      gUP = true;
//    }
//  }
  
//  if(bUP == true){
//    if(b < 100){
//      b++;
//    } else {
//      bUP = false;
//    }
//  }
  
//  if(bUP == false){
//    if(b > 20){
//      b--;
//    } else {
//      bUP = true;
//    }
//  }
  
  
//  stroke(r,g,b);
//  ellipse(posX,posY,x,x);
  
//  if(expand == true){
//    if(x < 500){
//      x = x + 2;
//    } else {
//      expand = false;
//    }
//  }
  
//  if(expand == false){
//    if(x > 300){
//      x = x - 2;
//    } else {
//      expand = true;
//    }
//  }
  
//}

//void keyPressed(){
//  if(key == 'd'){
//    if(posX < 540){
//    posX = posX + 10;
//    }
//  }
//  if(key == 'a'){
//    if(posX > 10){
//    posX = posX - 10;
//    }
//  }
//  if(key == 'w'){
//    if(posY > 10){
//    posY = posY - 10;
//    }
//  }
//  if(key == 's'){
//    if(posY < 540){
//    posY = posY + 10;
//    }
//  }
//}

Recitation 6: Processing Basics (Thomas Waugh)

Image: (Newport Cigarettes)

I chose this image because these are my favorite cigarettes back home. After arriving in China, I realized how large of a cigarette culture there is in this country. I am also very homesick, so I combined these two ideas into a making an animated version of the box in Processing. I started off knowing that I wanted to first recreate the box then I would add animations. To do so, I declared functions newPort(), which wrote the text, goldStripe(), which draws the stripe in the middle, blueStripe(), which makes the main part of the box, the blue stripes across the middle, and whiteTop(), which basically just refreshes the background and allows the animations on the text and gold stripe to happen. To animate the text, I created an if loop that moved it to the right until it reached a certain point at which point it moved it back past the left of the screen. I also added code so that after every time the text was drawn, it was given a random color. I also wrote the code so that the background refreshes after 15 drawings to give the Newport text some cool, colorful tracers. For the blue stripes, I just created a function which drew all the lines at once and after it finished drawing all of them it changed the anchor point down a little bit each time until it reached a certain point then reset itself. For the gold in the middle, it is just another loop which changes the weight of the stroke and makes the gold do a pulsing effect.

I think that drawing this in Processing was cool because it let me draw something that I draw all the time in a whole new way. Without processing, I couldn’t add animations in the intentionally glitchy manner that I did. I couldn’t make it flash colors on paper and I couldn’t get the lines to move on paper.

 

 

int p = 0;
int r = 50;
int q = 0;
int w = 30;

void setup(){
size(450,550);
whiteTop();
}

void draw(){

goldStripe(w);
blueStripes(q);
newPort(p, (random(0,255)), (random(0,255)), (random(0,255)));
if(p < 425){
p++;
} else {
p = -400;
if (r < 150){
r = r + 10;
} else {
r = 0;
whiteTop();

}
}

if(q < 30){
q++;
} else {
q = 0;
whiteTop();
}

if(w < 75){
w++;
} else {
stroke(#ffffff);
strokeWeight(w+1);
line(0, 180, 450, 180);
w = 5;
}
}



void whiteTop(){
stroke(#ffffff);
fill(#ffffff);
rect(0,0,450,180);
}
void blueStripes(int q){
strokeWeight(1);
fill(#29a3a3);
stroke(#29a3a3);
rect(0,180,450,550);
stroke(#196666);
strokeWeight(3);
for(int i=0; i<38; i++) {
line(0, q+(180 + (10 * i)), 450, q+(180 + (10 * i)));
}

}

void goldStripe(int w){
strokeWeight(w);
stroke(#cca300);
line(0, 180, 450, 180);
}

void newPort(int x, float l, float m, float n){

fill(l,m,n);
textSize(90);
String s = "Newport";
text(s, r+(1*x), 50, 400, 130);
}

Midterm Project (Thomas Waugh)

Project Name: APIM V1.03

Statement of Purpose:

Our goal was to create a very simple musical instrument that even somebody with absolutely no musical knowledge would be able to jam out on. We also wanted to make sure to make it compact and self-enclosed to facilitate better jamming. Musical instruments can take years to learn how to play proficiently and we sought to change this forever by creating the most intuitive instrument ever. Our project is intended as an intro to music and could also be suitable for small children. The project was inspired by a MIDI controller. Building a MIDI controller was our initial goal, however we quickly realized that we lacked the materials, time, and the Arduino lacked the ports to make this a possibility. We adapted however, to a much simpler version, which is what it is. To make the user experience better out of the box, we included a simple metronome, controlled by a potentiometer which helps turn random beeps into musical notes in a sequence.

Artist Inspiration:

I was inspired by local NYU Shanghai Dubstep DJ, Rugby Scruggs for my project. Watching him perform on stage, pushing so few buttons while still managing to work out a crowd was amazing to me. If he, pushing maybe a couple buttons a minute, doing virtually nothing, could rock a crowd, maybe the same was possible with an Arduino. He doesn’t even control the melody while he DJs, he just changes the BPM — the APIM can do that and more.

Another inspiration to this project was Ableton Live, the digital audio workspace that I’ve been using for a while now. Ableton helped me to discover the amount of possibilities that sound holds — just how mutable every sound is. From day one of planning, I had hoped to be able to implement FX knobs, such as reverb, delay, compressor, saturation, etc., however this quickly proved to be too challenging.

Project Description:

I built an Arduino instrument. I made it as user-friendly as possible by adding only a few buttons and making it nice and small. Our project was the only project in the class which was hand-held and in order to do that there had to be sacrifices for the portability and compact nature of the device. The APIM excels at being completely understood at first sight. Once it’s in the user’s hands, the user has no problem mastering it almost immediately, which was the initial goal so I was happy with that.

Project Significance:

The APIM is significant because it was the first time I had ever built my own self-enclosed, fully-functional machine of my own design. Being able to use the laser cutter to make all of my pieces perfect helped me reach a level of precision I had previously been unable to achieve. I was also happy to be able to follow through with my original idea of a MIDI controller, even though it wasn’t exactly what I had expected it was going to be. This project helped me really understand the limitations and advantages of using an Arduino in your project. The advantages were its size and its ease of programming, the disadvantages were its lack of external ports for a stronger speaker and lack of pins for more buttons and inputs as well as the machine’s low voltage making for a low-powered machine.

Project Design and Production:

The main box which holds the Arduino was laser cut. The first time around, the box was cut completely wrong, almost three times the size that we had meant to cut it. This meant that we had to do a whole other round of cutting in order to get our box to the correct size. The speakers, as the APIM requires two, were also an obstacle. One speaker was taken from the IMA lab rental room and the other one was salvaged out of a broken pair of headphones. As a matter of fact,  the speaker salvaged from the headphones was actually significantly louder than the one intended for use by Arduino. This helped teach me that sometimes the resources we think about using first and the resources which are the most accessible are not necessarily the best for the job. The wiring was also a challenge. Because we put the project on the inside of an enclosed box, we had to worry about the wires inside becoming unplugged rending the machine broken as opening the box to repair wires was quite a challenge. This made us really think carefully about how we positioned the wires, which length wires we used and how we set up the circuit. We also recycled the buttons from when we learned how to solder at the beginning of the semester. Lastly, in order to make the project entirely self-enclosed, we needed to somehow attach a portable power source, what better option than a portable power bank? This, however, also raised problems as the power bank was heavy and hard to attach to the APIM. Eventually, this was remedied with velcro, but the power bank did not get installed without its own fair share of problems.

Conclusion:

If I’m going to be honest, I was pretty disappointed with how the project turned out in the end. As I worked on it more and more, I saw more and more things that I wanted to implement but I just didn’t have enough time. For example, we wanted to implement distance sensors as a sudo-whammy bar and we wanted to add a bunch more potentiometers to control the FX. However, to do these things required a lot more work and were simply not realistic. To implement the distance sensor, the entire structure of the APIM and it’s entire nature would have had to have been changed drastically. The FX would’ve been easier but the Arduino simply is not equipped with enough to handle them and I doubt the speaker would have been able to express the intricacies that the FX create. I also would have really liked to be able to add more buttons, at least enough to finish an octave so that any song can be played. If I had more time I would love to add these things, but for what it was, I am satisfied with what I accomplished but I would still love to expand on it.

Recitation 4: Drawing Machines (Thomas Waugh)

What: A drawing machine made of two motors that change direction when knobs are turned.

Materials:

Arduino (x2)

Breadboard (x2)

Jumper Cables

Stepper Motor (x2)

H-Bridge (x2)

Laser-cut Arms (x2)

Laser-cut Motor Holder (x2)

3D Printed Motor Coupling (x2)

Paper Fasteners

Process:

 

 

Question 1:

What kind of machines would you be interested in building?Add a reflection about the use of actuators, the digital manipulation of art, and the creative process to your blog post.

I would really love to build machines which can be used to make really cool sounds. I was given a Roland-TR08 a few years ago and I loved playing with it and being able to manipulate the machine to create the exact sound that I wanted. It is disappointing to me that it looks like the only audio output accessible by arduino so far is the really weak speaker which came in the arduino kit. I would love to be able to create some sort of machine that can make sounds that I could then turn around to sample in Ableton maybe. I think it would be cool to be able to use some sort of real world sound machine that I can then use in my digital audio workspace to create a whole new sound. I really love making music because it allows a full range of creativity. Nothing is right or wrong, there are no rules, just whatever you think sounds best.

An actuator is the part of a machine which moves something in the real world. In order for a robot to actually be able to interact with the real world actuators are necessary. Thanks to the digital manipulation of art,  art can be manipulated in new ways because of the precision of computers. Computers are able to be much more accurate than humans when performing tasks allowing humans to create things which were impossible before.

Question 2:

Choose an art installation mentioned in the reading ART + Science NOW, Stephen Wilson (Kinetics chapter). Post your thoughts about it and make a comparison with the work you did during this recitation. How do you think that the artist selected those specific actuators for his project?

I really liked Waves by Daniel Palacios Jimenez. I like how even though the machine is a simple design it is still able to create a cool image with only one motor. I also think it’s cool how the machine senses what is going on in the world around it and reacts accordingly. I think that this machine is the most similar to what we have been doing in Interaction Lab. This project in particular dealt with using motors to create visuals and a large portion of Interaction lab is about making robots which sense and interact with the real world.