Kenneth Chu

For this recitation, we are applying the digital fabrications methods we discussed on Tuesday’s class, and turning them into a kinetic sculpture. 

 

Step 1: Design

For doing laser cutting, we are using a program called cuttle, which serves a as digital canvas for us to work on. This recitation was to be done in partners. So my partner and I split ourselves within student A and B, I was B. I started by dragging a rectangle into the origin of the canvas in Cuttle, and giving it the dimensions of  80mmx60mm. The next thing I did was give it round corners of 3mm as indicated in the instructions. Then I dragged another rectangle, but this time with dimensions of 40mmx 2.8mm, and placed it on the Y-axis @ -17.5mm, and applied a Boolean difference.  After that, I measured the dimensions of the servo motor, and gave the measurements to my partner, so he could incorporate them into his design.  

 

Design with rectangle:

 

 

Design with Boolean Difference: 

 

 

Step 1.2: Pattern design

For the pattern design part, I started by drawing a circle, and putting it on the origin. I then gave it the size of 120mm in diameter. Then, I created a shape that resembled a ninja star, and made the pattern repeat, I though this shape was cool looking, and would actually compliment what my partner came up with. Then I added a rectangle the size of the servo motor, as my design was going to be the static one. Then I uploaded both of my designs into the google drive provided, and went into the fabrication room. Pictures of the design can be found below.   

 

Design pattern:

Cuttable Design:

 

 

 

Step 2: Laser cut

For this part, we went into the fabrication room, and got a tour of it, then we proceeded to the woodwork part, and Andy got our files, and printed them. 

Timelapse of the printing:

 

Step 3: Assemble 

For the assembly part, we just took the stand, and assembled it together. It was a very straightforward process. Then we connected the servo straight into the Arduino, and in IDE opened the code for servo sweep. photos and videos can be found below. 

 

Final assembly:

 

 

Arduino Sweep & sculpture functioning:

 

PROJECT TITLE:

Move it! 

The reasoning behind this project stems from the inability for us as students to be as physically active during school periods. This has come from my self reflection, as well as observing my peers. This is why I wanted to create an interactive project that would encourage its users to move. I plan on using heart rate monitors, and using Arduino and processing in order to gamify them, and make it interactive. 

My plan for this project is using 2 heart rate sensors, and making them into bracelets, which would then connect into Arduino. The sensors would take the heart rate values, and display them side by side in processing. Then to start the game, a button switch would be activated (still thinking). This would prompt processing to randomly select from a pool of exercises, and pick one. It would then show a prompt, saying “first one to X bpm wins!” This would imply that both players have to do the exercise until one of the reaches X bpm, therefore winning.  I will start working on this project on Nov 28. I will check out the heart rate sensors, and I’ve already ordered the bracelets. After that I will work in the dorm on processing, and will expect to have a functioning prototype for user testing. 

The context, and significance, as mentioned above, is to get participants active, through physical movement. And also engaging the users through competition. The project aligns with my definition of interaction, because, it keeps the users engaged through movement, and  I believe it will be memorable to them. I don’t think that this project has been created, as I did not use any outside influence. I just recalled what we have been doing in the class, and decided to do things we have already done. I believe that this project will lead to people thinking about getting more physical activities more often, which will in turn lead to better health!

Project #1 

Move it!

For this project, I involved my love of sports, and wanted to do something related to it, so I envisioned something that would encourage people to move so the topic that I thought for it was physical movement. My first thought was using a heart rate sensor, that would be connected to a user, and using processing as a means of helping the user visualize their heartbeat, and prompting them to do different sets of physical activity. At the end, the user would be displayed their initial heartbeat, and their end one, demonstrating that exercise made their heartbeat increase. This is meaningful to me, because many of us take for granted the rhythm inside us that keeps us alive. The sketch for this project can be found below.

 

 

Project #2:

Paint it loudly!

My second project was actually pretty similar to the first part of recitation 8. I was visualizing something that would allow the user to draw different shapes, on a processing canvas. However the size of the shapes would be determined by a microphone, and they would be moved around the canvas using button, similar to a retro video game. There would also be a button in the middle of the button in order for the user to switch to a random color! The main topic for this project would be creative digital drawing, and would engage its user by the use of their voice, and fingers in order to create art. The sketch for it can be found below. 

 

Project #3

Light it up

This project consists of an array of neo pixels that could be lit up individually in processing. The main topic for this project is light visualization, and how it allows the user to design the lighting pattern based on their creativity. The means for doing this is through a dot in processing, and using a joystick to move it around the singles LED’s, thus lighting them up with a click. The sketch can be found below. 

 

 

Task #1:  Make a Processing Etch-A-Sketch 

For this task we were directed to build a sketch in processing and Arduino, that would simulate an Etch-A-Sketch, my approach for building the circuit was based on Nov 17’s class, however, the circuit for today’s recitation required 2 potentiometers, one controlling the X-axis, and the other one controlling the Y-axis. The picture of the finished circuit can be found below. The second step of task 1 is to open the “analog read serial” so we can check if everything is wired correctly. After checking, I opened the “send multiple values” sketch and modified it so it could take values from the 2 potentiometers, it also allowed to read the values on the serial monitor in a more stable way. Moreover, the sketch also contained the serial record that would allow Arduino to communicate with processing. The code from Arduino can be found below, as well as the video. 

 

First Circuit build: 

 

Testing Analog Read Serial:

Arduino Code:

#include “SerialRecord.h”

// Change this number to send a different number of values
SerialRecord writer(2);

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

void loop() {
int sensorValue1 = analogRead(A0);
int sensorValue2 = analogRead(A1);

writer[0] = sensorValue1;
writer[1] = sensorValue2;
writer.send();

delay(10);
}

Testing Send Multiple Values:

 

After the Arduino part was done, I opened processing, and built a sketch that used “Receive multiple values” so it allows to read what the Arduino is sending. After, I drew the circle sketch and it worked pretty well. The video can be found below. After verifying that it worked, I made the background black, and switched the circle for a line. I established 2 variables in order to control the x and y axis of the line. I also had to move the background to setup, so that the stroke movement is recorded. Also, I added a “if” statement, in order to be able to erase the old strokes. Video, and code can be found below. 

 

Processing circle:

 

Processing final Code test: 

 

Processing code:

import processing.serial.*;
import osteele.processing.SerialRecord.*;

Serial serialPort;
SerialRecord serialRecord;

float px;
float py;

void setup() {
  size(500, 500);
  background(0);
 
  String serialPortName = SerialUtils.findArduinoPort();
  serialPort = new Serial(this, serialPortName, 9600);
  serialRecord = new SerialRecord(this, serialPort, 2);
}

void draw() {
 
  serialRecord.read();

  float value1 = serialRecord.values[0];
  float value2 = serialRecord.values[1];

if( key == 'b') {
background(0);

}


  float x = map(value1, 0, 1024, 0, width);
  float y = map(value2, 0, 1024, 0, height);


  stroke(255);
  line(x, y, px, py);

  px=x;
  py=y;
  //circle(x,y,100);
}

 

For task 2, I decided to work with my neighbor. This time, the information is sent from processing into Arduino using “serial record” and “receive multiple values”, and after it is sent, it will make the servo motors “hit the ball” and make bounce into the opposite side. The circuit we came up for can be found below. After a little bit of trial and error, we managed to fix the Arduino code, because after the hitting the ball, it wouldn’t retract back into original position. And it only hit it once. The video for the final sketch can be found below, as well as the code for processing, and Arduino. 

 

Circuit:

Final video:

 

Arduino Code: 

 

 

 

 

 

 

 

import processing.serial.*;
import osteele.processing.SerialRecord.*;

Serial serialPort;
SerialRecord serialRecord;

int x = 0;
int size = 200;
int b = 0;

void setup(){
  fullScreen();
 
  String serialPortName = SerialUtils.findArduinoPort();
  serialPort = new Serial(this, serialPortName, 9600);
  serialRecord = new SerialRecord(this, serialPort, 2);
}

void draw(){
  drawBack();
  drawBall();
}

void drawBack(){
  background(0);
}

void drawBall(){
  noStroke();
  int R = floor(map(x, 0, width, 0, 255));
  int B = floor(map(x, 0, width, 255, 0));
 
  fill(R, 0, B);
  circle(x, height/2, size);
 
  if(x < width && b % 2 == 0)
  {
    x += 5;
    serialRecord.values[0] = 0;
    serialRecord.values[1] = 0;
  }
  if(x > 0 && b % 2 != 0)
  {
    x -= 5;
    serialRecord.values[0] = 0;
    serialRecord.values[1] = 0;
  }
  if(x == 0 || x == width)
  {
    b++;
    if(x == 0){
    serialRecord.values[0] = 1;
    }
   
    if(x == width){
    serialRecord.values[1] = 1;
    }
  }
  serialRecord.send();
}

PREPARATORY RESEARCH AND ANALYSIS

 

At the beginning of the semester, my idea of interaction was the response from a machine to the input you gave it. However, as the semester progressed, and we had our midterm projects, I realized that it included many more layers than I imagined, feedback could have its way as sound, light, motion, etc. So it got me thinking about what I should do for my final project, and I thought of heart rate, because many of us don’t mind it throughout the day, but it is very important to keep us alive. 

 

So for the research part I found 2 projects related to heart rate. The first one is “pulse” by Rafael Lozano-Hemmer. This exhibition consists of many incandescent light bulbs attached to the ceiling, and 2 electrodes which you grab. The electrodes will record it and display it to the first light bulb, and the past recordings will move down by one bulb, until they reach the end and disappear.I think that this exhibition is relating the heartbeat of the past people, and displaying which I think is really interactive. 

 

The second interactive project is “ Pulse Tank” by Rafael Lozano-Hemmer. This exhibition uses four heart rate sensors that translate a heartbeat into water ripples that can be visualized by the four participants. I think this is really interesting because it allows people to visualize their heartbeat in a completely different way. Moreover, I believe that both examples contribute to a very positive interactive experience because as Edmonds said “This tension between feeling in control and not being able to predict seems to be a significant factor in achieving a ‘sustaining’ experience” (Edmonds, 15), and i also believe that they have provided me with more insight for my final project.

 

References: 

 

10. Edmonds, “Art, Interaction and Engagement,” 2011 15th International Conference on Information Visualisation, 2011, pp. 451-456, doi: 10.1109/IV.2011.73. 

 

My colleagues’ news. PULSE TANK BY RAFAEL LOZANO-HEMMER – ADA | Archive of Digital Art. (n.d.). Retrieved November 12, 2022, from https://www.digitalartarchive.at/database/general/work/pulse-tank.html 

Rafael Lozano-Hemmer: Pulse – hirshhorn museum and sculpture garden: Smithsonian. Hirshhorn Museum and Sculpture Garden | Smithsonian. (2020, October 2). Retrieved November 12, 2022, from https://hirshhorn.si.edu/exhibitions/rafael-lozano-hemmer-pulse/

Task #1: Test the NeoPixel

The task for this recitation was for us to use the Neopixels in order to visualize music. For task 1 I followed the schematic provided and wired it accordingly. The libraries were already installed from previous classes, so I skipped step 2. However, I ran into a problem, because Arduino IDE decided to open into an old code, and the library couldn’t be found. To solve this problem I closed IDE and restarted it. For step 3 I went into the FastLed library, and used the blinking example. Pictures of task 1 can be found below. 

 

Schematic connection: 

 

 

Blinking LED test:

 

 

 

Task #2: Use your computer to light up NeoPixels

For the 1st step of task 2, the serial record library was already installed from previous classes, the use of it is to allow communication between Arduino, and processing.  For step 2, I clicked the link that directed me into the GitHub page, and I copy pasted the code into IDE. The code allowed  to modify individual led strips so I put the following into the serial monitor ” 5, 255,0,0″ This made the 6th led light up red. This verified the code was running properly. For step 3, I copy pasted the code provided, and ran it in processing. The processing code allowed to turn the LEDs on when you slid the mouse across it. 

 

Fifth LED light up:

 

Arduino, and processing code:

 

Mouse sliding through: 

 

Task #3: Add Music!

 

The first thing I did for task 3 was to download the sketch for the amplitude analyzer. The following I did was to start combining the previous processing sketch, with the one I just downloaded. The final code can be found below. I asked Gottfried for help in modifying the code, and he suggested adding a second array that would track which LED’s have already been triggered, and turn them off. So you could visualize the music better.  I also multiplied the volume by  50, so the effect was more centered. The song I chose was “Thousand bad times” by Post Malone, but I needed to convert it into an MP3 file, and the websites that offered it seemed very sketchy. So Gottfried helped me by converting it for me. I added the file into the data folder, and ran the program. The video can be seen below. Overall, this was a very interesting recitation, and it provided some insight into my final project. 

 

Amplitude analyzer program:

 

Combining the 2 Sketches:

 

Final code:  

import processing.sound.*;
import processing.serial.*;
import osteele.processing.SerialRecord.*;

Serial serialPort;
SerialRecord serialRecord;
SoundFile sample;
Amplitude analysis;

int W;         //width of the tiles
int NUM = 60;  //amount of pixels
int[] r = new int[NUM]; //red of each tile
int[] g = new int[NUM]; //red of each tile
int[] b = new int[NUM]; //red of each tile
int lastN;


void setup() {
  size(640, 480);
  W = width/NUM;
  // load and play a sound file in a loop
  sample = new SoundFile(this, "thousand.mp3");
  sample.loop();

  // create the Amplitude analysis object
  analysis = new Amplitude(this);
  // analyze the playing sound file
  analysis.input(sample);


  String serialPortName = SerialUtils.findArduinoPort();
  serialPort = new Serial(this, serialPortName, 9600);
  serialRecord = new SerialRecord(this, serialPort, 4);
  serialRecord.logToCanvas(false);
  rectMode(CENTER);
}

void draw() {

  println(analysis.analyze());
  background(125, 255, 125);
  noStroke();
  fill(255, 0, 150);


  for (int i=0; i<NUM; i ++) {
    fill(r[i], g[i], b[i]);
    rect(i * W + W/2, height/2, 10, 10);
  }



  // analyze the audio for its volume level
  float volume = analysis.analyze();

  // volume is a number between 0.0 and 1.0
  // map the volume value to a useful scale
  float diameter = map(volume, 0, 1, 0, width);
  // draw a circle based on the microphone amplitude (volume)
  circle(width/2, height/2, diameter);


  // if (mousePressed == true) {
  int n = floor(constrain(volume*50, 0, NUM-1));

  r[n] = floor(random(255));
  g[n] = floor(random(255));
  b[n] = floor(random(255));

  serialRecord.values[0] = lastN;     // which pixel we change (0-59)
  serialRecord.values[1] = 0;  // how much red (0-255)
  serialRecord.values[2] = 0;  // how much green (0-255)
  serialRecord.values[3] = 0;  // how much blue (0-255)
  serialRecord.send();            // send it!

  serialRecord.values[0] = n;     // which pixel we change (0-59)
  serialRecord.values[1] = r[n];  // how much red (0-255)
  serialRecord.values[2] = g[n];  // how much green (0-255)
  serialRecord.values[3] = b[n];  // how much blue (0-255)
  serialRecord.send();            // send it!
  
  lastN = n;
  //  }
  
  
}

Final Video: