////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  Tune me & I Play you Bach – Arduino Bach player with user defined tuning – tlachinolliatl@gmai.com /////
//  Visit our life Blog at:                                                                            /////   
//                         http://www.atl.travel.blog                                                         ///// 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// The inspiration behind this code was to hear the differences in equal temperament tuning  varying the value of the key note A4   ////
// standardly tuned at 440 Hz with some controversy about better harmonic generation with 432 cicles per second (Hz).               ////
//  Overall, there was a tendency towards the end of the 18th century for the frequency of the A above middle C to be in the range  ////
// of 400 to about 450 Hz.                                                                                                          ////  
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// change following value for tuning the scale
double la4 = 400; // checar como puede modificar este valor el usuario durante ejecución
//recomendación: definir los tiempos, h de half: d, w, h, q
int h=250; // aquí solo se definió h, ya que para esta melodía no habrá variación de tiempo en las notas.
// cent function recieves number of cents n and returns proportion factor to use it in tuneScale function to create user tuned scale
double centFactor(int n){
    double proportion;
    double power;
    power = (double)n/12; // por no hacer el casting todo valía nepe
    proportion = pow(2, power);
    return proportion;
  }
// The Tune function
double * tuneScale(double la4){
    static double  scale[12]; // arreglo para guardar las notas generadas
    // a partir de middleA podemos obtener Do de una octava mas arriba, que es la que utilizaremos
    // por medio de la siguiente formula de Cents, introducida por Alexander Ellis en 1875
    // b = a*2^(n/1200) 
    // se obtiene cualquier nota b por medio de la nota a y el numero n de cents en el intervalo de a hasta b
    double do5;
    do5 = la4*centFactor(3);
    for (int i = 0; i < 12; i++) {
      scale[i] = do5*centFactor(i);
   }
  return scale;
  }
double * scale = tuneScale(la4); // creation of the scale from tuneScale function and predefined la4
double  C = scale[0], //definimos las frecuencias de las notas
        Cs = scale[1],
        D = scale[2],
        Ds = scale[3],
        E = scale[4],
        F = scale[5],
        Fs = scale[6],
        G = scale[7],   
        Gs = scale[8],
        A = scale[9],
        As = scale[10],
        B = scale[11], 
        PAU = 30000; //pausa

int random_tonal_row, random_note = 0;        
// array of 15 tonal rows consisting of 16 notes each
double melody[15][16] = { // consider array as [number of melody rows][number of notes on each melody row]

  // The Well-Tempered Clavier, BWV 846: Prelude No. 1 in C major (Fragment)

                   { C/2, E/2, G/2, C, E, G/2, C, E, C/2, E/2, G/2, C, E, G/2, C, E },
                   
                   { C/2, D/2, A/2, D, F,  A/2, D, F, C/2, D/2, A/2, D, F,  A/2, D, F },
                   
                   { B/4, D/2, G/2, D, F, G/2, D, F, B/4, D/2, G/2, D, F, G/2, D, F },
                   
                   { C/2, E/2, G/2, C, E, G/2, C, E, C/2, E/2, G/2, C, E, G/2, C, E} ,

                   { C/2 , E/2 , A/2 , E, A, A/2, E, A, C/2 , E/2 , A/2 , E, A, A/2, E, A },

                   { C/2, D/2, Fs/2, A/2, D, Fs/2, A/2, D, C/2, D/2, Fs/2, A/2, D, Fs/2, A/2, D },

                   { B/4, D/2, G/2, D, G, G/2, B/2, G, B/4, D/2, G/2, D, G, G/2, B/2, G },

                   { B/4, C/2, E/2, G/2, C, E/2, G/2, C, B/4, C/2, E/2, G/2, C, E/2, G/2, C },

                   { A/4, C/2, E/2, G/2, C, E/2, G/2, C, A/4, C/2, E/2, G/2, C, E/2, G/2, C },

                   { Fs/4, A/4, D/2, A/2, C, D/2, A/2, C, Fs/4, A/4, D/2, A/2, C, D/2, A/2, C },

                   { G/4, B/4, D/2, G/2, B/2, D/2, G/2, B/2, G/4, B/4, D/2, G/2, B/2, D/2, G/2, B/2 },

                   { G/4, As/4, E/2, G/2, Cs, E/2, G/2, Cs, G/4, As/4, E/2, G/2, Cs, E/2, G/2, Cs },
                     
                   { F/4, A/4, D/2, A/2, D, D/2, A/2, D, F/4, A/4, D/2, A/2, D, D/2, A/2, D }, 

                   { F/4, D/2, F/2, Gs/2, B/2, F/2, Gs/2, B/2, F/4, D/2, F/2, Gs/2, B/2, F/2, Gs/2, B/2 },

                   { E/4, C/2, E/2, G/2, C, E/2, G/2, C, E/4, C/2, E/2, G/2, C, E/2, G/2, C }
                   
                   };

void setup() {
  // put your setup code here, to run once:
  pinMode(11, OUTPUT); // fija pin 11 como salida
  Serial.begin(9600); //for freakin' printin'
}

void loop() {
  for (int i = 0; i < 15; i++) {  
    //random_tonal_row = random(0,15); // definimos renglon tonal de manera aleatoria. Para random(min,max) el mínimo es inclusivo mientras el maximo es exlcusivo
    Serial.println();
     // imprimimos en serial para rescatar posibles combincaciones interesantes al utilizar random
    //Serial.print(":");
      for(int j = 0 ; j < 16; j++){
        Serial.print(melody[i][j]);
        //random_note = random(0,17); // 17 no existe es para agregar posible pausa
        //Serial.print(random_note);
        Serial.print("\t"); // tabulador para distinguir renglones tonales de mas de dos digitos
        tone(11, melody[i][j]); //da el tono a la frecuencia de la nota del ciclo, le pasamos el renglon tonal aleatorio para las 16 notas o podemos pasarle también random note.
        delay(h);//se mantiene con la nota el tiempo definido, para tiempos mas complejos se puede hacer un arreglo similar a melody
        noTone(11); //finaliza la nota
      }
  }
  //Serial.println();
}