const byte NBR_SENSORS = 3;  // this version only has left and right sensors
const byte IR_SENSOR[NBR_SENSORS] = {0, 1, 2}; // analog pins for sensors

// returns true if an object is detected on the given sensor
// the sensor parameter is the index into the sensor array
int irSensorDetect(int sensor)
{
  boolean result = false; // default value
  int value = analogRead(IR_SENSOR[sensor]); // get IR light level
  if( value <= irSensorReflect[sensor]) {
    result = true; // object detected (lower value means more reflection)
    if( isDetected[sensor] == false) { // only print on initial detection
      Serial.print(locationString[sensor]);         
      Serial.println(" object detected");
    }
  }
  isDetected[sensor] = result;  
  return result;
} 

boolean irEdgeDetect(int sensor)
{
  boolean result = false; // default value
  int value = analogRead(IR_SENSOR[sensor]); // get IR light level
  if( value >= irSensorEdge[sensor]) {
    result = true; // edge detected (higher value means less reflection)
    if( isDetected[sensor] == false) { // only print on initial detection
      Serial.print(locationString[sensor]);         
      Serial.println(" edge detected");
     }
  }
  isDetected[sensor] = result; 
  return result;
}

// calibrate thresholds for ambient light 
void irSensorCalibrate(byte sensor)
{
   int ambient = analogRead(IR_SENSOR[sensor]); // get ambient level
  irSensorAmbient[sensor] = ambient; 
  // precalculate the levels for object and edge detection  
  irSensorReflect[sensor] = (ambient * (long)(100-irReflectThreshold)) / 100;
  irSensorEdge[sensor]    = (ambient * (long)(100+irEdgeThreshold)) / 100; 
}   

/*********************************
 code for ping distance sensor
**********************************/

// Returns the distance in inches
// this returns 0 if no ping sensor is connected or the distance is greater than around 10 feet
int pingGetDistance(int pingPin)
{
  // establish variables for duration of the ping,
  // and the distance result in inches and centimeters:
  long duration, cm;

  // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
  pinMode(pingPin, OUTPUT);
  digitalWrite(pingPin, LOW);
  delayMicroseconds(2);
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(5);
  digitalWrite(pingPin, LOW);

  pinMode(pingPin, INPUT);
  duration = pulseIn(pingPin, HIGH, 20000); // if a pulse does not arrive 
                                            // in 20 ms then the ping sensor
                                            // is not connected
  if(duration >=20000)
    return 0;
    
  // convert the time into a distance
  cm = microsecondsToCentimeters(duration);
  return (cm * 10) / 25 ; // convert cm to inches
}

long microsecondsToCentimeters(long microseconds)
{
  // The speed of sound is 340 m/s or 29 microseconds per centimeter.
  // The ping travels out and back, so to find the distance of the
  // object we take half of the distance travelled.
  return microseconds / 29 / 2;
}

/********************************
  code for the EZ1 SONAR sensor
*********************************/  
// return distance using EZ1 connected to analog pin
int ezDistanceAN(int pin) // using analog
{
   const int bitsPerInch = 2; // each bit is 0.5 inch
   int value = analogRead(pin);
   int inches = value / 2;
   return inches; 
}

// return distance using EZ1 connected using PW
int ezDistancePW(int pin) //using digital pin
{
  int value = pulseIn(pin, HIGH); // timeout can be added (MAX_DISTANCE * 147L * 2)
  int cm = value / 58;      // pulse width is 58 ms per cm
  int inches = value / 147; // which is 147 ms per inch
  return inches;
}

/*********************************
 code for Sharp GP2Y0A02YK0F IR distance sensor
**********************************/
const long referenceMv = 5000; // the reference voltage in millivolts

int irGetDistance(byte pin)
{
  int val = analogRead(pin);
  int mV = map(val, 0, 1023, 0 , referenceMv);
  // or: 
  //int mV = (val,  * referenceMv) / 1023;
  
  int cm = mvToDistance(mV);
  return cm;
}

// the following is used to interpolate the distance from a table
// table entries are distances in steps of 250 millivolts
const int TABLE_ENTRIES = 11;
const int firstElement = 250; // first entry is 250 mV
const int INTERVAL  = 250; // millivolts between each element
static int distance[TABLE_ENTRIES] = {200,130,90,64,50,41,35,30,25,20,15};

int mvToDistance(int mV)
{
   if( mV < firstElement )
      return distance[0];
   if( mV >  INTERVAL * TABLE_ENTRIES )
      return distance[TABLE_ENTRIES-1];
   else
   {
      int index = mV / INTERVAL;   // highest table element <= mV value 
      int mV0 =  index * INTERVAL; // mV value of this element
      int mV1 = mV0 + INTERVAL;    // mV value of the next higher element 
      int result = map(mV, mV0, mV1, distance[index-1], distance[index]);  
      result = map(result, 0, 200, 0, 79); // convert from cm to inches 
      return result;
   }        
}

void loop()
{
  Serial.println("Waiting to detect movement from PIR sensor");
  pinMode(A5, INPUT); // configure the pin for input
  if(digitalRead(A5) == HIGH)
  {
     calibrateRotationRate(DIR_LEFT, 360);  // spin robot CCW one rotation
  }  
}

/**********************************************************
MyRobotSound.ino

Robot moves when a sound level exceeds a threshold
Based on Recipe 6.7 from Arduino Cookbook

Copyright Michael Margolis 20 July 2012

***********************************************************/

#include <AFMotor.h>  // adafruit motor shield library
#include "RobotMotor.h"    // 2wd or 4wd motor library

#include "robotDefines.h"  // global defines

const int analogInPin = 5;      // analog pin the sensor is connected to

const int middleValue = 512;      //the middle of the range of analog values
const int numberOfSamples = 128;  //how many readings will be taken each time

int sample;                       //the value read from microphone each time
long signal;                      //the reading once you have removed DC offset
long averageReading;              //the average of that loop of readings

long runningAverage=0;          //the running average of calculated values
const int averagedOver= 16;     //how quickly new values affect running average
                                //bigger numbers mean slower

const int threshold=400;        //at what level the robot will move

int speed = 50;

// Setup runs at startup and is used configure pins and init system variables
void setup()
{
  Serial.begin(9600);
  blinkNumber(8); // open port while flashing. Needed for Leonardo only  
  
  motorBegin(MOTOR_LEFT); 
  motorBegin(MOTOR_RIGHT); 
}

void loop()
{
  int level = getSoundLevel();
  if (level > threshold)         //is level more than the threshold ?
  {
     motorForward(MOTOR_LEFT, speed);    
     motorForward(MOTOR_RIGHT, speed);  
  }else
  {
     motorStop(MOTOR_LEFT);    
     motorStop(MOTOR_RIGHT);  
  }  
}

// function to indicate numbers by flashing the built-in LED
void blinkNumber( byte number) {
   pinMode(LED_PIN, OUTPUT); // enable the LED pin for output
   while(number--) {
     digitalWrite(LED_PIN, HIGH); delay(100);
     digitalWrite(LED_PIN, LOW);  delay(400);
   }
}

int getSoundLevel()
{
  long sumOfSquares = 0;
  for (int i=0; i<numberOfSamples; i++) { //take many readings and average them
    sample = analogRead(analogInPin);     //take a reading
    signal = (sample - middleValue);      //work out its offset from the center
    signal *= signal;                     //square it to make all values positive
    sumOfSquares += signal;               //add to the total
  }
  averageReading = sumOfSquares/numberOfSamples;     //calculate running average
  runningAverage=(((averagedOver-1)*runningAverage)+averageReading)/averagedOver;

  return runningAverage;
}