/**
$10 Drum machine (sequencer)

Jun 09 By A. Stein
Released under GPL v3

Description:
Simple sequencer machine which uses Capacitative Sensing Code for Arduinos.  This is a combination drumpad and sequencer.  
It has just two modes, record, and playback, and needs very few components; just 3 resistors and a piezo speaker.  
If you're feeling decadent, you can add an LED (with a resistor) for more "ooomph".

Full info at corticalcafe.com

**/


//some definitions
#define NOBUTTON_VAL  0
#define BUTTON1_VAL  1
#define BUTTON2_VAL  2
#define BUTTON3_VAL  3

#define MAXSAMPS  500  //max number of samples


//variable declarations
int capSenseThresh=5;    //initial cap sense threshold.  Will be changed on first call to initCapSensor.

//set pins
int button1Pin=8;      //drum pad pin definitions
int button2Pin=7;
int button3Pin=6;
int buttonGndPin=2;    //common gnd for all buttons, connect a 1M ohm resistor from here to each button in use

int ledPin=4;         //LED pin
int piezoPin=3;        //speaker pin

char beat[MAXSAMPS];    //store our data here

int  sampRate=10;  //sample rate (msec)
int  numSamps=MAXSAMPS;  //number of currently stored samples
int  freqs[]={2093, 2794, 3136};    //frequencies for the drum pads (check freq out to choose nice ones, like C, F, and G


//our obligatory setup routine
void setup() {
  flashLED(ledPin, 1);
//  beepPiezo(piezoPin, 1);
  initCapSensor(buttonGndPin, button1Pin);    //at the sketch start, initialize on an untouched button
  flashLED(ledPin, 1);  
//  beepPiezo(piezoPin, 1);
  Serial.begin(9600);
}


//our obligatory main routine
void loop () {
  long tmpTime;
  
  flashLED(ledPin, 3);
  playTone(3000, 100);    //tell user we're recording
  
  tmpTime=millis();
  recordSamples();
  tmpTime=millis()-tmpTime;
  Serial.print("Recording Time: ");
  Serial.print(tmpTime,DEC);
  Serial.print(" ms.\n");

  numSamps=getNumSamples();    //find where stored samples end (and loop repeats)
  printSamples();          //visualize samples
  modMedianFilter();      //filter
  printSamples();        //visualize samples
  
  
  Serial.print("Num Samples: ");
  Serial.print(numSamps, DEC);  
  Serial.println();


  do{
    tmpTime=millis();
    playSamples();
    tmpTime=millis()-tmpTime;
    Serial.print("Play Time: ");
    Serial.print(tmpTime,DEC);
    Serial.print(" ms.\n");
  } while(getButtonTouched()==NOBUTTON_VAL);    
            //loop playback until user is ready to record again
  
}


/**
returns the value of the button which was touched.  Assumes only 1 sensor is touched at a time.
**/
int getButtonTouched(){
  if(getTouched(getRawCapSense(buttonGndPin, button1Pin)))
    return(BUTTON1_VAL);
  else
  if(getTouched(getRawCapSense(buttonGndPin, button2Pin)))
    return(BUTTON2_VAL);
  else
  if(getTouched(getRawCapSense(buttonGndPin, button3Pin)))
    return(BUTTON3_VAL);
  else
    return(NOBUTTON_VAL);
  }
  


/*
record samples from touch pads
*/
void recordSamples(){
  long time;
  Serial.print("Recording...\t");

  //don't start recording until a button is pressed
  while(getButtonTouched()==NOBUTTON_VAL)    
  {
    delay(10);
  }

  for(int i=0;i<MAXSAMPS;i++)
  {
    time=millis();
  
    int buttonPressed=getButtonTouched();
    
    switch(buttonPressed)
    {
      case BUTTON1_VAL:
        digitalWrite(ledPin, HIGH);      //and change LED appropriately
        beat[i]=BUTTON1_VAL;            //save beat;
        break;
        
      case BUTTON2_VAL:
        digitalWrite(ledPin, HIGH);      //and change LED appropriately
        beat[i]=BUTTON2_VAL;            //save beat;
        break;
        
      case BUTTON3_VAL:
        digitalWrite(ledPin, HIGH);      //and change LED appropriately
        beat[i]=BUTTON3_VAL;            //save beat;
        break;
        
      case NOBUTTON_VAL:
        digitalWrite(ledPin, LOW);
        beat[i]=NOBUTTON_VAL;            //save no beat
        break;
    }

    time=millis()-time;      //get delta t
        
    
    delay(sampRate-time);    //wait until we're at a sample point again
  }
    Serial.print("Finished.");
    Serial.println();
}  


/**
Finds and returns last sample.
This is the point at which the user wants the track to repeat, so this routine
finds the last sample, and then walks backwards to find the end of the last stretch of silence. 
**/
int getNumSamples(){
  int retVal=1;
  int i;
  
  //find last nonzero sample (point where user wants tape to repeat)
  for(i=0; i<MAXSAMPS; i++)    
  {
    if(beat[i]!=NOBUTTON_VAL) retVal=i;
  }
  
  //and then back up until we find last zero sample
  do        
  {
    retVal--;
  } while (beat[retVal]!=NOBUTTON_VAL);
  
  return(retVal);
}



/**
Print the stored sample pattern
**/
void printSamples(){
  int retVal=1;
  
  for(int i=0; i<numSamps; i++)
  {
    switch(beat[i])
    {
      case BUTTON1_VAL:
        Serial.print("1");
        break;
        
      case BUTTON2_VAL:
        Serial.print("2");
        break;
        
      case BUTTON3_VAL:
        Serial.print("3");
        break;
        
      case NOBUTTON_VAL:
        Serial.print("_");
        break;
    }
  }
  
  Serial.println();
  }



/**
Modified median filter cleans up touch switch bounce.  Works by using a [1, 0, 1] sliding kernel
**/
void modMedianFilter(){
  int retVal=1;
  int medVals[]={BUTTON1_VAL, BUTTON2_VAL, BUTTON3_VAL, NOBUTTON_VAL};    //we want to check 0 *last*
  int numVals=4;
  
  for(int i=1; i<numSamps; i++)
  {
    for(int j=0; j<numVals; j++)
    {
      if(beat[i-1]==medVals[j])
      {
        if(beat[i+1]==medVals[j])
            beat[i]=medVals[j];
      }
    }
  }
  
}




/**
play samples back via LED and speaker
**/
void playSamples(){

  long time;
  int i, j;
  int tone;
  
  for(i=0;i<numSamps;i++)
  {
    time=millis();
  
    if(beat[i]!=NOBUTTON_VAL)    //sense if button is touched
    {
      
      //find out how many of the next samples are also nozero (assumes they are same value)
      j=0;
      while(beat[i+j]!=NOBUTTON_VAL)    
      {
        j++;
      }
      
      digitalWrite(ledPin, HIGH);      //and change LED appropriately

      time=millis()-time;      //get delta t
      
      tone=freqs[beat[i]-1];      //get tone from look up table
        
      playTone(tone, (((j+1)*sampRate)-time));    //play a tone from now until the end of this stretch of values
      
      i+=j;              //increment i to skip the rest of the samples at this value in this stretch
    }
    else
    {
      digitalWrite(ledPin, LOW);
 
      time=millis()-time;      //get delta t
      delay(sampRate-time);    //wait until we're on a sample
    }
  }
}  



/**
flash LED to let user know we're up to something
**/
void flashLED(int pin, int numFlashes){
  int onDly=100;
  int offDly=100;
  
  for(int i=0; i<numFlashes; i++){
    digitalWrite(pin, HIGH);      //LED on
    delay(onDly);
    digitalWrite(pin, LOW);      //LED off
    delay(offDly);
  }
}


/**
beep piezo to let user know we're up to something
**/
void beepPiezo(int pin, int numBeeps){
  int onDly=100;
  
  for(int i=0; i<numBeeps; i++){
    playTone(2000, 100);      //beep
    delay(onDly);              //pause
  }
}




/**
Play tone; freq in hz, t in ms
Original function by Paul Badger

FYI, here are note values for an octave scale
Divide or multiply them by powers of two to generate other octaves

float A     = 14080;
float AS    = 14917.2;
float B     = 15804.3;
float C     = 16744;
float CS    = 17739.7;
float D     = 18794.5;
float DS    = 19912.1;
float E     = 21096.2;
float F     = 22350.6;
float FS    = 23679.6;
float G     = 25087.7;
float GS    = 26579.5;


**/
void playTone(int freq, int t)  
{
  int hperiod;                               //calculate 1/2 period in us
  long cycles, i;
  pinMode(piezoPin, OUTPUT);                   // turn on output pin

  hperiod = (500000 / freq) - 7;             // subtract 7 us to make up for digitalWrite overhead

  cycles = ((long)freq * (long)t) / 1000;    // calculate cycles
 // Serial.print(freq);
 // Serial.print((char)9);                   // ascii 9 is tab - you have to coerce it to a char to work 
 // Serial.print(hperiod);
 // Serial.print((char)9);
 // Serial.println(cycles);

  for (i=0; i<= cycles; i++){              // play note for t ms 
    digitalWrite(piezoPin, HIGH); 
    delayMicroseconds(hperiod);
    digitalWrite(piezoPin, LOW); 
    delayMicroseconds(hperiod - 1);     // - 1 to make up for digitaWrite overhead
  }
  pinMode(piezoPin, INPUT);                // shut off pin to avoid noise from other operations
}




/*
Function to do binary evaluation of whether capacitive button has been pressed.
Takes rawCapSense value as input.
*/
boolean getTouched(int capVal) {
    return(capVal>=capSenseThresh);
}
  



/*
Sets capSenseThresh with a reasonable value by 
averaging a handful of rawCapSense values.  The 
button should be UNTOUCHED when this routine is running
(usually at the sketch start).
*/
void initCapSensor(int txPin, int rxPin) {
  int tmpCap=0;
  int numSamples=10;
  
  for (int i=0; i<numSamples; i++){
    tmpCap+=getRawCapSense(txPin, rxPin);
    delay(100);
  }
  
  capSenseThresh=tmpCap/(float)numSamples;
  capSenseThresh+=2;    //add a small margin;
}



/*
Get capacitive sensor value.  Requires 2 pins, connected by a 1M ohm resister.  
The Arduino should have a good ground, or at least the user and Arduino should share a common ground.
Because this routine times the RC discharge with variable capacitance (the user), it takes variable lengths of time.
*/
int  getRawCapSense(int txPin, int rxPin) {
  int delayVal=10;              //delay for RC charge/discharge
  int maxLoop=250;            //max timing delay before we return
  int curLoop=0;
  int retVal=0; 


  //set pin states
  pinMode(txPin, OUTPUT);     
  pinMode(rxPin, INPUT); 
    
  //send signal on TX pin
  digitalWrite(txPin, LOW);

  //time how long it takes to detect change at RX
  //with no load, it should happen quickly, but if touched, the RC will take longer to charge)
 do
 {
   curLoop++;
 }
 while (digitalRead(rxPin)==HIGH and curLoop<maxLoop);

 retVal=curLoop;
 curLoop=0;

  //now do it in reverse direction, in case RX pin is biased high or low
  //send signal on TX pin
 digitalWrite(txPin, HIGH);

  //time how long it takes to detect change at RX
  //with no load, it should happen quickly, but if touched, the RC will take longer to charge)
 do
 {
   curLoop++;
 }
 while (digitalRead(rxPin)==LOW and curLoop<maxLoop);

 retVal+=curLoop;
  
 return(retVal);    //return sum of how long it took for pin to change state both ways
}