Circuit Playground Sound-Controlled Robot

// Variable Tone Generator Circuit for Arduino Uno or Circuit Playground
// Mike Barela for Adafruit Industries    September, 2016

#define speakerPin 11 // For Circuit Playground change 11 to 9 for
                      //  external Piezo, change to 5 for onboard speaker
#define potPin A0     // For Circuit Playground change A0 to A7 

void setup() { 
  pinMode(potPin, INPUT);
  pinMode(speakerPin, OUTPUT);  
  Serial.begin(9600);
}

void loop() {
  uint16_t potValue;
  uint16_t freq;
  
  potValue = analogRead(potPin);
  freq = map(potValue,0,1023,100,8000);
  tone(speakerPin,freq);
  Serial.println(freq);
}

// Fast Forier Transform Test Program for Circuit Playground
// Mike Barela for Adafruit Industries    September, 2016

#include <Adafruit_CircuitPlayground.h>

#define BINS   32          // The number of FFT frequency bins
#define FRAMES 4           // This many FFT cycles are averaged 

void setup() {
  CircuitPlayground.begin();  // Set up the board library and serial
  Serial.begin(9600);
}

void loop() {
  uint8_t i,j;
  uint16_t spectrum[BINS];     // FFT spectrum output buffer
  uint16_t avg[BINS];          // The average of FRAME "listens"

  for(j=1; j <= FRAMES; j  ) {             // We gather data FRAMES times and average it
     CircuitPlayground.mic.fft(spectrum);  // Here is the CP listen and FFT the data routine
     for(i=0; i < BINS; i  ) {             // Add for an average
       if(spectrum[i] > 255) spectrum[i] = 255; // limit outlier data
       if(i == 0)
         avg[i] = spectrum[i];
       else
         avg[i] = avg[i]   spectrum[i];
     }
  } 
  for(i=0; i < BINS; i  ) {               // For each output bin average
     avg[i] = avg[i] / FRAMES;            //  divide about the number of values aaveraged
  }
  int maxVal = 0, maxIndex = 0;
  for(i=0; i < BINS; i  ) {               // For each output bin average
     if(avg[i] >= maxVal) {               //  find the peak value
       maxVal = avg[i];
       maxIndex = i;                      //  and the bin that max value is in
     }
  }
  for(j=0; j < 32; j  ) {           // print spectrum 32 bins
     Serial.print(avg[j]);
     Serial.print(" ");
  }
  Serial.println("");              // and print the highest value and the bin it is in
  Serial.print("Max Value = "); Serial.print(maxVal);
  Serial.print(", Index of Max Value = "); Serial.println(maxIndex);
}

// Circuit Playground Robot - Continuous Servo zero/no movement calibration program
// Mike Barela for Adafruit Industries   September, 2016

#include <Adafruit_CircuitPlayground.h>
#include <Servo.h>

Servo servoLeft;              // Define left servo
Servo servoRight;             // Define right servo
float speedAngleLeft = 90.0;  // Assume 90 degrees as a start
float speedAngleRight = 90.0;

void setup() { 
  servoLeft.attach(12);         // Set left servo to digital pin 12
  servoRight.attach(6);         // Set right servo to digital pin 6
  CircuitPlayground.begin();    // initialize the Circuit Playground library
  Serial.begin(9600);           // to output servo angle values
  Serial.println("Robot Continuous Servo Zero Movement Calibration");
} 

void loop() {                     // Loop through motion tests
  Serial.print("Speed Left = ");    Serial.print(speedAngleLeft); 
  Serial.print(", Speed Right = "); Serial.println(speedAngleRight);
  if(CircuitPlayground.slideSwitch()) {  //   = Calibrate Right, - = Calibrate Left
    if( CircuitPlayground.rightButton() ) {
      speedAngleRight  = 0.1;
    }
    if( CircuitPlayground.leftButton() ) {
      speedAngleRight -= 0.1;
    }
  }
  else {
    if( CircuitPlayground.rightButton() ) {
      speedAngleLeft  = 0.1;
    }
    if( CircuitPlayground.leftButton() ) {
      speedAngleLeft -= 0.1;
    }
  }
  servoLeft.write(speedAngleLeft);
  servoRight.write(speedAngleRight);
  delay(50);
}

// A sound controlled robot for the Adafruit Circuit Playground board
//  This uses two continuous rotation servos for movement and listens to
//  commands via the built-in mic. 
// This version is designed to respond to two whistle tones for 
//   start and stop.
// By Mike Barela for Adafruit Industries September, 2016  

#include <Adafruit_CircuitPlayground.h>   // Circuit Playground library
#include <Servo.h>                        // Audiono servo control library

// Global Definitions ------------------------------------------------------------
//  Fourier Transform 
#define BINS        32    // FFT output is output in this many bins
#define FRAMES       4    // This many FFT cycles are averaged for leveling
#define THRESHOLD  150    // Max bin value to say a tone was detected

//  Servo objects
Servo servoLeft;             // Define left servo
#define leftStopAngle  96.2  // Angle that left servo will stop (calibrated)
Servo servoRight;            // Define right servo
#define rightStopAngle 95.3  // Angle that right servo will stop (calibrated)
uint8_t moving = 0;          // Is the robot currently moving value (0 = no, 1 = yes)

// SETUP FUNCTION - this runs once to set the robot up when it is powered on

void setup() {
  servoLeft.attach(12);                 // Set left servo to digital pin 12
  servoRight.attach(6);                 // Set right servo to digital pin 6
  CircuitPlayground.begin();            // Initialize the CP library
  CircuitPlayground.setBrightness(20);  // NeoPixels are another visual que on what is happening
  CircuitPlayground.clearPixels();      // Ensure all NeoPixels are off at start
  Serial.begin(9600);                   // Set up the USB port for serial information for users
  Serial.println("\n\nAdafruit Circuit Playground Robot using Whistle Commands");
  stopRobot();
}

// LOOP FUNCTION - runs over and over to check what to do ---------------------

void loop() {
  uint8_t  i,j;                        // loop index values
  uint16_t spectrum[BINS];             // FFT spectrum output buffer
  uint16_t avg[BINS];                  // The avaerage FFT values over FRAMES iterations
  int16_t  maxVal = 0, maxIndex = 0;   // The maximum value and the FFT bin of that value
  int8_t   maxBins;

  if( !CircuitPlayground.slideSwitch() ) {  // if slide switch is moved to "-", shut robot down
     if(moving) {
        stopRobot();                        // stop the robot
        CircuitPlayground.clearPixels();    // turn all pixels off in low power mode
     }
     Serial.println("\nRobot stopped due to slide switch, move to ' ' to resume");
     return;                                //  and go back to top of loop
  }

  for(j=1; j <= FRAMES; j  ) {         // Gather FRAMES samples of audio from the microphone
     CircuitPlayground.mic.fft(spectrum);  // This function gathers an audio sample and does FFT
     for(i=0; i < BINS; i  ) {             // Add values to perform a simple average
       if(spectrum[i] > 255) spectrum[i] = 255; // in library, sometimes values get "huge"
       if(i == 0)
         avg[i] = spectrum[i];
       else
         avg[i] = avg[i]   spectrum[i];
     }
  } 
  for(i=0; i < BINS; i  ) {       // For each output bin average
     avg[i] = avg[i] / FRAMES;    //   calculate the average (unweighted)
  }

  maxBins = 0;
  for(i=0; i < BINS; i  ) {   // Search for the highest value and the FFT bin it's in
     if(avg[i] > 255) avg[i] = 255;   // HACK 4 NOW
     if(avg[i] >= maxVal) {
       maxVal = avg[i];       // Important note: If there is an equal max value in higher bins
       maxIndex = i;          //   note the later index (helps when recognizing a sound)
     }
     if(avg[i] >= 254) maxBins  ;
  }
  // avg[] is now FRAME averaged FFT output, 32 bins.

     if( CircuitPlayground.leftButton() ) {    // use onboard buttons to change behavior 
        maxIndex = 9; // stop
        maxVal = THRESHOLD;
     }
     if( CircuitPlayground.rightButton() ) {
        maxIndex = 7; // forward
        maxVal = THRESHOLD;
     }
    
  // A detection is defined as a bin reaching a value of at least THRESHOLD
  if( maxVal >= THRESHOLD ) {    

     // For visual review of the values the FFT has produced, print the FFTs 32 bins
     for( uint8_t j=0; j < 32; j  ) {
       Serial.print(avg[j]);
       Serial.print(" ");
     }
     Serial.println("");
     // maxVal is the biggest bin, maxIndex is the index of that value
     Serial.print("\nMax Value = "); Serial.print(maxVal);
     Serial.print(", Index of Max Value = "); Serial.println(maxIndex);

     CircuitPlayground.clearPixels();  // clear old pixel values
     switch( maxIndex ) {  // based on which bin had the detection, act on it
       case  0:
       case  1:
       case  2:
                CircuitPlayground.strip.setPixelColor(0,0,240,0);
                // you can put a movement function call here
                break;       
       case  3:
       case  4:
                CircuitPlayground.strip.setPixelColor(1,0,240,0);
                // you can put a movement function call here
                break;       
       case  5:
       case  6:
       case  7:
                CircuitPlayground.strip.setPixelColor(2,10,225,10); // Low whistle (3rd LED Green)
                forward();   // forward
                break;       
       case  8:
       case  9:
       case 10:  
                CircuitPlayground.strip.setPixelColor(3,225,00,10); // higher whistle (4th LED red)
                stopRobot();
                break;     
       case 11:              // 7822 hertz
                CircuitPlayground.strip.setPixelColor(3,0,240,0);
                // you can put a movement function call here
                break;
       case 18:
       case 19: CircuitPlayground.strip.setPixelColor(4,0,240,0); // 2795 hertz
                // you can put a movement function call here
                break;
       case 20:              // 2957 hertz
       case 21:              // 3094 hertz  
       case 22: CircuitPlayground.strip.setPixelColor(5,0,240,0); // 3250 hertz
                // you can put a movement function call here
                break;
       case 23:             // 3436 hertz
       case 24:             // 3605 hertz
                
       case 25: CircuitPlayground.strip.setPixelColor(6,0,240,0); // 3700 hertz
                // you can put a movement function call here
                break;
       case 26:             // 3876 hertz
       case 27:             // 4046 hertz
       case 28: CircuitPlayground.strip.setPixelColor(7,0,240,0); // 4192 hertz (motor noise?)
                // you can put a movement function call here
                break;
       case 29:             // 4339 hertz
       case 30:             // 4517 hertz
       case 31: CircuitPlayground.strip.setPixelColor(8,0,240,0); // 4640 hertz (often goes here)
                // you can put a movement function call here
                break;
       default: CircuitPlayground.strip.setPixelColor(9,200,0,0); // if any other bin, light NeoPixel #9 red
                break;
     } // end switch
     CircuitPlayground.strip.show();  // show the neopixel assigned to the bin
  } // end if
} // end function loop

// Servo motion function routines for robot movement forward, reverse, turns, and stop

void stopRobot() {
  moving = 0;                        // let program know we are stopped
  servoLeft.write(leftStopAngle);    // Get these values from a calibration routine
  servoRight.write(rightStopAngle);  //  as continuous servos don't stop at exactly 90.0
  Serial.println("Stopped");
}

void forward() {
  if( moving == 1 ) {  // if the robot currently is moving  NEEDED?
    stopRobot();       // stop it 
  }
  else {
    moving = 1;        // flag we are going to move
  }
  servoLeft.write(0);
  servoRight.write(180);
}

void reverse() {
  if( moving == 1 ) {  // if the robot currently is moving
    stopRobot();       // stop it 
  }
  else {
    moving = 1;        // flag we are going to move
  }
  servoLeft.write(180);
  servoRight.write(0);
}

void turnRight() {
  if( moving == 1 ) {  // if the robot currently is moving
    stopRobot();       // stop it 
  }
  else {
    moving = 1;        // flag we are going to move
  }
  servoLeft.write(180);
  servoRight.write(180);
}

void turnLeft() {
  if( moving == 1 ) {  // if the robot currently is moving
    stopRobot();       // stop it 
  }
  else {
    moving = 1;        // flag we are going to move
  }
  servoLeft.write(0);
  servoRight.write(0);
}

// A sound controlled robot for the Adafruit Circuit Playground board
//  This uses two continuous rotation servos for movement and listens to
//  commands via the built-in mic. Sound processing is done with the
//  Circuit Playground FFT library function for AVR microcontrollers.

// The fast Fourier transform (FFT) algorithm converts a signal from the
// time domain to the frequency domain -- here, turning a specific audio
// signal into a command to the robot.

// Note the Circuit Playground slide switch when set to "-" stops the motors
//  It is not a battery off switch so unplug or turn off the battery to save
//  power when not in use.

// By Mike Barela for Adafruit Industries September, 2016  Version 1.0

#include <Adafruit_CircuitPlayground.h>   // Circuit Playground library
#include <Servo.h>                        // Audiono servo control library

// Global Definitions ------------------------------------------------------------
//  Fourier Transform 
#define BINS        32    // FFT output is output in this many bins
#define FRAMES       4    // This many FFT cycles are averaged for leveling
#define THRESHOLD  150    // Max bin value to say a tone was detected

//  Servo objects
Servo servoLeft;             // Define left servo
#define leftStopAngle  96.2  // Angle that left servo will stop (calibrated)
Servo servoRight;            // Define right servo
#define rightStopAngle 95.3  // Angle that right servo will stop (calibrated)
uint8_t moving = 0;          // Is the robot currently moving value (0 = no, 1 = yes)

// SETUP FUNCTION - this runs once to set the robot up when it is powered on

void setup() {
  servoLeft.attach(12);                 // Set left servo to digital pin 12
  servoRight.attach(6);                 // Set right servo to digital pin 6
  CircuitPlayground.begin();            // Initialize the CP library
  CircuitPlayground.setBrightness(20);  // NeoPixels are another visual que on what is happening
  CircuitPlayground.clearPixels();      // Ensure all NeoPixels are off at start
  Serial.begin(9600);                   // Set up the USB port for serial information for users
  Serial.println("\n\nAdafruit Circuit Playground Robot");
  stopRobot();
}

// LOOP FUNCTION - runs over and over to check what to do ---------------------

void loop() {
  uint8_t  i,j;                        // loop index values
  uint16_t spectrum[BINS];             // FFT spectrum output buffer
  uint16_t avg[BINS];                  // The avaerage FFT values over FRAMES iterations
  int16_t  maxVal = 0, maxIndex = 0;   // The maximum value and the FFT bin of that value
  int8_t   maxBins;

  if( !CircuitPlayground.slideSwitch() ) {  // if slide switch is moved to "-", shut robot down
     if(moving) {
        stopRobot();                        // stop the robot
        CircuitPlayground.clearPixels();    // turn all pixels off in low power mode
     }
     Serial.println("\nRobot stopped due to slide switch, move to ' ' to resume");
     return;                                //  and go back to top of loop
  }

  for(j=1; j <= FRAMES; j  ) {         // Gather FRAMES samples of audio from the microphone
     CircuitPlayground.mic.fft(spectrum);  // This function gathers an audio sample and does FFT
     for(i=0; i < BINS; i  ) {             // Add values to perform a simple average
       if(spectrum[i] > 255) spectrum[i] = 255; // in library, sometimes values get "huge"
       if(i == 0)
         avg[i] = spectrum[i];
       else
         avg[i] = avg[i]   spectrum[i];
     }
  } 
  for(i=0; i < BINS; i  ) {       // For each output bin average
     avg[i] = avg[i] / FRAMES;    //   calculate the average (unweighted)
  }

  maxBins = 0;
  for(i=0; i < BINS; i  ) {   // Search for the highest value and the FFT bin it's in
     if(avg[i] > 255) avg[i] = 255;   // HACK 4 NOW
     if(avg[i] >= maxVal) {
       maxVal = avg[i];       // Important note: If there is an equal max value in higher bins
       maxIndex = i;          //   note the later index (helps when recognizing a sound)
     }
     if(avg[i] >= 254) maxBins  ;
  }
  // avg[] is now FRAME averaged FFT output, 32 bins.

  // use onboard buttons to change behavior 
     if( CircuitPlayground.leftButton() ) {
        maxIndex = 28; // stop
        maxVal = THRESHOLD;
     }
     if( CircuitPlayground.rightButton() ) {
        maxIndex = 11; // forward
        maxVal = THRESHOLD;
     }
    
  // A detection is defined as a bin reaching a value of at least THRESHOLD
  if( maxVal >= THRESHOLD ) {    

    if( maxBins > 3 ) {  // Some loud broad spectrum sound, we don't want to act on that
      Serial.println("\nMore than 3 bins are maxed out");
      return;
    }

    // For visual review of the values the FFT has produced, print the FFTs 32 bins
     for( uint8_t j=0; j < 32; j  ) {
       Serial.print(avg[j]);
       Serial.print(" ");
     }
     Serial.println("");
     // maxVal is the biggest bin, maxIndex is the index of that value
     Serial.print("\nMax Value = "); Serial.print(maxVal);
     Serial.print(", Index of Max Value = "); Serial.println(maxIndex);

     CircuitPlayground.clearPixels();  // clear old pixel values
     switch( maxIndex ) {  // based on which bin had the detection, act on it
       case 10:              // 8000  hertz
       case 11: unused();    // 7822 hertz
                break;
       case 18:
       case 19: CircuitPlayground.strip.setPixelColor(0,0,240,0); // 2795 hertz
                forward();   // forward
                break;
       case 20:              // 2957 hertz
       case 21: unused();    // 3094 hertz  
                break;
       case 22: CircuitPlayground.strip.setPixelColor(1,0,240,0); // 3250 hertz
                turnLeft();
                break;
       case 23:             // 3436 hertz
       case 24: unused();   // 3605 hertz
                break;
       case 25: CircuitPlayground.strip.setPixelColor(2,0,240,0); // 3700 hertz
                turnRight();
                break;
       case 26:             // 3876 hertz
       case 27: unused();   // 4046 hertz
                break;
       case 28: CircuitPlayground.strip.setPixelColor(3,0,240,0); // 4192 hertz
                stopRobot();
                break;
       case 29:             // 4339 hertz
       case 30: unused();   // 4517 hertz
                break;
       case 31: CircuitPlayground.strip.setPixelColor(4,0,240,0); // 4640 hertz
                // reverse();
                break;
       default: CircuitPlayground.strip.setPixelColor(9,200,0,0); // if any other bin, light NeoPixel #9 red
                stopRobot(); 
                break;
     } // end switch
     CircuitPlayground.strip.show();  // show the neopixel assigned to the bin
  } // end if
} // end function loop

// Servo motion routines for robot movement forward, reverse, turns, and stop

void stopRobot() {
  moving = 0;                        // let program know we are stopped
  servoLeft.write(leftStopAngle);    // Get these values from a calibration routine
  servoRight.write(rightStopAngle);  //  as continuous servos don't stop at exactly 90.0
  Serial.println("Stopped");
}

void forward() {
  if( moving == 1 ) {  // if the robot currently is moving  NEEDED?
    stopRobot();       // stop it 
  }
  else {
    moving = 1;        // flag we are going to move
  }
  servoLeft.write(0);
  servoRight.write(180);
}

void reverse() {
  if( moving == 1 ) {  // if the robot currently is moving
    stopRobot();       // stop it 
  }
  else {
    moving = 1;        // flag we are going to move
  }
  servoLeft.write(180);
  servoRight.write(0);
}

void turnRight() {
  if( moving == 1 ) {  // if the robot currently is moving
    stopRobot();       // stop it 
  }
  else {
    moving = 1;        // flag we are going to move
  }
  servoLeft.write(180);
  servoRight.write(180);
}

void turnLeft() {
  if( moving == 1 ) {  // if the robot currently is moving
    stopRobot();       // stop it 
  }
  else {
    moving = 1;        // flag we are going to move
  }
  servoLeft.write(0);
  servoRight.write(0);
}

void unused() {   // Frequency not used at present
  CircuitPlayground.strip.setPixelColor(8,0,0,255); // display a blue light on pixel 8
}

// Tone Generator for the Circuit Playground Simple Robot
// 
// Using a set of buttons, play predetermined tones to control the Circuit Playground simple robot
//
// Mike Barela for Adafruit Industries   September, 2016

const int speakerPin = 11;       // Uno pin 11, Circuit Playground pin 5

// here is where we define the buttons that we'll use. button "0" is the first, button "3" is the 3rd, etc
// uint8_t buttons[] = { 1, 0, 3, 2 };  // for a second Circuit Playground
uint8_t buttons[] = { 4, 3, 6, 5 };     // for Arduino Uno
#define DEBOUNCE 10  // button debouncer, how many ms to debounce, 5  ms is usually plenty
// This handy macro lets us determine how big the array up above is, by checking the size
#define NUMBUTTONS sizeof(buttons) 
// we will track if a button is just pressed, just released, or 'currently pressed' 
int8_t pressed[NUMBUTTONS], justpressed[NUMBUTTONS], justreleased[NUMBUTTONS];

uint16_t notes[] = { 2795, 3250, 3700, 4192 };  // control tones in Hertz

void setup() { 
  uint8_t i;

  pinMode(2, OUTPUT);   // Ground for 
  digitalWrite(2, LOW); //  the 4 button keypad ground (eases wiring on Uno)
  // Make input & enable pull-up resistors on switch pins
  for (i=0; i < NUMBUTTONS; i  ) {
    pinMode(buttons[i], INPUT_PULLUP);  
  }
  pinMode(speakerPin, OUTPUT);  // The piezo speaker pin is set as an output
}

void loop() {
  check_switches();      // when we check the switches, we'll get their current state

  for (uint8_t i = 0; i < NUMBUTTONS; i  ) {  // we check the state of the buttons
    if (pressed[i]) {
      //     digitalWrite(13, HIGH);
      // is the button pressed down at this moment
    }
    if (justreleased[i]) { // on button release . . 
       tone(speakerPin, notes[i], 1000);  // Play the tone assigned to the button for 1 second
    }
  }
  for (uint8_t i=0; i < NUMBUTTONS; i  ) {  // remember, check_switches() will necessitate clearing the 'just pressed' flag
    justpressed[i] = 0;
  }

} 
 
void check_switches()
{
  static int8_t previousstate[NUMBUTTONS];
  static int8_t currentstate[NUMBUTTONS];
  static long lasttime;
  uint8_t index;
 
  if (millis() < lasttime){ // we wrapped around, lets just try again
     lasttime = millis();
  }
  
  if ((lasttime   DEBOUNCE) > millis()) {
    // not enough time has passed to debounce
    return; 
  }
  // ok we have waited DEBOUNCE milliseconds, lets reset the timer
  lasttime = millis();
  
  for (index = 0; index < NUMBUTTONS; index  ){ // when we start, we clear out the "just" indicators
    justreleased[index] = 0;
     
    currentstate[index] = digitalRead(buttons[index]);   // read the button
   
    if (currentstate[index] == previousstate[index]) {
      if ((pressed[index] == LOW) && (currentstate[index] == LOW)) {
          // just pressed
          justpressed[index] = 1;
      }
      else if ((pressed[index] == HIGH) && (currentstate[index] == HIGH)) {
          // just released
          justreleased[index] = 1;
      }
      pressed[index] = !currentstate[index];  // remember, digital HIGH means NOT pressed
    }
    //Serial.println(pressed[index], DEC);
    previousstate[index] = currentstate[index];   // keep a running tally of the buttons
  }
}