Project 2

We were once again supposed to create a theoretical art piece and build a mock-up of it with our Arduinos.
We were supposed to use 2 sensor inputs and 2 LED outputs and Serial communication.

I wanted to use Processing this time around (Since Processing communicates with the Arduino via Serial I am counting this as my use of Serial communication.). For this project, I found myself very inspired by the following computer generated art pieces. I love the sense of chaos and yet rhythm that they have.

At the same time I thought about how I never seem to make enough time to explore my creative ideas. I am usually too wrapped up in the things that I have to do for school or work to spend much time on the grandiose ideas of my mind. So I have started daily challenging myself with this question (and I encourage you to do the same): "What have you created today?"

So I decided to make a system that would take the natural rhythm of  daily activity and express it in a generative art piece so that at the end of the day you could have automatically created a piece of art for the day. It uses an accelerometer to track your motion(maybe you would wear it on your foot or just your shirt) and a pressure sensor (maybe to detect touch or steps). My Processing program uses the accelerometer data as an (x,y) coordinate to determine where on the screen it should draw and the pressure sensor data changes the color

(Code and Video will be in next blog post)

Rock, Paper, Scissors

We had an assignment to make a rock, paper, scissors game with the RGB LED.
R beats G
G beats B
B beats R

We were to use Serial communication to play with another person in class
I played with Laura so that we could test the entire communication protocol.
I had one bug that gave me a lot of problems which was that I was not delaying long
enough when trying to receive more than one character in a row as in "GGG"
I was not giving the buffer long enough to actually receive all of the data

Here is a schematic of my arduino board for this project (These are the exact pin #'s used)

And here is my code. I used a header file to organize my code and so that I could use enumerations which seem to have a slight problem in Arduino:

//functions.h


#include "Arduino.h"

HardwareSerial& s = Serial1;

const byte R_rock = 10;
const byte G_paper = 8;
const byte B_scissors = 9;

const byte R_stat = 7;
const byte G_stat = 6;
const byte B_stat = 5;

const byte pot_pin = A8;
int pot_val = 0;

const byte switch_pin = 2;
int prev_switch_val = 0;
int switch_val = 0;

int R_val = 0;
int G_val = 0;
int B_val = 0;

int R_stat_val = 0;
int G_stat_val = 0;
int B_stat_val = 0;

int state = 0;
enum Color{ RED, GREEN, BLUE };

Color my_choice  = RED;
Color opponent_choice = RED;


void set_rps_color()
{
  pot_val = analogRead(pot_pin);    // read the potentiometer to determine color choice
 
  if(pot_val < 413)
  {
    R_val = 255;
    G_val = 0;
    B_val = 0;
  }
  else if(pot_val < 827)
  {
    R_val = 0;
    G_val = 255;
    B_val = 0;
  }
  else
  {
    R_val = 0;
    G_val = 0;
    B_val = 255;
 
  }
}

//be careful with this...not listening to this all the time...
boolean switch_pressed()
{
  prev_switch_val = switch_val;
  switch_val = digitalRead(switch_pin);
  //Serial.print(prev_switch_val);Serial.print(" ");
  //Serial.println(switch_val);
  if(prev_switch_val==0 && switch_val==1)
  {
    return true;
  }
  return false;
}

int determine_winner(enum Color me,enum Color opponent)
{
  int test = (3+((int)me-(int)opponent))%3;
  if(test == 2)
  {
    //I win
    R_stat_val = 0;
    G_stat_val = 255;
    B_stat_val = 0;
  }
  else if(test == 1)
  {
    //They win
    R_stat_val = 255;
    G_stat_val = 0;
    B_stat_val = 0;
  }
  else if(test == 0)
  {
    //tie
    R_stat_val = 175;
    G_stat_val = 255;
    B_stat_val = 0;
  }
  return test;
}

int get_opponent()
{
  //need to read 3 times and construct a string?
  if(s.available() > 0)
  {
     char incomingByte = s.read();
   
    if(incomingByte == 'R') opponent_choice = RED;
    else if(incomingByte == 'G') opponent_choice = GREEN;
    else if(incomingByte == 'B') opponent_choice = BLUE;
    else return -1;
  }
  else
  {
    return -1;
  }
 
  return int(opponent_choice);
}

int send_choice()
{
  if(R_val == 255) {s.write("R"); my_choice = RED; return 0;}
  else if(G_val == 255) {s.write("G"); my_choice = GREEN; return 1;}
  else if(B_val == 255) {s.write("B"); my_choice = BLUE; return 2;}
  else return -1;
}

void set_stat_color(int R, int G, int B)
{
  R_stat_val = R;
  G_stat_val = G;
  B_stat_val = B;
}

//
// i is 1 for the first reset  => send ZZZ
// i is 2 for the second reset => send XXX
//
int send_reset(int i)
{
  if(i==1) {s.write("ZZZ"); }
  else if(i==2) {s.write("XXX");}
  else return -1;
}

//
// i is 1 for the first reset  => listening for ZZZ
// i is 2 for the second reset => listening for XXX
//
bool listen_for_reset(int i)
{
  String inData = "   ";
  int index = 0;
  char inChar;
 
  if(i==1)
  {
    //Serial.println("Wont work without this print for some weird crazy reason");
    while(s.available() > 0)
    {
      //Serial.println("Serial data available");
       inChar = s.read();
       if(index < 3)
       {
         inData[index]=inChar;
         index++;  
       }
       delay(10);
    }
   
    //inData.trim();
    if(inData == "ZZZ" || inData == "zzz")
    {
      return true;
    }
  }
  else if(i==2)
  {
       //Serial.println("Wont work without this print for some weird crazy reason");
    while(s.available() > 0)
    {
       inChar = s.read();
       if(index < 3)
       {
         inData[index]=inChar;
         index++;  
       }
       delay(10);
    }
   
    //inData.trim();
    if(inData == "XXX" || inData == "xxx")
    {
      return true;
    }  
  }
  return false;
}

//main file


#include "functions.h"

// the setup routine runs once when you press reset:
void setup() {              
  // initialize the digital pin as an output.
  pinMode(R_rock, OUTPUT);
  pinMode(G_paper, OUTPUT);
  pinMode(B_scissors, OUTPUT);

  pinMode(R_stat, OUTPUT);
  pinMode(G_stat, OUTPUT);
  pinMode(B_stat, OUTPUT);

  pinMode(pot_pin, INPUT);
  pinMode(switch_pin, INPUT);

 s.begin(9600);
 Serial.begin(9600);
}

// the loop routine runs over and over again forever:
void loop() {
 
  switch (state){
    case 0:
            //Waiting for someone to press "reset"
            if(switch_pressed())
            {
               send_reset(1); //send the first reset signal
               set_stat_color(0,0,255); //set status to blue
               state ++; //advance state to wait for opponent
               break;
            }
            else if(listen_for_reset(1))
            { //opponent pressed reset
              set_stat_color(0,0,255); //set status color to blue
              state+=2; //advance state to wait for me to press reset
              break;
            }
            break;
    case 1:
            //waiting for opponent to press reset
            if(listen_for_reset(1))
            {
              set_stat_color(155,0,255);//set status color to magenta
              state+=2;//advance state to choose color
              break;
            }
            break;
    case 2:
            //waiting for me to press reset
            if(switch_pressed())
            {
              send_reset(1);//send the first reset signal
              set_stat_color(155,0,255);
              state++; //advance state to choose color
              break;
            }
            break;      
    case 3:
            //Allow our player to select color
            set_rps_color(); //can change color as much as we want
            if(switch_pressed()) //when done press switch
            {
              send_choice();
              set_stat_color(155,255,255);//set stat color to signify I have chosen
              state++;//advance state to wait on opponent
              break;
            }
            if(get_opponent()>=0)//also listen for opponent choice
            {
              set_stat_color(0,255,255);//set stat color to signal opp chose and is waiting on me
              state+=2;//advance state for opp to wait on me
              break;
            }
            break;
     case 4:
            //Serial.println("In case 4");
            //Wait for other player to select color
            if(get_opponent()>=0)
            {
              set_stat_color(0,255,255); //set stat color
              state+=2; //advance state to determine winner
            }
            break;
      case 5:
            //Opponent is waiting on me to choose
            set_rps_color(); //can change color as much as we want
            if(switch_pressed())
            {
              send_choice();
              set_stat_color(155,255,255);//set stat color to signify I have chosen
              state++; //advance state to determine winner
            }
            break;
      case 6:
            //determine winner
            determine_winner(my_choice,opponent_choice); //This sets the stat light color
            state++; //advance state to wait for reset
            break;
      case 7:
            //Either opponent or I must press reset to start over
            if( switch_pressed() || listen_for_reset(2))
            {
              send_reset(2); //send the second reset
             
              //Clean up
              R_stat_val = 0;
              G_stat_val = 0;
              B_stat_val = 0;
           
              R_val = 0;
              G_val = 0;
              B_val = 0;
         
              //Start back at case 0
              state = 0;
          }
  }
           
   analogWrite(R_rock,R_val);
   analogWrite(G_paper,G_val);
   analogWrite(B_scissors,B_val);
 
   analogWrite(R_stat,R_stat_val);
   analogWrite(G_stat,G_stat_val);
   analogWrite(B_stat,B_stat_val);

}

Project 1

Here is what I presented in class for Project 1:

I am quite fascinated by time. I love that there are so many different perspectives on time. It is mysterious and can be the center of so many different trains of thought. A physicist might study the rules of time and how it works, whereas a physchologist will ask, "How do humans view time? How does it affect our actions?" and a philosopher will ponder interesting puzzles such as "Does time exist if nothing is changing?"

So I made a timer with my Arduino for this assignment.

 The question then is what should I do with this timer and I came up with the following theoretical art piece. The piece that I propose was inspired by this robot that I found a video of online. He was built with full spacial awareness, but as soon as he begins to go out and explore his environment he unplugs himself. He is just a robot, he does not have feelings or care, but still I feel sorry for him. I love the irony of this idea of frustrating a machine. A machine cannot feel frustration or anything else but the viewer tends to feel the emotion for the machine anyway.

A brief explanation of my proposed art piece. I am furthermore, very intrigued ad inspired by the additional irony of the idea of a useless superpower. The idea that one could possess or be granted an ability that is special, unique, or defies physics or normal human capability, but can achieve nothing with it.

For the more practically minded, you could use the timer I created in a number of ways, but thought of its potential use in pilates class to help me monitor my breathing and keep a steady slow pace, both of which are very important to doing pilates correctly.

Here is a schematic for my circuit board (These are the exact pin numbers that I used)

And here is my code from the project:



int Switch = 2;
int Pot = 5;
int R = 10;
int G = 8;
int B = 9;
int pot_val = 0;
int switch_val = 0;
int prev_switch_val = 0;
boolean go = 1;
boolean blink = 1;

double total_time = 100000.0;
double time_left = total_time;

// the setup routine runs once when you press reset:
void setup() {              
  // initialize the digital pin as an output.
  pinMode(Pot, INPUT);
  pinMode(Switch, INPUT);
  pinMode(R, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(B, OUTPUT);

 Serial.begin(9600);
}

/*
**This function will wait the specified amount of time (relative, not in any specific metric)
**but still listens for the button press.
**Returns true immediately if button is pressed
**Otherwise returns false
*/
boolean wait(int time_out)
{
  while(time_out>0)
  {
    time_out--;
   
    prev_switch_val = switch_val;
    switch_val = digitalRead(Switch);
    if(switch_val==1 && prev_switch_val==0)
    {
      //time paused
      go = !go;
      return true;
    }
   
    //delay(1);
    delayMicroseconds(100);
  }
  return false;
}

void loop() {
  //Check and see if out time is up
  if(time_left <= 0)
  {
    Serial.println("Time's Up!");
    //Start things over (This would start the video over too)
    time_left = total_time;
    delay(1000);
  }
 
  //this part is basically waiting for a button press to unpause
  prev_switch_val = switch_val;
  switch_val = digitalRead(Switch);
  if(switch_val==1 && prev_switch_val==0)
  {
    //button was pressed, so we want to pause time
    go = !go; //boolean to pause the "time" and unpause on next press
  }
 
  //change the color of the light as time "runs out"
  //blinking according to the speed of "time"
  //but we make sure that the light is on when paused
  if(go)
  {
    pot_val = analogRead(Pot);    // read the pull down and print the value
    //This will control the speed of the blinking of the light
    //and the light should change from green to red faster
 
    //As long as this is not paused count down time
    //larger pot # = slower blink = slower time = less time elapsed
    double time_elapsed = map(pot_val,0,1023, 1000,100);
    time_left = time_left - time_elapsed;
 
    //light should be on
    if(blink){
        //change the color of the light slowly
       double c = (time_left) * (1 - .45) / (total_time)+.45;
       //red light overpowers at about c=.4 or .3 so altering this
       analogWrite(G,(c)*255);
       analogWrite(R,(1-c)*255);
       analogWrite(B,0);
     
       //wait the appropriate amount of time
       double wait_time = map(pot_val,0,1023,2000,5000);
       Serial.print(time_left);Serial.print(" ");
       Serial.print(wait_time);Serial.print(" ");
       Serial.println(c);
       wait(wait_time);
     
       //flip the blink boolean off
       blink = !blink;
    }
    else
    {
      //light is off
       analogWrite(G,0);
       analogWrite(R,0);
       analogWrite(B,0);
       //wait for proper duration
       double wait_time = map(pot_val,0,1023,2000,5000);
       wait(wait_time);
       //flip the blink boolean back on
       blink = !blink;
    }
  }
 else
  {
    //time is paused
    //make sure the light is on but doesnt blink or change color
    double c = (time_left) * (1 - .45) / (total_time)+.45;
    analogWrite(G,(c)*255);
    analogWrite(R,(1-c)*255);
    analogWrite(B,0);
   
    Serial.println("Paused");
  }
}

Theoretical Project

We are to create a theoretical project using the input and output devices that we have learned about so far which include LEDs, switches, and potentiometers. Last time in class I successfully created a color wheel using the potentiometer and a 3 pin RGB LED. As you turn the wheel, the resistance in the potentiometer changes and the color changes from red to yellow to green to blue-green to blue to purple and back to red. I though I would try to incorporate this exciting achievement into this project, but here is what I came up with:

I thought of creating an art piece that makes a statement on the modern commodity of time.
The idea is that there would be a self-generating art piece. For now I was thinking of this as a simple video of  a drawing or painting being created. The catch is that there is also a timer attached to this piece that counts down the time remaining, and the previously mentioned art piece never has time to finish itself. When the timer runs out, the canvas is swept blank and the piece has to start itself over (video stops short of a complete piece and repeats). No matter how long a viewer were to observe this piece, he or she would never know what the finished piece was supposed to look like. The viewer can interact with the piece by turning a dial (aka the potentiometer) to speed time up or slow time down and can even press a button to pause time all together. But these interactions are of no avail since as time speeds up, the drawing speeds up, but by relativity the art piece still only makes it to same stage of completeness as before. Similarly when time is paused, the art piece must also stop drawing. The timer is just an LED that blinks according to the speed of time set by the potentiometer dial. This LED changes from green through yellow to red as time runs out. The light is fully red when time is out and the piece must begin again.

Originally, I was trying to think of a piece that could instill a false sense of urgency in the viewer since I believe this often happens to people in life especially when involved in modern corporate America. We are all in a hurry, but what is that hurry really for other than burning away the time that we do have with stress and worry. Though related, this piece has really become a comment on my personality and the number of times that I start something that I don't finish. Too many interests, too little time. Yet for all our wishing to slow time down, we still could  not control our ability to finish something anyway.