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

Autores

Grupo 10

Lucía Rodríguez Santamaría
Víctor Jiménez López
Adrián Puyo Olías
Rubén Barrajón Sanz

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 Mega1
Resistencias 220 ohmnios22
Resistencia 1k ohmnios1
Buzzer 5V <25mA1
LDRs 551612
Protoboard2
Interruptores “Push”2
Micro-interruptor 8 vías1

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.

Placa protoboard con los LDRs conectados de forma que simulen 12 teclas de un piano y esta imagen tiene la funcion de mostrar como seria el montaje de las notas.
Notas en nuestro piano
12 teclas de un piano convencional con las notas correspondientes y esta imagen solo sirve de comparación con la anterior.
Notas en un teclado convencional

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

Micro-interruptor de 8 vías conectado a la placa protoboard para la codificación de octavas.
Micro-interruptor para octavas

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ónBotón de GrabaciónAcción
00El piano funciona con normalidad
01Se ejecuta la funcionalidad de grabado
10Se ejecuta la funcionalidad de reproducción
11Se borra la grabación

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

Piano completo, teniendo dos placas protoboard, una conlos LDRs, buzzer y interruptores, y otra con el micro-interruptor para octavas, ambas placas conectadas al Arduino MEGA
Piano final

También te podría gustar...

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *