I intend on updating it again, but this is what I could get done in a back alley of La Paz with one battery to burn .

Link

A separate mechanical device, a power window motor was modified through sheet metal work and welding. This was used to hang a tree upon and thereby spin it. This is seen in action in a short clip of the Robotic Branch Video below during Rossum’s recent Uncanny Valley robotic art show at the Brewhouse.

Description: The final product is an array of 256 LEDs which could be used to display a multitude of information. It is also able to control, in a limited way, an iPod or other audio device. The design uses a clock module, temperature sensor, LED controllers, and a stereo volume control to provide the time, temperature, and audio entertainment which the user desires. Through the iPod, it is also possible to use it as an alarm clock.
Unfortunately I was not able to get everything fully functional at the same time, however individually everything worked.

Diagram of the Arduino-connected components

Materials Used:
Temperature sensor (thermistor)
DS1307 clock module (sparkfun breakout)
4 LED matrices
4 LED controllers (max7219)
1 Arduino
Power source (6A @ 5V)
2 grid style PCBs
1 double audio taper potentiometer (volume control)
2 audio jacks
1 power jack
connectors and wire
5 lbs solder

Case:
Masonite
Plexi
asst hardware

due to my mixed up wiring, i had to modify tomeks ledcontroller lib a little.
here are some code excerpts for showing temperature with two of the matrices connected.
note that this only lets you write 1 led/column, basically to do more than 1 you have to keep a buffer and add to it, then update each row later. this is what the LEDMatrix lib included with the arduino distro does.
anyway, the code below makes a little mountain which is taller the warmer the temperature

void loop () {
  int temp = analogRead(tpin);

  //what you write goes here mat(row,col); maxx is literal, mat translates

  if (temp  0){
    kh(1);
  }
  if (temp  294){
    kh(2);
  }
  if (temp  339){
    kh(3);
  }
  if (temp  384){
    kh(4);
  }
  if (temp  429){
    kh(5);
  }
  if (temp  474){
    kh(6);
  }
  if (temp  521){
    kh(7);
  }
  if (temp  564){
    kh(8);
  }
  else{
    kh(9); //light them all
  }
}

void kh(int minn){//build a mountain
  for (e=minn; e= minn
    maxx(d[e],0);
    maxx(d[minn],0); //pushes the last clear through to the second matrix
 }
  for (e=1; e<minn; e++){ //turn on the rows <min
    mat(e,e);
    mat(e, 17-e);
  }
}

heres my code for writing to two matrices:

void mat(int reg, int col){ //can address row 1-8, col 1-16
  digitalWrite(load, LOW);
  if (col <= 8){//this writes the lower rows to the second matrix
    putByte(d[reg]);
    putByte(c[col]);
    putByte(0x00);
    putByte(0x00);
  }
  else{//this subtracts 8 and writes the higher rows to the first matrix
    putByte(d[reg]);
    putByte(c[col-8]);
  }
  digitalWrite(load, HIGH);
}

I managed to lose the .ai of the poster I made for the final presentation, but it was just name, title, and abstract

Materials:Arduino microprocessorMacbook (for power)simple switchbreadboard22 gauge solid wires1 150 ohm resistorrubberbands or fishwire (to wrap around the exercise machine)1 mechanical exercise machine1 busy/lazy person who wants to work out but is in need of a reminder

Please watch the video to see the process and explanation:

For the full downloadable video file (55.9 mb): www.kipworks.com/mfi/kipumlee_mfi_finalproject.mov

For the downloadable poster that was used during the final presentation (1.1 mb): www.kipworks.com/mfi/kipumlee_Poster.pdf

Learnings:It was good to prototype on my own and take things outside of the conceptual world. Although it was difficult learning these new programs and how things actually work, I learned the basics of how to put things together and test out an idea. I hope to continue working with physical computing and study the subject more to get more proficient with the materials and coding.
(Mark, I still don’t know why I can’t post my code even though I’ve followed the directions on how to make it nice using the “sourcecode” brackets)

Code for Arduino:

 int sensorVal;

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

void loop() {
  sensorVal = analogRead(0);
  Serial.println(sensorVal, DEC);
  delay(10);
}

Processing Code:

//adapted from Tom Igoe's works.
import processing.serial.*;                    			// access to serial port
import processing.net.*;                       			// access to net library

int linefeed=10;                               			//linefeed in ASCII
Serial myPort;                                 			//the serial port
int sensorVal=0;
int graphPosition=0;                           			//to graph my sensor input
boolean kipsToy=false;                         			//if thing not there (to use with graph plotting)
int threshold=1;                               			//if above this number, thing is there
int timeThreshold=0;                           			//minimum number of minutes between emails
int timerMax=10000;                            			//timer limit is 10000 loops (equivalent to about 2 min)
int timer=0;                                   			//start timer
int triggerPHP=0;                              			//if triggerPHP=0, no email is sent via PHP. if triggerPHP=1, email sent to me.

//HTTP client variables:
Client client;                                 			// new net client
boolean requestInProgress;                     			// whether a net request is in progress
String responseString = "";                    			// string of text received by client

void setup() {
  size(400,300);
  println(Serial.list());
  myPort=new Serial(this, Serial.list()[0], 9600);

  myPort.bufferUntil(linefeed);
}

//SAME AS VOID LOOP() IN ARDUINO
void draw() {
  if(sensorVal > threshold) {                			//if the sensorVal is above threshold
    kipsToy=true;                            			//someone there (for graph purposes)
    timer=0;                                 			//reset timer
    triggerPHP=0;                            			//PHP reads and doesn't send me an email b/c only triggerPHP=1 sends me email
  }
  else{
    if(sensorVal < threshold && timer >= timerMax) {    	//if sensor not in use and nonusage time > timeMax
      kipsToy=false;                           			//therefore, nothing there anymore (for graph purposes)
      sendMail();                              			//then send mail
      timer=0;                                 			//reset timer
      triggerPHP=1;                            			//variable to trigger PHP to send me an email
    }
  }

  if (requestInProgress == true) {
    checkNetClient();
  }
  timer++;                                     			//adds one to timer while it continues to loop
  println("Timer Reading is" + timer);
}

//READS FROM ARDUINO
void serialEvent(Serial myPort) {
  String myString=myPort.readStringUntil(linefeed);
  if(myString !=null) {
    sensorVal=int(trim(myString));
    println("This is the sensor value from arduino" + sensorVal);
    drawGraph();                              			//draws graph
  }
}

//DRAWS GRAPH
void drawGraph() {
  int lineHeight=sensorVal/2;
  if (kipsToy) {
    stroke(0,255,0);                           			//draw green line
  }
  else{
    stroke(255,0,0);                           			//draw red line
  }
  line(graphPosition, height, graphPosition, height-lineHeight);

  //at the edge of the screen, go back to the beginning:
  if(graphPosition >= width) {
    graphPosition=0;
    background(0);
  }
  else{
    graphPosition++;
  }
}

//USING PHP TO SEND MAIL
void sendMail() {
  if (requestInProgress == false) {               		//Do this only if I'm not already in the middle of an HTTP request
    client = new Client(this, "kipworks.com", 80);      	// open a connection to host

    String requestString = "/mfi/mfi-script2.php?triggerPHP=" + triggerPHP;    //form the request string

    client.write("GET " + requestString + " HTTP/1.0\n");    	//send the HTTP GET request
    client.write("HOST: kipworks.com\n\n");
    requestInProgress = true;                    		//note that I have a request in progress
  }
}

//NETWORK STUFF
void checkNetClient() {
  if (client.available() > 0) {                  		//available() returns how many bytes have been received by client
    responseString +=char(client.read());        		//read a byte, convert to a character, and add it to string
    print("|");                                  		//add to a line of |'s on the screen
  }
  else{                                         		//if no byte available, either the response hasn't started, or it's done
    if(responseString.length() > 0) {              		//if responseString is longer than 0 bytes, response has started
      if(requestInProgress == true) {              		//I've got some bytes, but now there's no more to read. stop
        println(responseString);                   		//print the response
        requestInProgress = false;                 		//note that the request is over
        responseString = "";                       		//reset the string for future requests
      }
    }
  }
}

While I’m pleased to have achieved my main goal of the CD player circuit bend, I wish I had more time to develop the content (audio) to better utilize the technical developments.

int cd1stop = 2;
int cd1play = 3;
int cd1forward = 4;
int sensorPin = 0;
int val = 0;       // variable to store the value coming from the sensor

void setup()
{
  pinMode(cd1stop, OUTPUT);
  pinMode(cd1play, OUTPUT);
  pinMode(cd1forward, OUTPUT);
  pinMode(sensorPin, INPUT);  // }

void loop()
{
  val = analogRead(sensorPin);    // read the value from the sensor
  delay(1000);
  if (val < 850)  // zero out CD player (automatically plays) and stop it
	{digitalWrite(cd1play, HIGH);
	delay(100);
	digitalWrite(cd1stop, LOW);
	delay(1000);
	digitalWrite(cd1stop, HIGH);
	delay(1000);
	}

   else	// play
	{digitalWrite(cd1play, LOW);
	}
}

* Description

This interactive coffee table responds to the users and objects (coffee cups) by giving out different shades of light.

Two I/R sensors are attached on each side of the table to detect how many people there are. Two photocells are attached on the top of the table at both ends to detect how many coffee cups are being used. Depending on how many people or coffee cups there are, the table will respond differently with different shades and intensity of color. The table reaches its happiest state when the table is being fully utilized; two people sitting at the table, both of them drinking coffee. The table will entertain the users by flashing colorful lights and spinning.

* Code

int lightVal = 0;
int lightValB = 0;
int distanceVal = 0;
int distanceValB = 0;
int lightsensor = 0;
int lightsensorB = 2;
int distancesensor = 3;
int distancesensorB = 1;
int green = 11;
int red = 9;
int blue = 10;
int greenB = 3;
int redB = 5;
int motor = 7;
int value = 0;
int state = 1;
void setup() {
  pinMode(lightsensor, INPUT);
  pinMode(lightsensorB, INPUT);
  pinMode(distancesensor, INPUT);
  pinMode(distancesensorB, INPUT);
  pinMode(motor,OUTPUT);
  pinMode(red,OUTPUT);
  pinMode(green,OUTPUT);
  pinMode(blue,OUTPUT);
  pinMode(redB,OUTPUT);
  pinMode(greenB,OUTPUT);
  Serial.begin(9600); // Set up the serial communication.
}
void loop()
{
  lightVal = analogRead(lightsensor);
  lightValB = analogRead(lightsensorB);
  distanceVal = analogRead(distancesensor);
  distanceValB = analogRead(distancesensorB);
  Serial.println("-----");
  Serial.print("lightvallue ");
  Serial.println(lightVal);
  Serial.print("lightvalueB ");
  Serial.println(lightValB);
  Serial.print("distancevalue ");
  Serial.println(distanceVal);
  Serial.print("distancevalueB ");
  Serial.println(distanceValB);
 Serial.print("state ");
 Serial.println(state);
 if (state == 0) {noPnoC ();}
 else if (state == 1) {noPoneC ();}
 else if (state == 2) {noPoneC_B ();}
 else if (state == 3) {noPtwoC ();}
 else if (state == 4) {onePnoC ();}
 else if (state == 5) {onePnoC_B ();}
 else if (state == 6) {onePoneC ();}
 else if (state == 7) {onePoneC_B ();}
 else if (state ==  {onePtwoC ();}
 else if (state == 9) {onePtwoC_B ();}
 else if (state == 10) {twoPnoC ();}
 else if (state == 11) {twoPoneC ();}
 else if (state == 12) {twoPoneC_B ();}
 else if (state == 13) {twoPtwoC ();}
}
void noPnoC()    
{
  alloff();
  for(value = 0; value <=75; value+=5)
  {analogWrite(red, value);
  delay(100);}
 
  for(value = 75; value >=0; value-=5)
  {analogWrite(red, value);
  delay(100);}
condition();
}   
void noPoneC()   
{
  alloff();
  for(value = 0; value <=50; value+=2)
  {analogWrite(red, value);
  delay(200);}
 
  for(value = 50; value >=0; value-=2)
  {analogWrite(red, value);
  delay(200);}
 
condition();
}
void noPoneC_B()       
{
  alloff();
  for(value = 0; value <=50; value+=2)
  {analogWrite(red, value);
  delay(200);}
 
  for(value = 50; value >=0; value-=2)
  {analogWrite(red, value);
  delay(200);}
 
 condition();
}
void noPtwoC()      
{
  alloff();
  for(value = 0; value <=50; value+=2)
  {analogWrite(red, value);
  delay(200);}
 
  for(value = 50; value >=0; value-=2)
  {analogWrite(red, value);
  delay(200);}
 
 condition();
}
void onePnoC()
{
  alloff();
  for(value = 0 ; value <=180; value+=5)
  {analogWrite(blue, value);
  delay(30); }
  for(value = 180 ; value >=0; value-=5)
  {analogWrite(blue, value);
  delay(30);}
 
condition();
}
void onePnoC_B()
{
  alloff();
  for(value = 0 ; value <=180; value+=5)
  {analogWrite(red, value);
  delay(30); }
  for(value = 180 ; value >=0; value-=5)
  {analogWrite(red, value);
  delay(30);}
 
condition();
}

void onePoneC()
{  alloff();
  for(value =0; value <=180; value+=5)
  {analogWrite(blue, value);
  delay(30);}
  for(value = 0; value <=255; value+=10)
  {analogWrite(greenB, value);
  delay(30);}
 
  for(value = 255; value >=0; value-=10)
  {analogWrite(greenB, value);
  delay(30);}
 
  for(value = 180; value >=0; value-=5)
  {analogWrite(blue, value);
  delay(30);}
 
condition();
}
void onePoneC_B()
{  alloff();
  for(value =0; value <=180; value+=5)
  {analogWrite(red, value);
  delay(30);}
  for(value = 0; value <=255; value+=10)
  {analogWrite(greenB, value);
  delay(30);}
 
  for(value = 255; value >=0; value-=10)
  {analogWrite(greenB, value);
  delay(30);}
 
  for(value = 180; value >=0; value-=5)
  {analogWrite(red, value);
  delay(30);}
 
condition();
}
void onePtwoC()
{  alloff();
  for(value =0; value <=180; value+=5)
  {analogWrite(blue, value);
  delay(30);}
  for(value = 0; value <=255; value+=10)
  {analogWrite(greenB, value);
  delay(30);}
 
  for(value = 0; value <=255; value+=10)
  {analogWrite(green, value);
  delay(30);}
 
  for(value = 255; value >=0; value-=10)
  {analogWrite(greenB, value);
  delay(30);}
    
  for(value = 255; value >=0; value-=10)
  {analogWrite(green, value);
  delay(30);}
 
  for(value = 180; value >=0; value-=5)
  {analogWrite(blue, value);
  delay(30);}
 
 condition();
}
void onePtwoC_B()
{  alloff();
  for(value =0; value <=180; value+=5)
  {analogWrite(red, value);
  delay(30);}
  for(value = 0; value <=255; value+=10)
  {analogWrite(greenB, value);
  delay(30);}
 
  for(value = 0; value <=255; value+=10)
  {analogWrite(green, value);
  delay(30);}
 
  for(value = 255; value >=0; value-=10)
  {analogWrite(greenB, value);
  delay(30);}
    
  for(value = 255; value >=0; value-=10)
  {analogWrite(green, value);
  delay(30);}
 
  for(value = 180; value >=0; value-=5)
  {analogWrite(red, value);
  delay(30);}
condition();
}

void twoPnoC()
{  alloff();
  for(value =0; value <=200; value+=5)
  {analogWrite(blue, value);
  delay(30);}
 
  for(value =0; value <=200; value+=5)
  {analogWrite(redB, value);
  delay(30);}
   
  for(value = 200; value >=0; value-=5)
  {analogWrite(blue, value);
  delay(30);}
 
  for(value = 200; value >=0; value-=5)
  {analogWrite(redB, value);
  delay(30);}
 
condition();
}
void twoPoneC()
{  alloff();
  for(value = 0; value <=180; value+=5)
  {analogWrite(blue, value);
  delay(30);}
 
  for(value =0; value <=180; value+=5)
  {analogWrite(redB, value);
  delay(30);}
 
  for(value = 0; value <=255; value+=10)
  {analogWrite(green, value);
  delay(30);}
 
  for(value = 255; value >=0; value-=10)
  {analogWrite(green, value);
  delay(30);}
   
  for(value = 180; value >=0; value-=5)
  {analogWrite(blue, value);
  delay(30);}
 
  for(value = 180; value >=0; value-=5)
  {analogWrite(redB, value);
  delay(30);}
 
condition();
}
void twoPoneC_B()
{  alloff();
  for(value = 0; value <=180; value+=5)
  {analogWrite(blue, value);
  delay(30);}
 
  for(value =0; value <=180; value+=5)
  {analogWrite(redB, value);
  delay(30);}
 
  for(value = 0; value <=255; value+=10)
  {analogWrite(green, value);
  delay(30);}
 
  for(value = 255; value >=0; value-=10)
  {analogWrite(green, value);
  delay(30);}
   
  for(value = 180; value >=0; value-=5)
  {analogWrite(blue, value);
  delay(30);}
 
  for(value = 180; value >=0; value-=5)
  {analogWrite(redB, value);
  delay(30);}
 
condition();
}
void twoPtwoC()
{  alloff();
  digitalWrite(motor,HIGH);
  digitalWrite(red, HIGH);
  delay(50);
  digitalWrite(red,LOW);
  digitalWrite(red, HIGH);
  delay(50);
  digitalWrite(red,LOW);
  digitalWrite(green,HIGH);
  delay(50);
  digitalWrite(green,LOW);
  digitalWrite(blue,HIGH);
  delay(50);
  digitalWrite(blue,LOW);
  digitalWrite(greenB,HIGH);
  delay(50);
  digitalWrite(greenB,LOW); 
condition();
}

void alloff()
{
  digitalWrite(red,LOW);
  digitalWrite(green,LOW);
  digitalWrite(blue,LOW);
  digitalWrite(redB,LOW);
  digitalWrite(greenB,LOW);
  digitalWrite(motor,LOW);
}
void condition()
{
  if (distanceVal < 150 && lightVal > 80 && distanceValB < 150 && lightValB > 220) {state = 0;}
  if (distanceVal < 150 && lightVal < 80 && distanceValB < 150 && lightValB > 220) {state = 1;}
  if (distanceVal < 150 && lightVal > 80 && distanceValB < 150 && lightValB < 220) {state = 2;}
  if (distanceVal < 150 && lightVal < 80 && distanceValB < 150 && lightValB < 220) {state = 3;}
  if (distanceVal > 150 && lightVal > 80 && distanceValB < 150 && lightValB > 220) {state = 4;}
  if (distanceVal < 150 && lightVal > 80 && distanceValB > 150 && lightValB > 220) {state = 5;}
  if (distanceVal > 150 && lightVal < 80 && distanceValB < 150 && lightValB > 220) {state = 6;}
  if (distanceVal < 150 && lightVal > 80 && distanceValB > 150 && lightValB < 220) {state = 7;}
  if (distanceVal > 150 && lightVal < 80 && distanceValB < 150 && lightValB < 220) {state = 8;}
  if (distanceVal < 150 && lightVal < 80 && distanceValB > 150 && lightValB < 220) {state = 9;}
  if (distanceVal > 150 && lightVal > 80 && distanceValB > 150 && lightValB > 220) {state = 10;}
  if (distanceVal > 150 && lightVal < 80 && distanceValB > 150 && lightValB > 220) {state = 11;}
  if (distanceVal > 150 && lightVal > 80 && distanceValB > 150 && lightValB < 220) {state = 12;}
  if (distanceVal > 150 && lightVal < 80 && distanceValB > 150 && lightValB < 220) {state = 13;}
 
}

A kinetic object responds to movement both across its face as well as towards and away from it. Like a simple mechanical pet or a sunflower, it reacts to a body along a path, following one longingly as it passes; it may even show excitement when approached.

With this project I sought to build on skills learned over the semester, and elaborate on the four-state machine practiced earlier in the year, engaging the possibilities of passive, casual movement as interaction with an artifact.

Each pinwheel possesses two ultrasonic rangefinders in order to determine the presence of an object in its field of vision calculating distance of passing objects through each rangefinder, thus allowing it to calculate the angle at which the pinwheel pivots towards the movement.

Poster here

#include <math.h> // (no semicolon)

int milliSecCounter = 0;  // countshow many times we've gone through the sendServoAngle() function
int timesThruLoop = 0;    //coutns how many times we've read for a new angle
int holdDuration = 100;      //in milliseconds, stores how long we wait before taking another reading....this is to give the servo enough time to go to the angle
int newestAngle;
int newestDistance;
int valA;
int valB;

int myAngle;
int pulseWidth;

int potPin = 0;           // Analog in 0 connected to the potentiometer
int transistorPin = 9;    // connected to the base of the transistor for EACH MOTOR
int alphaMotorPin = 9;
int potValue = 0;         // value returned from the potentiometer

 // -------IR _ STUFF

//    pin values
int ultraSoundSignalLeft = 8; // Ultrasound signal pin
int ultraSoundSignalRight = 7; // Ultrasound signal pin

int val = 0;
int valRight = 0;

int irValA;
int irValB;

int ultrasoundValue = 0;
int ultrasoundValueRight = 0;

int timecount = 0; // Echo counter
int timecountRight = 0; // Echo counter

int ledPin = 13; // LED connected to digital pin 13

int sensorDistance = 100; //distance between sensors, should be in same units (response time) that sensor detects in.
int absDistance;
int maxDistance = 5000; //value to cap detectable distance

// CALC ANGLE
int disLeft;         //calculated distance from left sensor
int disRight;        //calculated distance from right sensor
int newAngle;        //calculated angle from IR readings

int angleSlightLeft = 100;     //lower limit angle read to turn the extreme left
int angleMoreLeft = 122;        //upper limit angle read to turn the the left
int angleMostLeft = 145;
int angleCenter = 90;
int angleSlightRight = 77;      //upper limit angle to read to turn to the right
int angleMoreRight = 55;
int angleMostRight = 32;    //upper limit angle read to turn to the far right

int movetoUnits = 128; //values as anaolong input to the servo.
                        //multiply this value by the values below to obtain analong input to servo

int movetoMostLeft = 7;     //degree value of far left angle to move to
int movetoMoreLeft = 6;        //degree valeu of left angle to move to
int movetoSlightLeft = 5;
int movetoCenter = 4;
int movetoMostRight = 3;        //degree value of right angle to move to
int movetoMoreRight = 2;
int movetoSlightRight =1 ;      //degree value of far right angle to move to

//SERVO STUFF ------------------------
int alphaServoPin = 2;
int servoPin = 2;     // Control pin for servo motor
int minPulse = 500;   // Minimum servo position
int maxPulse = 2500;  // Maximum servo position
int pulse = 0;        // Amount to pulse the servo
int pulseRange = 2000;

long lastPulse = 0;    // the time in milliseconds of the last pulse
int refreshTime = 20; // the time needed in between pulses

int analogValue = 0;  // the value returned from the analog sensor
int analogPin = 1;    // the analog pin that the sensor's on

boolean firstTime = true;

// MOTOR VARIABLES
int speedHigh = 150;       //designated range for high, med, and low motor speed
int speedMed = 100;
int speedLow = 230;      

int farDist = 1400;
int medDist = 400;  

// COUNTERS
int holdValuesCounter;    //counts how many times the entire loop (all four sensors have been read) has been done
int holdValuesTill;      //holds the counter value which decides when to change motor speed and servo position (look elsewhere)

int latentTimeCounter;    //counts how many seconods of no movement
int latentTimeLimit;      //determines how many seconds of no activity until "sleep" behavior occurs

int count = 1;

// -----------------------------------

void setup() {
  // SERVO STUFF
    pinMode(servoPin, OUTPUT);  // Set servo pin as an output pin
  pulse = minPulse;           // Set the motor position value to the minimum

  // set  the transistor pin as output:
  pinMode(transistorPin, OUTPUT);
  pinMode(ledPin, OUTPUT);            // Sets the digital pin as output
    Serial.begin(9600);  

}

void servoPulse(int servoPin, int myAngle){
  pulseWidth = (myAngle*11) + 500;
  digitalWrite(servoPin, HIGH);
  delayMicroseconds(pulseWidth);
  digitalWrite(servoPin, LOW);
  delay(20);
}

void loop() {

  timecount = 0;
  timecountRight = 0;
  val = 0;
  valRight = 0;
  ultrasoundValue = 0;
  ultrasoundValueRight = 0;

  //IR stuff
  pinMode(ultraSoundSignalLeft, OUTPUT); // Switch signalpin to output
  pinMode(ultraSoundSignalRight, OUTPUT); // Switch signalpin to output

  //test every 1000th millisecond
//  ENTER if (milliSecCounter

 if (milliSecCounter == 0 || milliSecCounter == timesThruLoop*holdDuration){
    timesThruLoop++;   ///count how many times did we go through loop?
    Serial.println("inloop");
  //if true, read for new angle
    valA =   readIR(ultraSoundSignalLeft, val, ultrasoundValue, timecount);
    valB = readIR(ultraSoundSignalRight, valRight, ultrasoundValueRight, timecountRight);
    newestAngle = getAngleSimple( valA, valB );
    newestDistance = getSmallestDistance(valA, valB);
   // Serial.println("newestAngle");
    Serial.println(newestAngle);
    sendMotor(alphaMotorPin, newestDistance);
  }

  //else save last angle and let testServoAngle pulse to the next one
 testServoAngle(newestAngle);
  milliSecCounter = milliSecCounter + 1;
} 

//-----INDIVIDUAL FUNCTIONS-------------------
// DC MOTOR
void testMotor(){

  // read the potentiometer, convert it to 0 - 255:

  potValue = analogRead(potPin) / 4;
  Serial.println("POTVALUE");
  Serial.println(potValue);
  // use that to control the transistor:
  analogWrite(9, potValue);
}

// SERVO FUNCTIONS
void moveServo(int angle){

    // SERVO STUFF
  //the servo is initialized at the center, record this position, and then move between the two throughout the program

  //analogValue = analogRead(analogPin);      // read the analog input
  //pulse = (angle * 19) / 10 + minPulse;    // convert the analog value
                                            // to a range between minPulse
                                            // and maxPulse.
  pulse = (angle*2000 ) / 180 + pulseRange;
  Serial.println("ANGLE");
  Serial.println(pulse);

  // pulse the servo again if rhe refresh time (20 ms) have passed:
  if (millis() - lastPulse >= refreshTime) {
    digitalWrite(servoPin, HIGH);   // Turn the motor on
    delayMicroseconds(pulse);       // Length of the pulse sets the motor position
    digitalWrite(servoPin, LOW);    // Turn the motor off
    lastPulse = millis();           // save the time of the last pulse
  }
}

void testServo(){

    // SERVO STUFF
  //the servo is initialized at the center, record this position, and then move between the two throughout the program

  //analogValue = 1023;
  analogValue = analogRead(analogPin);      // read the analog input
  pulse = (analogValue * 19) / 10 + minPulse;    // convert the analog value
                                            // to a range between minPulse
                                            // and maxPulse.
  Serial.println("ANGLE");
  Serial.println(pulse);
  Serial.println(analogValue);
 Serial.println("count");
Serial.println(count);

  // pulse the servo again if rhe refresh time (20 ms) have passed:
  if (millis() - lastPulse >= refreshTime) {
    digitalWrite(servoPin, HIGH);   // Turn the motor on
    delayMicroseconds(pulse);       // Length of the pulse sets the motor position
    digitalWrite(servoPin, LOW);    // Turn the motor off
    lastPulse = millis();           // save the time of the last pulse
  }

}
void testServoAngle (int angle){

    // SERVO STUFF
  //the servo is initialized at the center, record this position, and then move between the two throughout the program

  //analogValue = 1023;
// pulse = analogVal;
 // analogValue = analogVal;      // read the analog input 0 - 1023

  //convert degrees to analogVal inputs (0-1023)
 //pulse = (bucketAngle(analogVal)* 19) / 10 + minPulse;

 // pulse = (analogValue * 19) / 10 + minPulse;    // convert the analog value
                                            // to a range between minPulse
                                            // and maxPulse. 

  ///1. CONVERT ANGLE TO ANALOG 0-1023
  pulse = (angle*11) + 500;
  //2. CONVERT ANALOG TO PULSE
  Serial.println("Angle is");
  Serial.println(angle);
  Serial.println("PULSE");
  Serial.println(pulse);

  // pulse the servo again if rhe refresh time (20 ms) have passed:
  while (millis() - lastPulse >= refreshTime) {
    digitalWrite(servoPin, HIGH);   // Turn the motor on
    delayMicroseconds(pulse);       // Length of the pulse sets the motor position
    digitalWrite(servoPin, LOW);    // Turn the motor off
    lastPulse = millis();           // save the time of the last pulse
  }

}

// IR FUNCTIONS
int readIR(int pinIR, int value, int soundValue, int time){

       // Send low-high-low pulse to activate the trigger pulse of the sensor
      // -------------------------------------------------------------------

      digitalWrite(pinIR, LOW); // Send low pulse
      delayMicroseconds(2); // Wait for 2 microseconds
      digitalWrite(pinIR, HIGH); // Send high pulse
      delayMicroseconds(5); // Wait for 5 microseconds
      digitalWrite(pinIR, LOW); // Holdoff

      // Listening for echo pulse
      // -------------------------------------------------------------------

      pinMode(pinIR, INPUT); // Switch signalpin to input
      value = digitalRead(pinIR); // Append signal value to val
      while(value == LOW) { // Loop until pin reads a high value
      value = digitalRead(pinIR);

      }

      while(value == HIGH) { // Loop until pin reads a high value
      value = digitalRead(pinIR);
       time = time +1;            // Count echo pulse time

      }
      // Writing out values to the serial port
      // -------------------------------------------------------------------
      //
      if (time > maxDistance){ time = maxDistance;} //cap max distance if readings too much
      soundValue = time; // Append echo pulse time to ultrasoundValue
    //

      if(time > 0){
      digitalWrite(ledPin, HIGH);
      }

      // Delay of program

      delay(200);

      return soundValue; // is distance
      }

int getAngleSimple(int left, int right){ // funciton outputs degrees
//calc distance, put in a range, then figure angle.

  if (abs(left - right) < 5) //qualify a difference between left and right then,calc distance
   {
   Serial.println("equal distances");
   newAngle = 90;
   }

 if (left > right){
   absDistance = left - right;
   newAngle = 57.3*atan2(absDistance,sensorDistance);
   }
 if  (left < right){
   absDistance = right - left;
   newAngle = 90 + (57.3*atan2(absDistance,sensorDistance));
   }
 //  Serial.println ("Angle");
   return newAngle;
  // moveServo(newAngle);
  // newAngle = 0;

 }

void calcAngle(){ // funciton outputs degrees
//calc distance, put in a range, then figure angle.
 if (abs(disLeft-disRight) < 5) //qualify a difference between left and right then,calc distance
   {
   Serial.println("equal distances");
   newAngle = 90;
   }

 if (disLeft > disRight){
  Serial.println("left greater");
   //calcMotor(disRight); //send shortest distance to determine motor RPMs
   absDistance = disLeft - disRight;
   ////newAngle = 180;
   //newAngle = 180 - (57.3*atan2(absDistance,sensorDistance));
   newAngle = 57.3*atan2(absDistance,sensorDistance);
   //newAngle = 57*atan2(calcAbsDist(disLeft,disRight),sensorDistance);
   }
 if  (disLeft < disRight){
   Serial.println("right greater");
   //calcMotor(disLeft); //send shortest distance to determine motor RPMs
   absDistance = disRight - disLeft;
   ////newAngle = 0;
   //newAngle = 270 - (57.3*atan2(absDistance,sensorDistance));
   newAngle = 90 + (57.3*atan2(absDistance,sensorDistance));
   //newAngle = 90 + 57*atan2(calcAbsDist(disRight,disLeft),sensorDistance);
   }
   Serial.println ("Angle");
   Serial.println (newAngle);
  // moveServo(newAngle);
  // newAngle = 0;

 }

int calcClosest(int left, int right){
  if (left > right){ return left;}
  else if (left < right) {return right;}
  else  { return left; }

}

int calcAbsDist( int x, int y){
  absDistValue = x - y;
  return absDistValue;

}

void sendServo (int pinServo, int angle){

  //the servo is initialized at the center, record this position, and then move between the two throughout the program

  analogValue = analogRead(analogPin); //test to read from analog potentiometer
  //analogValue = bucketAngle(angle);     // read the analog input
  pulse = (analogValue * 19) / 10 + minPulse;    // convert the analog value
                                            // to a range between minPulse
                                            // and maxPulse. 

  Serial.println("ANGLE");
  Serial.println(analogValue);

 // pulse the servo again if rhe refresh time (20 ms) have passed:
  while (millis() - lastPulse >= refreshTime) {
    digitalWrite(pinServo, HIGH);   // Turn the motor on
    delayMicroseconds(pulse);       // Length of the pulse sets the motor position
    digitalWrite(pinServo, LOW);    // Turn the motor off
    lastPulse = millis();           // save the time of the last pulse
  }

}

int bucketAngle(int z){ //convert raw angle into generalized angle
  if (z <= angleMostRight){ z = movetoMostRight;}
  if (z > angleMostRight && z <= angleMoreRight){ z = movetoMoreRight;}
  if (z > angleMoreRight && z <= angleSlightRight){ z = movetoSlightRight;}
  if (z > angleSlightRight && z<= angleSlightLeft){ z = movetoCenter;}
  if (z > angleSlightLeft && z<= angleMoreLeft){ z = movetoSlightLeft;}
  if (z > angleMoreLeft && z<= angleMostLeft){ z = movetoMoreLeft;}
  if (z > angleMostLeft){ z = movetoMostLeft;} 

  z = z*movetoUnits; //z*128 = analog input to servo

 return z;
}

void sendMotor (int pinMotor, int distance){
  Serial.println("in send motor");
  if (distance > farDist){ potValue = speedHigh;}
  if (distance > medDist && distance <= farDist){ potValue = speedMed;}
  if (distance < medDist){ potValue = speedLow;}
  analogWrite(pinMotor, potValue);
}

int getSmallestDistance (int a, int b){
 if (a > b) {return a;}
 if (a < b) { return b;}
 if ( a == b){return a;}
}