//----------------------------
// Forget-Me-Not
//
// by Elie Zananiri & HyeJin Yoo
// based on code from Making Things Talk by Tom Igoe
 
//----------------------------
#define SOUND1    4
#define SOUND2    5
#define SOUND3    6
 
#define MONITOR   13
 
#define THRESHOLD 79
#define MSGLENGTH 22
#define INTERVAL  30000
 
//----------------------------
int packet[MSGLENGTH];
int byteCounter;
 
long lastPlayedSound1 = 0;
long lastPlayedSound2 = 0;
long lastPlayedSound3 = 0;
 
int address = 0;
int rssi = 0;
 
//----------------------------
void setup() {
  // open the serial port
  Serial.begin(9600);
 
  // configure output pins
  pinMode(SOUND1, OUTPUT);
  pinMode(SOUND2, OUTPUT);
  pinMode(SOUND3, OUTPUT);
}
 
//----------------------------
void loop() {
  // check for any messages and read up to 2 packets at a time
  int readCount = 0;
  while (Serial.available() > 0 && readCount < (MSGLENGTH*2)) {
    handleIncoming();
    readCount++;
    delay(5);
  }
 
  // flash the monitor pin to let us know all is working
  digitalWrite(MONITOR, HIGH);
  delay(50);
  digitalWrite(MONITOR, LOW);
  delay(50);
}
 
//----------------------------
void handleIncoming() {
  // read a byte from the port
  int b = Serial.read();
  // if this is a start byte, it's a new packet
  if (b == 0x7E) {
    // if there is data, parse the previous packet
    if (packet[2] > 0) {
      parseData();
    }
 
    // reset the byte counter
    byteCounter = 0;
  }
 
  // store the current byte into the packet
  packet[byteCounter] = b;
  byteCounter++;
}
 
//----------------------------
void parseData() {
  // read the address, which is a two-byte value
  address = packet[5] + packet[4]*256;
 
  // read the signal strength
  rssi = packet[6];
 
  // get the time
  long now = millis();
 
  // trigger a sound if the signal is not strong enough
  // and the sound has not played in a while
  if (address == 0x1ABC && rssi > THRESHOLD) {
    if (now - lastPlayedSound1 > INTERVAL) {
      lastPlayedSound1 = now;
      playSound(SOUND1);
    }
  }
  else if (address == 0x1CBA && rssi > THRESHOLD) {
    if (now - lastPlayedSound2 > INTERVAL) {
      lastPlayedSound2 = now;
      playSound(SOUND2);
    }
  }
  else if (address == 0x1BBB && rssi > THRESHOLD) {
   if (now - lastPlayedSound3 > INTERVAL) {
     lastPlayedSound3 = now;
     playSound(SOUND3);
   }
  }
}
 
//----------------------------
void playSound(int sound) {
  digitalWrite(sound, HIGH);
  delay(100);
  digitalWrite(sound, LOW);
  delay(6*1000);  // enough time to play the entire sample
 
  // flush the serial buffer to ignore all backed up messages
  Serial.flush();
}

import processing.serial.*;
import ddf.minim.*;
 
AudioPlayer samples[] = new AudioPlayer[6];
int val[] = new int[6];
int currVal = 0;
int barWidth = 150;
 
Serial port;
 
void setup() {
  size(900, 256);
  smooth();
  stroke(0);
  fill(#A72F2F);
 
  port = new Serial(this, Serial.list()[0], 9600);
  port.bufferUntil(’\n’);
 
  // start sound engine
  Minim.start(this);
 
  // load samples
  for (int i=0; i < 6; i++) {
    samples[i] = Minim.loadFile(”sample” + (i+1) + “.wav”);
  }
}
 
void draw() {
  background(255);
  for (int i=0; i < 6; i++) {
    rect(i*barWidth, 0, barWidth, val[i]);
    if (val[i] > 50) {
      samples[i].setVolume(val[i] / 255);
      samples[i].play(0);
    }
  }
}
 
void serialEvent(Serial port) {
  String inputString = port.readStringUntil(’\n’);
  if (inputString != null) {
    inputString = trim(inputString);
    //println(inputString);
    int[] values = int(split(inputString, “,”));
 
    // make sure we have the right data before assigning values
    if (values.length == 6) {
      for (int i=0; i < 6; i++) {
        val[i] = values[i];
      }
    }
  }
}
 
void stop() {
  for (int i=0; i < 6; i++) {
    samples[i].close();
  }
  Minim.stop();
  super.stop();
}

//-------------------------------
// Etch-a-sketch 2000
// by Elie Zananiri
// http://www.silentlycrashing.net
 
//-------------------------------
int shakeSwitchPin = 2;
int xPotPin = 0;
int yPotPin = 1;
 
//-------------------------------
void setup() {
  Serial.begin(9600);
}
 
//-------------------------------
void loop() {
  int s = digitalRead(shakeSwitchPin);
  int x = analogRead(xPotPin);
  int y = analogRead(yPotPin);
 
  Serial.print(x, DEC);
  Serial.print(",");
  Serial.print(y, DEC);
  Serial.print(",");
  Serial.println(s, DEC);
 
  delay(25);
}

import processing.serial.*;
 
//-------------------------------
// Etch-a-sketch 2000
// by Elie Zananiri
// http://www.silentlycrashing.net
 
//----------------------------
Serial port;
 
int margin = 70;
int radius = 20;
int threshold = 3;
boolean firstRun = true;
 
float currX = 0;
float currY = 0;
float lastX = 0;
float lastY = 0;
float potX = 0;
float potY = 0;
boolean drawIt = false;
 
int currShake = 0;
int lastShake = 0;
boolean shakeIt = false;
 
//----------------------------
void setup() {
  size(800, 600);
  smooth();
 
  // draw the background
  background(#af100c);
  strokeWeight(10);
  stroke(#5A0403);
  fill(#d5d5d5);
  erase();
  noStroke();
  strokeWeight(1);
  erase();
 
  // open and set up the serial port
  port = new Serial(this, Serial.list()[2], 9600);  
  port.bufferUntil('\n');
}
 
//----------------------------
void draw() {
  if (shakeIt) {
    noStroke();
    fill(#d5d5d5, 20);
    erase();
    shakeIt = false;
 
  } else if (drawIt) {
    stroke(#141414);
    noFill();
    line(lastX, lastY, currX, currY);
    drawIt = false;
  }
}
 
//----------------------------
void serialEvent(Serial p) {
  String inputString = p.readStringUntil('\n');
  if (inputString != null) {
    // get the input values
    inputString = trim(inputString);
    int[] values = int(split(inputString, ","));
 
    // make sure we have the right data before assigning values
    if (values.length == 3) {
      // get the new coords
      potX = map(values[0], 0, 1023, margin, width - margin);
      potY = map(values[1], 0, 1023, height - margin, margin);
 
      // make sure the new values are a big enough change
      if (abs(potX - currX) > threshold || abs(potY - currY) > threshold) {
        // store the previous coords
        if (firstRun) {
          lastX = potX;
          lastY = potY;
          firstRun = false;
 
        } else {
          lastX = currX;
          lastY = currY;
        }
 
        // store the current coords
        currX = potX;
        currY = potY; 
 
        drawIt = true;
      }
 
      // get the shake status
      currShake = values[2];
      // if it's different...
      if (currShake == 1 && currShake != lastShake) {
        shakeIt = true;
      }
      // store the previous shake status
      lastShake = currShake;
    }
  }
}
 
//----------------------------
void erase() {
  // draw a rounded rectangle
  rect(margin + radius, margin, width - margin*2 - radius*2, height - margin*2);
  rect(margin, margin + radius, width - margin*2, height - margin*2 - radius*2);
  ellipse(margin + radius, margin + radius, radius*2, radius*2);
  ellipse(margin + radius, height - margin - radius, radius*2, radius*2);
  ellipse(width - margin - radius, height - margin - radius, radius*2, radius*2);
  ellipse(width - margin - radius, margin + radius, radius*2, radius*2);
}

import processing.serial.*;
 
/**
 * Sensor sketcher
 * by Elie Zananiri
 * ITP Physical Computing, 04/10/2008
 *
 * SPACE captures an image
 * 's' toggles scaling
 */
 
//-------------------------------
// variables
Serial port;
PFont monaco;
 
int arraySize = 200;
int data[] = new int[arraySize];
int margin = 30;
float barWidth;
 
int minVal = 1024;
int maxVal = 0;
boolean scaled = false;
 
//-------------------------------
void setup() {
  size(800, 256);
  smooth();
  frameRate(60);
 
  monaco = loadFont("Monaco-12.vlw");
  textFont(monaco, 12);
 
  stroke(0);
  fill(255, 0, 0);
 
  barWidth = (width - margin) / float(arraySize);
 
  // reset the data
  for (int i=0; i < arraySize; i++) {
    data[i] = 0;
  }
 
  port = new Serial(this, Serial.list()[2], 9600);
}
 
//-------------------------------
void draw() {
  background(0);
 
  // draw the bounds
  textAlign(LEFT, TOP);
  if (scaled) {
    text(maxVal, 0, 0);
  } else {
    text("1024", 0, 0);
  }
  textAlign(LEFT, BOTTOM);
  if (scaled) {
    text(minVal, 0, height);
  } else {
    text("0", 0, height);
  }
 
  // draw all the data
  for (int i=0; i < arraySize; i++) {
    float barHeight;
    if (scaled) {
      barHeight = height * ((data[i] - minVal) / float(maxVal - minVal));
    } else {
      barHeight = data[i] * (height/1024.0f);
    }
    rect(i*barWidth + margin, height - barHeight, barWidth, barHeight);
  }
}
 
//-------------------------------
void serialEvent (Serial port) {
  // move all the data back to make space for the new one
  for (int i=1; i < arraySize; i++) {
    data[i-1] = data[i];
  }
 
  // get the byte
  int in = port.read();
  data[arraySize-1] = in;
 
  // adjust the bounds
  if (in < minVal) {
    minVal = in;
  }
  if (in > maxVal) {
    maxVal = in;
  }
}
 
//-------------------------------
void keyPressed() {
  if (key == ' ') {
    saveFrame("graph-" + nf(frameCount, 4) + ".jpg");
 
  } else if (key == 's') {
    scaled = !scaled;
  }
}