Piano de LDRs y función de grabación.

Autores

Introducción

En este blog contaremos los aspectos más importantes en la creación de nuestro proyecto, el cual consiste en un piano implementado mediante LDRs, pues estos percibirán la aparición o ausencia de luz para saber que tecla se está pulsando. Estas notas se reproducirán en un buzzer como se haría en un piano eléctrico. Además, como la placa protoboard es pequeña para que puedan sonar todas las notas en las distintas octavas, existirá la opción de cambiar de octava. También se permitirá al usuario grabar una melodía, reproducirla y eliminarla.

Materiales

Componente	Unidades
Arduino Mega	1
Resistencias 220 ohmnios	22
Resistencia 1k ohmnios	1
Buzzer 5V <25mA	1
LDRs 5516	12
Protoboard	2
Interruptores «Push»	2
Micro-interruptor 8 vías	1

Realización

Al comenzar el proyecto analizamos como queríamos que fuera el circuito, lo esquematizamos y nos pusimos a programarlo. El código de nuestroloop() consta de 4 partes, además de esta función tenemos el setup, donde configuramos los pines como salida o entrada y configuramos el monitor serie, y la declaración de variables.

Al comenzar, verificamos si los botones que implementan las funcionalidades de grabado o reproducción están activados, de esta forma conoceremos que intención de uso tiene el usuario. En la segunda parte calculamos en que octava estamos, asi podremos decidir la frecuencia de las diferentes notas. A continuación leemos los valores de todos los LDRs y calculamos la media, ya que si uno de los valores es bastante inferior a la media, sabremos que el LDR no esta recibiendo luz y por tanto se está pulsado. Finalmente, es en la ultima sección donde leemos qué nota se está pulsando en cada momento, también guardamos la nota si el botón de grabación está activado.

#define buzzer 12                                //Definimos pines de trabajo
#define Boton_Rec 30
#define Boton_Play 31

#define NUMERO_DE_OCTAVAS 7                                           //Definimos el número de octavas
#define TArray 60
int PinesOctavas[NUMERO_DE_OCTAVAS] = {40,41,42,43,44,45,46};        //Definimos los pines de entrada de las octavas
int ValoresOctavas[NUMERO_DE_OCTAVAS] = {0,0,0,0,0,0,0};          //Definimos los valores iniciales de las octavas

#define NUMERO_DE_NOTAS 12                                             //Definimos el número de notas
int PinesLDR[NUMERO_DE_NOTAS] = {A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11};   //Definimos los pines de entrada de los LDR
int LecturasLDR[NUMERO_DE_NOTAS];                  //Definimos un array para almacenar los valores leídos de los LDR

int Grabacion[TArray];

int Frecuencias[NUMERO_DE_NOTAS][NUMERO_DE_OCTAVAS] = {                  //Definimos el valor (en hercios) de las notas
  {33,65,131,262,523,1047,2093},                                             //Valores de DO por cada octava
  {35,69,139,277,554,1109,2217},                                             //Valores de DOS por cada octava
  {37,73,147,294,587,1175,2349},                                             //Valores de RE por cada octava
  {39,78,156,311,622,1245,2489},                                             //Valores de RES por cada octava
  {41,82,165,330,659,1319,2637},                                             //Valores de MI por cada octava
  {44,87,175,349,698,1397,2794},                                             //Valores de FA por cada octava
  {46,93,185,370,740,1480,2960},                                             //Valores de FAS por cada octava
  {49,98,196,392,784,1568,3136},                                             //Valores de SOL por cada octava
  {52,104,208,415,831,1661,3322},                                            //Valores de SOLS por cada octava
  {55,110,220,440,880,1760,3520},                                            //Valores de LA por cada octava
  {58,117,233,466,932,1865,3729},                                            //Valores de LAS por cada octava
  {62,123,247,494,988,1976,3951}                                             //Valores de SI por cada octava
};

#define duracionNota 250                                                     //Definimos la duración de cada nota
int octava; 
int j;
int i;

//string Notas[NUMERO_DE_NOTAS] = { "DO", "DOs", "RE", "REs", "Mi", "FA", "FAs", "SOL", "SOLs", "LA", "LAs", "SI"};
    
   
void setup(){
  pinMode(buzzer, OUTPUT);                                                          //Configuramos el pin de trabajo como una Salida
  for (int i = 0; i < NUMERO_DE_OCTAVAS; i++) {
    pinMode(PinesOctavas[i], INPUT);
  }
  pinMode(Boton_Rec, INPUT);
  pinMode(Boton_Play, INPUT);
  j = 0;
}
  
void loop(){
  
//---------------------------------------------------------------------------------------------------------------//
  if(digitalRead(Boton_Play) == HIGH){
    if (digitalRead(Boton_Rec) == LOW){  
      for (int i = 0; i < j; i++){
        tone(buzzer, Grabacion[i], duracionNota);
        delay(duracionNota);
      }
    }
    else{
      for (int i = 0; i <= j; i++){
        Grabacion[i] = 0;
      }
      j = 0;
    }
  }
//------------------------------------------------------------------------------------------------------------//
  else{
    for (int i = 0; i < NUMERO_DE_OCTAVAS; i++) {                    //Almacenar valores de los pines de las Octavas
      if (digitalRead(PinesOctavas[i]) == LOW){
        ValoresOctavas[i]=0;
      }
      else{
        ValoresOctavas[i]=1;
      }
    }
    
    octava = 0; //Caso inicial
    i = 0;
    while((ValoresOctavas[i] == 1) && (i< NUMERO_DE_OCTAVAS)) {                               //Comprobar la octava
      octava = i+1;
      i++;
    }
    if (octava > 0){        
//------------------------------------------------------------------------------------------------------//
        
        int lecturaMedia = 0;
        for (int i = 0; i < NUMERO_DE_NOTAS; i++) {                                      //Lectura valores LDR
          LecturasLDR[i] = analogRead(PinesLDR[i]);
          lecturaMedia += LecturasLDR[i];
          };
        
        lecturaMedia /= NUMERO_DE_NOTAS;
        
          int lecturaCalculo = lecturaMedia/2;
//--------------------------------------------------------------------------------------------------------------------------------//
          i = 0;
          while (i < NUMERO_DE_NOTAS) {
            if(lecturaCalculo > LecturasLDR[i]){                         //Comprobación de la luz que incide a cada LDR
              tone(buzzer, Frecuencias[i][octava-1], duracionNota);
              if ((digitalRead(Boton_Rec) == HIGH) && (j < TArray)){
                Grabacion[j] = Frecuencias[i][octava-1];
                j++;
                }
              i=NUMERO_DE_NOTAS;
            }
            i++;  
         }
       }
       delay(200);
    
  }
}

Imágenes del proyecto finalizado

Este seria el teclado de LDRs con 12 notas que se corresponderían a las notas que se repiten en el piano, pero en un piano convencional cada 12 notas cambia la octava.

Para que el consumidor pueda cambiar de octava instalamos un micro-interruptor de 8 vías, con el que pueda seleccionarla.

La ultima funcionalidad instalada fue la de poder grabar, reproducir y resetear la música guardada, para esto usamos dos interruptores cuyos valores conjuntos darán lugar a las distintas funcionalidades.

Botón de Reproducción	Botón de Grabación	Acción
0	0	El piano funciona con normalidad
0	1	Se ejecuta la funcionalidad de grabado
1	0	Se ejecuta la funcionalidad de reproducción
1	1	Se borra la grabación

Este es el resultado final del piano con todo conectado correctamente.