I worked on this project with Tim Haynes.

The goal of this project was to build a device that lets you know when your train stop is coming up.

Look!

It all started with the thought that when you’re coming home late, and you’re tired or drunk or both, you can sometimes miss your trainstop. Or if you’re reading a good book or watching a movie or even just having a nap. So, what if you had a device that could A) alert you that your stop was coming up and B) let you know that your stop was here.

How?

Enter… The Device
Right now it’s a simple box with very basic inputs and outputs.

• You turn on the Device. By default, its set to two train stops, because why would you need something like this for only one stop?
• You increment the number of stops by pushing a red on the side. This is also useful in the case of false stop detection.
• When you reach the stop before your stop, a yellow light goes on and stays on until…
• You near your stop where a red light comes on and a buzzer/vibrator goes off.

Do It Yourself

So the setup is pretty simple and the materials are cheap/easy to come by.

• Arduino (or some other microcontroller thingy)
• 2 LEDs
• 1 (or more) (we used a piezo) Buzzer/vibrating motor/loud-annoying-wake-me-up-thing
• 1 accelerometer
• 1 pushbutton switch
• 1 on/off type switch
• power supply for arduino (we used a 9v battery)
• breadboard, wires, wirecutter
• 2x 220 ohm resistors, 1x 10k ohm resistor
• A casing to hold the Device

Circuit Diagram

Code

int analogPin0 = 0;
int analogPin1 = 1;
int analogPin2 = 2;

int analogValue0 = 0;
int analogValue1 = 0;
int analogValue2 = 0;            // outgoing ADC value

int wasOn=-1;

int y = 0;

float distance, distanceo, totaldist, totaldisto;
float velocity, speedo, accel, accelo; 

int d1, d2, d3, d1o, d2o, d3o;
int count = 1;

float lowend, highend, lowendo, stayold, stayold2;
int highcount, lowcount, staycount, mystopcount, countdown;
int iteration, iterationo;

int switchPin = 7;      //  digital input pin for a switch
int yellowLedPin = 3;   //  digital output pin for an LED
int redLedPin = 6;      //  digital output pin for an LED
int buzzerPin = 8;      //  digital output pin for a buzzer
int switchState = 0;    //  the state of the switch
int stops = 2;          //  number of stops
int buzzerState = 0;    //  if buzzer is on

void setup()
{
  pinMode(switchPin, INPUT);       // set the switch pin to be an input
  pinMode(yellowLedPin, OUTPUT);   // set the yellow LED pin to be an output
  pinMode(redLedPin, OUTPUT);      // set the red LED pin to be an output
  pinMode(buzzerPin, OUTPUT);      // set the buzzer pin to be an output

  // start serial port at 9600 bps:
  Serial.begin(9600);
  lowend=highend=accel=velocity=distance=d1=d2=d3=staycount=mystopcount=0;
  iteration=0;
  lowendo=totaldisto=accelo=speedo=totaldist=distanceo=d1o=d2o=d3o=iterationo=0;
  highcount=lowcount=3;
  stayold=0; stayold2=1;
  countdown=3;
}

void loop()
{
  switchState = digitalRead(switchPin);

  analogValue0 = analogRead(analogPin0); 

  analogValue1 = analogRead(analogPin1); 

  analogValue2 = analogRead(analogPin2); 

 if (switchState == 1) {
    wasOn=1;
  }
  if(switchState == 0 && wasOn == 1)
  {
    stops = stops + 1;
    //Serial.println("HAI! I'm on!");
    wasOn=0;
  }

  /*
 Serial.print(analogValue0);
 Serial.print("*");
  Serial.print(analogValue1);
   Serial.print("*");
   Serial.println(analogValue2);
   */
  // pause for 10 milliseconds:
  delay(10);

	/*
	the data is collected every 10 ms, so a count of 100 is 1 second
	*/
        if(count==100)
        {
          iteration++;

          /*
            if 3 data points are high and close enough to each other then a
	    high-end point is recorded
          */
          if(totaldist-300 > lowend) // looking for a number above the lowest
                                     //data point (lowend)
          {
            if(highcount >=2) // on the 3rd occurence of a high point within
                              // 100 points of itself, see if its ok to say
 			      // its a high point
            {

              if(totaldisto+100 >= totaldist && totaldisto-100 <= totaldist)
              {  highend=totaldist; } else{ highcount=0;}
            } else { //else the count is restarted and the search for
                     // consecutive high data points continues
              if(totaldisto+100>=totaldist && totaldisto-100<=totaldist)
              {  highcount++; } else { highcount=0; }
            }
          }

          /* A cheap hack. Just puts the first data point lower than the first
	     high data point into the low end point. */
          if(highend>0 && lowend==0) {
            if(totaldist 0)
          {
            if(totaldist>lowend){highend=totaldist;}
          }

          /*
            if 3 data points in succession are low, then a  new low end point is
	    recorded
          */
          if(totaldist+300 < highend)// looking for a number below the high
				     //data point
          {
            if(lowcount >=2){ // on the 3rd occurence of a low data point w/in
                              // 100 points of itself, check to see if its ok
			      // to record
              if(totaldisto+100>=totaldist && totaldisto-100<=totaldist)
              { lowendo=lowend; lowend=totaldist; } else {lowcount=0;}
            } else {//else the count is restarted and the search for consecutive
                    // low points resumes
              if(totaldisto+100>=totaldist && totaldisto-100<=totaldist)
              {  lowcount++; } else { lowcount=0; }
            }
          }

          /*
          Serial.print("!");
          Serial.print("*");
          Serial.print(highend,DEC);
          Serial.print("*");
          Serial.print(lowend,DEC);
          Serial.print("*");
          Serial.println(totaldist,DEC);
          */

         /*if the last low end point is close enough to the current low end
        point, then start saying that maybe we're stopping or have stopped */
          if(lowendo+100>=lowend && lowendo-100<=lowend)
          {staycount++; stayold2=lowendo;}else{staycount=0;}
          /* if we've been at a low end for quite a while and its not the
          beginning of the program then check to see if we've been staying
             at the same place as well and if so then say that we think that
             we've stopped */
          if(staycount>=3 && highend!=0 && lowend!= 0 && stayold!=stayold2)
          {
            //Serial.println("@");
            stayold=lowendo;
            stayold2=stayold;
            staycount=0;
            if(mystopcount==-1)
            {
              //Serial.println("#");
              countdown--;
              stops--;
            }

	    /*
            stops--;
            Serial.print(iteration);
            Serial.print(" ");
            Serial.println(stops);
	    */
            if (stops == 1) {
              digitalWrite(yellowLedPin, HIGH);   // turn on the yellow LED
            }
            if (stops == 0) {
              digitalWrite(yellowLedPin, LOW);   // turn off the yellow LED
              digitalWrite(redLedPin, HIGH);     // turn on the red LED
              digitalWrite(buzzerPin, HIGH);     // turn on the buzzer
              buzzerState = 1;
              stops=0;
            }

            mystopcount++;
            iterationo=iteration;

          }

          //this is the number we need to play with to finesse things
          if(iterationo+8 < iteration){mystopcount=-1;}
          if(iterationo+3 < iteration){
          digitalWrite(buzzerPin, LOW); digitalWrite(redLedPin,LOW);
        }

          /* reset distances and times */
          totaldisto=totaldist;
          totaldist=0;
          count=1;

          speedo=velocity;
          accelo=accel;

        }

        /*below this line is all graph data */

        //X
        y = analogValue0;
        d1 =  y- d1o;
        d1o = y;

        //Y
        y = analogValue1;
        d2 = y - d2o;
        d2o = y;

        //Z
        y = analogValue2;
        d3 = y - d3o;
        d3o = y;

        //Distance
        if(d1o != 0 && d2o != 0 && d3o != 0)
        {
          distance = sqrt(sq(d1)+sq(d2)+sq(d3));
          distanceo= distance;
        }

        //Speed (averaged over time (every reading is 1 second)), reset @ STOPs
        totaldist+=distance;  //DONT'T DELETE THIS LINE OR EVERYTHING WILL DIE
        velocity = totaldist/count;

        //Accel
        accel = velocity/count;

        count++;  //OR THIS
}

Thoughts, Commnets, Concerns

So this project went along at pretty steady pace. We had a few hiccoughs in the beginning, trying to interpret the accelerometer data in order to extrapolate the speed and then figure out how to detect a "stop" from all of that mess.
Once we got that figured out, it was just a matter of actually riding the train trying to fine tune our settings. The most trouble we had (still have actually) was with detecting false stops. Where the train decelerates while underground or stops for some train delay or another.
We've thought about combining the accelerometer with an audio sensor or something but none of those ideas were really feasible in the amount of time we had. So right now the Device only works for the 4/6 train line and its sometimes a bit shaky at that.

1. We sample the speed each second.
2. We baseline the high and low speeds at the start of the program.
3. We determine new high and low speeds based on a simple algorithm. If there is a new high/low point that is steady (within 100 of each other), and 300 away from the current (high if low and low if high) point, for 3 seconds then a new high/low is set. Simple, right?
4. If there is a constant deceleration for 6~ish seconds, we say “Ok, we’ve detected a stop.”

This is all fairly accurate so far and the data reflects it except for a few false negatives that we hope to smooth out by changing the constant deceleration time from 6 seconds to 10ish. We’ll have to play around w/ that.
Right now we just have to actually build a case for our project, and maybe pretty up the input/output mechanisms. Right now we just have a switch that we push to raise the stop count and some lights/a buzzer that can go off.

purple — distance
teal — speed
black — acceleration
vertical blue – stops/starts

• ok, so a shadow thing that goes buh bum buh bum and changes to match your shape – built out of cloth – mini doll thing pic1
• passerby-shadows captured-fade down as time pass-worn out by footstep vibrations- blend softly smooth into each other-twist and morph-and then cease to exist. OR dancing shadow
  pic pic2
• minature house filled w/ booby traps pic
• watch that notifies you when your stop is coming up on the train pic
• device that switches your music if it senses you’re falling asleep pic
• a device to detect if you’re doing a motion (say martial arts form) correctly pic

Oh! And i finally was able to find the time to clean my apartment after two weeks. I went to Oscar’s bday party and hung out with friends here and there. It was good times really. Good times. Now the week isn’t quite over so i’m going to go and get as much more relaxing in as possible.

Cheers!

It’s been a long road. For the short version of this post, click here.

My groupmates for this project were: Jayoung Chung, “Neo” Sangzoon Park, and Ozge Kirimlioglu.

First, the results

How it all began

We started with an idea of an idea. Well really, it was more like an idea of an idea’s grandmother’s 3rd cousin, twice removed. By which I mean, we all had different ideas and aethetics that we wanted to push onto this project. Books, nature scenes, moons, clocks, the abstract or even “anything so long as it’s cool.” It took a week before we managed to narrow ourselves down into something all parties could agree upon.

We were going to gut a book, and create a system reminiscent of the free-writing exercises many prose writers practice.

The components

• 1 x Holy Bible
• 1 x Biographical Directory of the American Congress (1774-1971)
• 2 x Solenoids (push style)
• 20 x Assorted plastic dice.
• 1 x Arduino board
• Scissors, glue, saws, wires, force sensors… you know… all that good stuff.

Workflow

I’d like to start off by saying test, TEST, TEST!!!1. We tested and prototyped everything all through the build process and it saved us lots of time.

So we ordered our solenoids from McMaster-Carr’s, got our old books from Strand’s and got a bunch of cubes from Canal Plastics.

The first thing we did when we got our solenoid’s was … you guessed it! Tested em out. It would have sucked if the solenoid’s didn’t work. Luckily they did.



Next, we bought and cut all our book, which btw was the Holy Bible. We really liked the idea of using a bible for this. The only one who kind of got upset about it was the cleaning guy, but i’m not sure if he was joking or not.




More cutting was required to give the book a more aethetically pleasing shape and also, the solenoids had to be mounted for even more testing.

Meanwhile, the plastic cubes had to be etched and filled with paint, and there was soldeirng and wiring to be done. Nothing too fancy. They two solenoids required ~4A of current and ~12V of power. We *ahem* salvaged an old variable power supply and hooked it up to fix our needs.



One problem that came up was how to get the cubes to pop properly. The thing with a book is that it absorbs force quite well if there’s just a solid board going across it. So we came up with a prototype that involved springs, so that the board had some give. In the end though, we went with stretchy cloth. That way there were no gaps, plus then we could put a nice design of print on it.



More testing! We set up our device on some blocks and put a clear piece of plastic so we could observe.

Now, it was just time to assemble and fine tune. There were a couple minor things. Had to drill a hole in the larger american congress book we were using for a base to hold the solenoids. We didn’t have any drill bits that were the perfect size, so we had to retain the mounting board we used for the prototype above to hold them in place.
The base also had to be stained (with coffee grounds) to match the coloring of the top book. Gave it a nice “aged” look. Also, as you can see the cool-looking cubes were also a bit hard to read, so we decided to cover it up with tape and add snippets form the excess pages. It worked out pretty well, though I do wish we could have incorporated some of the words that god left behind. Like… “jabberwocky” or “sesquipedal”.



One last casualty, Jayoung’s Arduino board died due to a mistake of wiring.



Done at last, we spent the last little bit taking pictures of our finished product, documenting it all, and generally making merry (except not so much with the making merry).

Overall Impression

I enjoyed working on this project. Everyone brought something to the table.
Jayoung had a strong artistic flair, Neo rocks with electronics, Ozge has a good eye for details. We did take some time reach a consensus for what to do, but that’s to be expected when so many people with different skillsets mix. I look foward to working with them all again (and I’m not just saying that to be nice =p ).

Here’s the processing code:

import processing.serial.*;

Serial myPort;
int xpos, ypos;

int pingX=0,pingY=0;

/*
  this will be a psuedo matrix to hold
  all generated points. the main index of
  bob will represent x, while the arraylist
  of that index will hold all the y points
  along that x line that are lit up.
 */
ArrayList[] bob;

//the pinging you-are-here circle
subPoint p = new subPoint();

void setup () {
  myPort = new Serial(this, "COM4", 9600);
  myPort.bufferUntil('\n');

  size(512, 512);
  xpos=ypos=0;

  bob = new ArrayList[513];
  for(int i=0;i<513;i++)
  {
    bob[i]=new ArrayList();
  }
}

void serialEvent (Serial myPort) {
  String data = myPort.readStringUntil('\n');
  if(data!=null)
  {
    println(data);
    data = trim(data);
    int inputs[] = int(split(data,'-'));

    if(inputs.length > 1)
    {
      xpos=inputs[0];
      ypos=512-inputs[1];

      if(!bob[xpos].contains(ypos)){ bob[xpos].add(ypos);}

      pingX++;
      pingY++;
      if(pingX>45){pingX=pingY=0;}

      if(inputs[2]==1){ clear(); }
    }
  }
}

void clear()
{
  for(int i=0;i<513;i++)
  {
    bob[i].clear();
  }
}

void draw () {
  background(255);
  stroke(0,255,0);

  for(int i=0;i<513;i++)
  {
    if(!bob[i].isEmpty())
    {
      for(int j=0;j < bob[i].size();j++)
      {
        String s = bob[i].get(j).toString();
        point(i,int(s));
      }
    }
  }
  p.update(xpos,ypos);
}

class subPoint {

  void update(float x, float y)
  {
    stroke(255,0,0);
    noFill();
    ellipse(x+1,y+1,pingX/3,pingY/3);
  }
}

The arduino code is relatively simple:

int aPin1 = 0;
int aPin2 = 1;
int aVal = 0;
int dPin = 2;

void setup()
{
  Serial.begin(9600);
  pinMode(dPin,INPUT);
}

void loop()
{
  aVal = analogRead(aPin1);
  aVal = map(aVal,0,1024,0,512);
  Serial.print(aVal,DEC);
  Serial.print('-');
  aVal = analogRead(aPin2);
  aVal = map(aVal,0,1024,0,512);
  Serial.print(aVal, DEC);
  Serial.print('-');
  aVal = digitalRead(dPin);
  Serial.println(aVal, DEC);
  // pause for 10 milliseconds:
  delay(10);
}

• Hat Angle: As a man, you should wear your hat at a rakish angle. However, finding the right angle for you can take quite alot of mirror work. And once you find it, if you take off the hat, you have to find it again the next time. So, make a device that remembers the position at which you last wore your hat, allowing you to make only minute adjustments the next time.
• Sk8ter Love: So yea, I bought a skateboard a few months ago, but this-and-that happened and I havnt been able to ride it more than 4 times. But! From what I’ve noticed while teaching myself to ride, I have a tendency to get .. not scared, but unnerved while going down steep hills really fast (or at least really fast to me). It would be nice to have some sort of feedback device letting me know ~how fast I’m going or that I’m still on balance. Give me some artificial confidence … or let me know that if i don’t hop off soon I may die. Also.. can someone teach me the proper way to stop on a skateboard?
• Auto Airbag: This would be a personal airbag, you could strap onto your body. It detects when you’re moving faster than a certain speed, say… 9.8 m/s and when a collision w/ something is immenent it deploys an airbag in that direction. So you could possibly just throw yourself at the ground… at the walls… at people all day long and never suffer any damage.
• Exersize Buddy: Mmm, I’ve not really worked out at all since I started the moving process a few months ago. And trying to fit in gym time while living in BK and school in Manhattan hasn’t really been working out. Usually I get to ITP with only 15 minutes to spare and by the time I’m finished my work on the floor I just wanna go eat/sleep/die. But the real problem lies at home. I absolutely hate working out just by itself. If i’m at the gym then I’ll get in a solid hour because I don’t want to end up looking like a punk. But at home, it’s just me… and I lack motivation. So! Introducing the Exercize Buddy. You put a number in the system and have to touch two things togehter 100 times. It turns into a game. Touch them together by doing pushups, jumping jacks, situps. Oh yea, and it yells encouragement at you, Ahnold Shwartz style. “Ya… do eet. Pump dat iron!”, and such.

Here’s the video.



I started toying around with the servo, but I really wanted to play with the piezo. I wanted to create a different sound based on the user’s input. I had a force sensor, so I jury rigged some code up to do interesting stuff. At first there was a problem when I tried to upgrade the arduino program and found that it was broken. Oh well. Back down to version 0011.


So, what i was trying to do is let a user make a 3-note song. But this sound stuff is harder than it seems. I kept having trouble getting the delay right for to seperate the notes, so really what you’re hearing in the video is 3 notes being played very fast, but it sounds like one sound. Still, it’s generally what I was aiming for. I need to figure out the delays more. But not now. Later.


And here’s the code:

int speakerOut = 9;  // Set up speaker on a PWM pin (digital 9, 10 or 11)
int analogValue = 0;  // the value returned from the analog sensor
int analogPin = 0;    // the analog pin that the sensor's on

void setup() {
  pinMode(speakerOut, OUTPUT);
  Serial.begin(9600);
}

int notes[] = { 261, 261, 261 };
int times[] = { 1, 1, 1 };
int i=0;
int j=0;
int state=0;
unsigned long time=0;

void loop() {
  if(j>3){j=0;}
  if(j==0)
  {
    Serial.println("Hi! Enter first note.");
    getNote(j);
    Serial.println(notes[j]);
    Serial.println(times[j]);
    Serial.println("Ok! Processing the note.");
    delay(2000);

    Serial.print("enddelay");
  }else if(j==1)
  {
    getNote(j);
    Serial.println("Hi! Enter second note.");
    Serial.println(notes[j]);
    Serial.println(times[j]);
    Serial.println("Ok! Processing the note.");
    delay(2000);
  }else if(j==2)
  {
    getNote(j);
    Serial.println("Hi! Enter 3rd note.");
    Serial.println(notes[j]);
    Serial.println(times[j]);
    Serial.println("Ok! Processing the note.");
    delay(2000);
  }else if(j==3)
  {
    Serial.println("Who's awesome? You're awesome!");
    Serial.println("Ok, listen to your tune and whenever
           you're ready to stop, just press the button.");
    playIt();
    Serial.println("Back!");
    delay(2000);
  }
  j++;
}

//gets the user input note and how long it took them to input it
void getNote(int i)
{
  time=millis();
  int analogValueOld=0;
  while(1)
  {

    analogValue = analogRead(analogPin);
    if(analogValue > 4)
    {
      while(analogValue > 4)
      {
        analogValue = analogRead(analogPin);
        if(analogValueOld < analogValue) {analogValueOld=analogValue;}
      }

      notes[i]=map(analogValueOld,0,870,3830,1912);
      times[i]=abs(millis()-time);
      return;
    }
  }
}

//play the tune till user stops it
void playIt()
{
  while(1)
  {
    //Serial.println(analogValue);
    analogValue = analogRead(analogPin);
    while(analogValue < 50)
    {
      if(analogValue >=50)
      {
        digitalWrite(speakerOut,LOW);
        return; // in theory, this should return out of the function
                  //but it's acting like a break
      }
      for(int i=0;i<3;i++)
      {
        for(int j=times[i]*1000;j>0;j-=(notes[i]/2))
        {
           digitalWrite(speakerOut,HIGH);
           delayMicroseconds(notes[i]/ 2);
           digitalWrite(speakerOut,LOW);
           delayMicroseconds(notes[i]/ 2);
        }
        delayMicroseconds(times[1]*times[2]*times[3]*150);
      }
      analogValue = analogRead(analogPin);
    }
    return; // so that's why i had to use two return statements
  }
}