#define timbre 2  //Asignamos a "timbre" el valor 2. El timbre se conecta en el pin 2.
#define LDo1 4  //Asignamos a "LDo1" el valor 4. El timbre se conecta en el pin 4.
#define LRe 5  //Asignamos a "LRe" el valor 5. El timbre se conecta en el pin 5.
#define LMi 6  //Asignamos a "LMi" el valor 6. El timbre se conecta en el pin 6.
#define LFa 8  //Asignamos a "LFa" el valor 8. El timbre se conecta en el pin 8.
#define LSol 10  //Asignamos a "LSol" el valor 10. El timbre se conecta en el pin 10.
#define LLa 11  //Asignamos a "LLa" el valor 11. El timbre se conecta en el pin 11.
#define LSi 12  //Asignamos a "LSi" el valor 12. El timbre se conecta en el pin 12.
#define LDo2 13  //Asignamos a "LDo2" el valor 13. El timbre se conecta en el pin 13.

const float FDo1 = 261.63; //Constante racional que indica la frecuencia a la que sonará la nota Do1
const float FRe = 293.66; //Constante racional que indica la frecuencia a la que sonará la nota Re
const float FMi = 329.63; //Constante racional que indica la frecuencia a la que sonará la nota Mi
const float FFa = 349.23; //Constante racional que indica la frecuencia a la que sonará la nota Fa
const float FSol = 392.00; //Constante racional que indica la frecuencia a la que sonará la nota Sol
const float FLa = 440.00; //Constante racional que indica la frecuencia a la que sonará la nota La
const float FSi = 493.88; //Constante racional que indica la frecuencia a la que sonará la nota Si
const float FDo2 = 523.63; //Constante racional que indica la frecuencia a la que sonará la nota Do2

const int n = 300;  //Duración en milisegundos de las notas negras
const int b = n*2;  //Duración en milisegundos de las notas blancas, relativo al valor de una negra
const int r = n*4;  //Duración en milisegundos de las notas redonda, relativo al valor de una negra
const int c = n/2;  //Duración en milisegundos de las notas  corchea, relativo al valor de una negra
const int s = n/4;  //Duración en milisegundos de las notas  semicorchea, relativo al valor de una negra
const int cp = 3*n/4;  //Duración en milisegundos de las notas  semicorchea con puntillo, relativo al valor de una negra
const int z =75;  //Milisegundos que se apaga antes la luz que termine de sonar una nota

//En función de la partitura la duración de la nota referencia puede cambiar: tempo

const int n1=2*n;  //Duración en milisegundos de las notas negras
const int b1 = n1*2;  //Duración en milisegundos de las notas blancas, relativo al valor de una negra
const int r1 = n1*4;  //Duración en milisegundos de las notas redonda, relativo al valor de una negra
const int c1 = n1/2;  //Duración en milisegundos de las notas  corchea, relativo al valor de una negra
const int s1 = n1/4;  //Duración en milisegundos de las notas  semicorchea, relativo al valor de una negra
const int cp1 = 3*n1/4;  //Duración en milisegundos de las notas  semicorchea con puntillo, relativo al valor de una negra

void setup() 
{
 //Indicamos al programa qué pines vamos a usar y si son de salida o de entrada de información
 pinMode(timbre,OUTPUT);
 pinMode(LDo1,OUTPUT);
 pinMode(LRe,OUTPUT);
 pinMode(LMi,OUTPUT);
 pinMode(LFa,OUTPUT);
 pinMode(LSol,OUTPUT);
 pinMode(LLa,OUTPUT);
 pinMode(LSi,OUTPUT);
 pinMode(LDo2,OUTPUT);
}

void loop() 
{
cancion1(); //suena la canción 1
luces();  //encendemos de forma progresiva todas las luces
cancion2(); //suena la canción 3
luces();  //encendemos de forma progresiva todas las luces
}

/* 
Se va a programar cada nota, es decir, la frecuencia a la que va a sonar y el tiempo que va a estar sonando, y el led
que se va a enceder y el tiempo que va a estar encendido
Esta función requiere de un valor "t", que corresponde con la duración de la nota, es decir, el timepo que va a estar sonando
*/ 

void Do1(int t)
{
  tone(timbre,FDo1); //Comienza a sonar la nota Do1 a la frecuencia fijada
  digitalWrite(LDo1,HIGH); //se enciende el led correspondiente al Do1
  delay(t-z); //Permanece encendido t-z milisegundos
  digitalWrite(LDo1,LOW); //Se apaga el led correspondiente al Do1
  delay(z); //permanece apagado el led z milisegundos
  noTone(timbre); //se apaga el sonido. Ha a estado sonando n milisegundos
}
void Re(int t)
{
  tone(timbre,FRe);
  digitalWrite(LRe,HIGH);
  delay(t-z);
  digitalWrite(LRe,LOW);
  delay(z);
  noTone(timbre);
}
void Mi(int t)
{
  tone(timbre,FMi);
  digitalWrite(LMi,HIGH);
  delay(t-z);
  digitalWrite(LMi,LOW);
  delay(z);
  noTone(timbre);
}
void Fa(int t)
{
  tone(timbre,FFa);
  digitalWrite(LFa,HIGH);
  delay(t-z);
  digitalWrite(LFa,LOW);
  delay(z);
  noTone(timbre);
}
void Sol(int t)
{
  tone(timbre,FSol);
  digitalWrite(LSol,HIGH);
  delay(t-z);
  digitalWrite(LSol,LOW);
  delay(z);
  noTone(timbre);
}
void La(int t)
{
  tone(timbre,FLa);
  digitalWrite(LLa,HIGH);
  delay(t-z);
  digitalWrite(LLa,LOW);
  delay(z);  
  noTone(timbre);
}
void Si(int t)
{
  tone(timbre,FSi);
  digitalWrite(LSi,HIGH);
  delay(t-z);
  digitalWrite(LSi,LOW);
  delay(z);
  noTone(timbre);
}
void Do2(int t)
{
  tone(timbre,FDo2);
  digitalWrite(LDo2,HIGH);
  delay(t-z);
  digitalWrite(LDo2,LOW);
  delay(z);
  noTone(timbre);
}

/*
Una vez programas todas las notas, programaremos las canciones, que hacen uso de las notas ya programadas.
Tendremos que indicar qué nota va a sonar y si esta nota es una negra, blanca, redonda,... es decir, la duración
de la nota
*/

void cancion1()
{
 Mi(n);
 Mi(n);
 Mi(b);
 Mi(n);
 Mi(n);
 Mi(b);
 Mi(n);
 Sol(n);
 Do1(n);
 Re(n);
 Mi(r);
 Fa(n);
 Fa(n);
 Fa(b);
 Fa(n);
 Mi(n);
 Mi(b);
 Mi(n);
 Re(n);
 Re(n);
 Mi(n);
 Re(b);
 Sol(b);
 Mi(n);
 Mi(n);
 Mi(b);
 Mi(n);
 Mi(n);
 Mi(b);
 Mi(n);
 Sol(n);
 Do1(n);
 Re(n);
 Mi(r);
 Fa(n);
 Fa(n);
 Fa(b);
 Fa(n);
 Mi(n);
 Mi(b);
 Sol(n);
 Sol(n);
 Fa(n);
 Re(n);
 Do1(r);
}

void cancion2()
{
  Do2(n1);
  Si(cp1);
  La(s1);
  Sol(n1);
  delay(c1);
  Fa(c1);
  Mi(n1);
  Re(n1);
  Do1(n1);
  delay(c1);
  Sol(c1);
  La(n1);
  delay(c1);
  La(c1);
  Si(n1);
  delay(c1);
  Si(c1);
  Do2(n1);
  delay(c1);
  Do2(c1);
  Do2(c1);
  Si(c1);
  La(c1);
  Sol(c1);
  Sol(cp1);
  Fa(s1);
  Mi(c1);
  Do2(c1);
  Do2(c1);
  Si(c1);
  La(c1);
  Sol(c1);
  Sol(cp1);
  Fa(s1);
  Mi(c1);
  Mi(c1);
  Mi(c1);
  Mi(c1);
  Mi(c1);
  Mi(s1);
  Fa(s1);
  Sol(n1);
  delay(c1);
  Fa(s1);
  Mi(s1);
  Re(c1);
  Re(c1);
  Re(c1);
  Re(s1);
  Mi(s1);
  Fa(n1);
  delay(c1);
  Mi(s1);
  Re(s1);
  Do1(c1);
  Do2(c1);
  delay(c1);
  La(c1);
  Sol(cp1);
  Fa(s1);
  Mi(c1);
  Fa(c1);
  Mi(n1);
  Re(n1);
  Do1(b1);  
}

//Ahora programemos el juego de luces que que se va a mostrar entre canción y canción.

void luces()
{
  digitalWrite(LDo1,HIGH);
  delay(100);
  digitalWrite(LRe,HIGH);
  delay(100);
  digitalWrite(LMi,HIGH);
  delay(100);
  digitalWrite(LFa,HIGH);
  delay(100);
  digitalWrite(LSol,HIGH);
  delay(100);
  digitalWrite(LLa,HIGH);
  delay(100);
  digitalWrite(LSi,HIGH);
  delay(100);
  digitalWrite(LDo2,HIGH);
  delay(100);
  delay(2000);
  digitalWrite(LDo1,LOW);
  digitalWrite(LRe,LOW);
  digitalWrite(LMi,LOW);
  digitalWrite(LFa,LOW);
  digitalWrite(LSol,LOW);
  digitalWrite(LLa,LOW);
  digitalWrite(LSi,LOW);
  digitalWrite(LDo2,LOW);
  delay(500);
}