Piano Electrónico

Autores: Iker Pizarro Fernández y Brais Cabo Felpete

Grupo 6 – 2023/2024

Introducción

La historia del piano lo sitúa como uno de los instrumentos más icónicos y relevantes de la humanidad, a pesar de ser relativamente moderno en su creación. Con una riqueza tonal sin igual y una versatilidad incomparable, su evolución se ha potenciado con la llegada de los teclados electrónicos, capaces no solo de emular su sonido tradicional, sino también de incorporar una amplia gama de sonidos de otros instrumentos.

Inicialmente, concebimos la idea de desarrollar un teclado electrónico compacto de una octava, con capacidad para alternar entre diferentes instrumentos. Sin embargo, para añadir mayor complejidad y originalidad al proyecto, decidimos expandir su funcionalidad. Así, nuestra propuesta consiste en llevar la experiencia de un teclado digital a un sistema empotrado de reducido tamaño, pero con características distintivas.

Introducimos la capacidad no solo de cambiar entre diferentes instrumentos, sino también de variar los tonos en los que se representan dichos instrumentos. Estos tonos e instrumentos pueden ser añadidos al sistema mediante archivos almacenados en una tarjeta SD, brindando flexibilidad para personalizar la experiencia musical. Además, implementamos un modo adicional llamado «Reproducción de Archivos de Audio», que permite reproducir archivos de audio almacenados en la tarjeta SD, complementando la funcionalidad de representación de instrumentos.

Para la realización de este proyecto, hemos utilizado diversos componentes, entre los que destacan el Arduino Mega, el lector de tarjetas SD, altavoces y una pantalla LCD.

A lo largo de este informe, detallaremos cada una de las partes que conforman el proyecto, abarcando tanto el hardware como el software responsable de su funcionamiento, así como los desafíos enfrentados durante su desarrollo y la distribución de tareas entre el equipo. Además, se presentarán algunas ideas adicionales que surgieron durante el proceso y que podrían ser implementadas en futuras iteraciones del proyecto.

Desarrollo e implementación

Para desarrollar la totalidad del proyecto, recurrimos a una implementación incremental, en la que íbamos realizando pequeños avances, incluyendo funcionalidades y probando que todo funcionara satisfactoriamente, hasta que logramos una versión final completamente funcional.

Los pasos seguidos para implementar el piano han sido los siguientes:

• Selección del hardware:  Lo primero que hicimos fue reunirnos y buscar información sobre los componentes que íbamos a necesitar para implementar la idea que teníamos en mente. En un principio pensábamos que los archivos de audio podrían estar almacenados en el ordenador conectado a la placa pero pronto descubrimos que esto no era así y que tendríamos que utilizar un lector de tarjetas SD. También nos dimos cuenta de que no íbamos a poder utilizar una placa Arduino Uno ya que necesitábamos una gran cantidad de pines disponibles en la placa. Recabando información descubrimos que una Arduino Mega serviría para realizar el trabajo que nos propusimos.

• Detectar la pulsación de un botón: El primer paso que dimos una vez ya habíamos elegido el hardware fue conectar un botón a la placa para comprobar que esta funcionara correctamente.

• Botones y lógica para las 12 notas musicales: Posteriormente, conectamos todos los botones relativos a las notas musicales y realizamos la lógica para detectar el botón que estaba siendo pulsado sin necesidad de introducir una condición para cada botón. En este punto nos dimos cuenta de que conllevaba demasiado esfuerzo conectar los 12 botones junto con las resistencias, las tomas al positivo, al negativo, y al PIN de la placa correspondiente. Aquí descubrimos el modo INPUT_PULL_UP de las placas arduino con el que solo es necesario conectar el botón al GND y al pin correspondiente para que se detecte la pulsación.

• Botones y lógica para cambio de instrumento y tono: En este paso conectamos los 4 botones, 2 para cambiar de instrumento y 2 para cambiar de tono, necesarios para poder realizar las funcionalidades que deseábamos. También creamos él código correspondiente, reutilizando el código ya que la lógica para cambiar de tono y de instrumento es muy parecida por lo que evitamos la duplicación de código.

• Conexión de tarjeta SD: Fue en este paso cuando recibimos el lector de tarjetas SD, por lo que la conectamos a la placa. Una vez hechas las conexiones y habiendo comprobado que funcionaba el lector correctamente pensamos que sería una buena idea que los instrumentos se cargaran directamente de la tarjeta SD con sus correspondientes tonos en lugar de estar fijados en el código. Más adelante, creamos la lógica para que la información se cargue de esta forma en el arranque del proyecto leyendo los directorios de la tarjeta SD.

• Conexión altavoz: Acto seguido, conectamos el altavoz a la placa e implementamos la lógica para que las notas pulsadas emitieran el sonido correspondiente por el altavoz. Para ello, utilizamos la librería TMRpcm que permite reproducir archivos .wav presentes en la tarjeta SD.

• Amplificación del sonido del altavoz: En este punto, comprobamos que el sonido emitido por el altavoz tenía un volumen casi inaudible. Buscando por internet encontramos la forma de construir un amplificador de sonido con un transistor NPN, por lo que reconectamos el altavoz amplificando su sonido.

• Conexión pantalla LCD: Hasta este momento, todas las salidas de información se mostraban por el serial. Fue en este paso cuando conectamos la pantalla LCD para mostrar la información de instrumento y tono seleccionados, así como que en el arranque del dispositivo muestre la cantidad de instrumentos encontrados en la tarjeta SD.

• Creación del modo de reproducción de archivos: En este paso, pensamos en posibles mejoras para el proyecto. Fue cuando tuvimos la idea de crear un modo “Reproductor de música” que permite reproducir archivos de la tarjeta SD sin la necesidad de que estén ligados a una nota de un instrumento. Para esto creamos un modo que escanea los archivos presentes en la SD y permite ir navegando entre los mismos, de forma que se pueda reproducir el seleccionado, así como pausar el que se está reproduciendo en ese momento o reanudar la reproducción si hay algún archivo pausado. También incluimos un botón para cambiar entre los modos.

• Construcción del artefacto: En este paso, construimos la caja para introducir todos los elementos electrónicos, así como el mecanismo de pulsado de teclas.

• Empaquetado: Este fue el último paso del desarrollo. En él empaquetamos los componentes electrónicos en la caja construida y adecuamos los botones a las teclas del piano.

Hardware

Para el desarrollo de este proyecto, hemos necesitado un microcontrolador Arduino Mega, un lector de tarjetas SD, un altavoz de 3 W compatible con Arduino, 19 botones, una pantalla LCD 16 X 02 y cables para realizar las conexiones.

La necesidad de utilizar un Arduino Mega en lugar de un Arduino Uno es debido a la gran cantidad de pines digitales que requería nuestro proyecto.

Imagen representativa del hardware utilizado realizada con el diseñador Fritzing. En el hardware real hemos conectado los botones a una mini protoboard y con cables a las teclas pero consideramos que este diseño es más legible y las conexiones representadas son equivalentes.

Software

Respecto al software del proyecto, cabe destacar que hemos intentado modularizar el código lo máximo posible, así como evitar la repetición favoreciendo la reutilización. También cabe mencionar que hemos utilizado cuatro librerías externas para facilitar el desarrollo:

• SD: Esta librería se ha utilizado para leer y manejar los archivos de la tarjeta SD.

• TMRpcm: El uso de esta librería es el de reproducir archivos de audio presentes en la tarjeta SD.

• LinkedList: Esta librería sirve para tener una implementación de una lista para simplificar el trabajo con varios datos.

• LiquidCrystal: El uso de esta librería está dedicado al control de la pantalla LCD.

Código

#include <LiquidCrystal.h>
#include <SPI.h>
#include <SD.h>
#include <LinkedList.h>
#include <TMRpcm.h>

TMRpcm audio;
boolean playingAudio = false;

int D7_pin = 7;
int D6_pin = 6;
int D5_pin = 5;
int D4_pin = 4;
int EN_pin = 10;
int RS_pin = 12;
LiquidCrystal lcd(RS_pin, EN_pin, D4_pin, D5_pin, D6_pin, D7_pin);

const int CS_PIN = 53;

const int PIN_DO = 22;
const int PIN_DO_S = 24;
const int PIN_RE = 26;
const int PIN_RE_S = 28;
const int PIN_MI = 30;
const int PIN_FA = 32;
const int PIN_FA_S = 34;
const int PIN_SOL = 36;
const int PIN_SOL_S = 38;
const int PIN_LA = 40;
const int PIN_LA_S = 42;
const int PIN_SI = 44;
const int PIN_NEXT_MELODY = 46;
const int PIN_PREVIOUS_MELODY = 48;
const int PIN_NEXT_TONE = 23;
const int PIN_PREVIOUS_TONE = 25;

const int PINES[] = {PIN_DO, PIN_DO_S, PIN_RE, PIN_RE_S, PIN_MI, PIN_FA, PIN_FA_S, PIN_SOL, PIN_SOL_S, PIN_LA, PIN_LA_S, PIN_SI, PIN_NEXT_MELODY, PIN_PREVIOUS_MELODY, PIN_NEXT_TONE, PIN_PREVIOUS_TONE};
const int NUM_PINES = sizeof(PINES) / sizeof(int);

const String NOTAS[] = {"Do", "Do#", "Re", "Re#", "Mi", "Fa", "Fa#", "Sol", "Sol#", "La", "La#", "Si"};
const int NUM_NOTAS = sizeof(NOTAS) / sizeof(String);

LinkedList<String> melodiesList = LinkedList<String>();
int numMelodies = 0;
const int NUM_MELODIES_PINS = 2;

LinkedList<String> tonesList = LinkedList<String>();
int numTones = 0;
const int NUM_TONES_PINS = 2;

LinkedList<String> songsList = LinkedList<String>();
int numSongs = 0;

const String INSTRUMENT_DIRECTORY = "INSTRU";
const String SONG_DIRECTORY = "SONGS";

int selectedMelody = 0;
int selectedTone = 0;
int selectedSong = 0;

boolean playPianoMode = true;

const int PIN_CHANGE_MODE = 31;
const int PIN_VOLUME_UP = 27;
const int PIN_VOLUME_DOWN = 29;

const int PIN_NEXT_SONG = 46;
const int PIN_PREVOUS_SONG = 48;
const int PIN_PAUSE_SONG = 23;
const int PIN_PLAY_SONG = 25;

const int PIN_SPEAKER = 11;

// ------------------------------------------------------------------------------------
// Initialization functions
// ------------------------------------------------------------------------------------

// Initialize piano keys input pins
void initializePianoKeyPins()
{
    pinMode(PIN_DO, INPUT_PULLUP);
    pinMode(PIN_DO_S, INPUT_PULLUP);
    pinMode(PIN_RE, INPUT_PULLUP);
    pinMode(PIN_RE_S, INPUT_PULLUP);
    pinMode(PIN_MI, INPUT_PULLUP);
    pinMode(PIN_FA, INPUT_PULLUP);
    pinMode(PIN_FA_S, INPUT_PULLUP);
    pinMode(PIN_SOL, INPUT_PULLUP);
    pinMode(PIN_SOL_S, INPUT_PULLUP);
    pinMode(PIN_LA, INPUT_PULLUP);
    pinMode(PIN_LA_S, INPUT_PULLUP);
    pinMode(PIN_SI, INPUT_PULLUP);
}

// Initialize melody pins
void initializeMelodyPins()
{
    pinMode(PIN_PREVIOUS_MELODY, INPUT_PULLUP);
    pinMode(PIN_NEXT_MELODY, INPUT_PULLUP);
}

// Initalize tone pins
void initializeTonePins()
{
    pinMode(PIN_PREVIOUS_TONE, INPUT_PULLUP);
    pinMode(PIN_NEXT_TONE, INPUT_PULLUP);
}

// Initialize volume pins
void initializeVolumePins()
{
    pinMode(PIN_VOLUME_UP, INPUT_PULLUP);
    pinMode(PIN_VOLUME_DOWN, INPUT_PULLUP);
}

// Initialize change mode pin
void initiaizeModePin()
{
    pinMode(PIN_CHANGE_MODE, INPUT_PULLUP);
}

// Initialize SD card
void initializeSD()
{
    displayValuesOnScreen("Inicializando SD", "");
    delay(500);

    while (!SD.begin(CS_PIN))
    {
        displayValuesOnScreen("SD no encontrada", "");
        while (1)
            ;
    }

    displayValuesOnScreen("SD encontrada", "");
    delay(1000);
}

// Loads all melodies in the sd card
void initializeMelodies()
{
    melodiesList.clear();
    File dir = SD.open("/" + INSTRUMENT_DIRECTORY);
    getDirectoryFolders(dir, melodiesList);
    numMelodies = melodiesList.size();
    if (numMelodies == 0)
    {
        displayValuesOnScreen("Instrumentos", "no encontrados");
        while (1)
            ;
    }
    else
    {
        String message = "Encontrados: " + String(numMelodies);
        displayValuesOnScreen("Instrumentos", message.c_str());
        delay(500);
    }
}

// Loads all songs
void initializeSongs()
{
    songsList.clear();
    File dir = SD.open("/" + SONG_DIRECTORY);
    getDirectoryFiles(dir, songsList);
    numSongs = songsList.size();
}

// ------------------------------------------------------------------------------------
// LCD Display Funcions
// ------------------------------------------------------------------------------------

// Display piano info on screen
void displayPianoInfoOnScreen()
{
    displayValuesOnScreen(melodiesList.get(selectedMelody), "TONO: " + tonesList.get(selectedTone));
}

// Display reprodution mode info on screen
void displaySongInfoOnScren()
{
    displayValuesOnScreen("Elige cancion", songsList.get(selectedSong));
}

// Display passed info on screen
void displayValuesOnScreen(String firstLine, String secondLine)
{
    lcd.clear();
    lcd.print(firstLine);
    lcd.setCursor(0, 1);
    lcd.print(secondLine);
}

// ------------------------------------------------------------------------------------
// Directory utils functions
// ------------------------------------------------------------------------------------

// Gets folders names on directory
void getDirectoryFolders(File dir, LinkedList<String> &directoryFolders)
{
    getDirectoryItems(dir, directoryFolders, true);
}

// Gets file names on directory
void getDirectoryFiles(File dir, LinkedList<String> &directoryFiles)
{
    getDirectoryItems(dir, directoryFiles, false);
}

// Gets folders or files names on directory
void getDirectoryItems(File dir, LinkedList<String> &directoryItems, boolean getDirectories)
{
    while (true)
    {
        File entry = dir.openNextFile();
        if (!entry)
        {
            break;
        }
        if (entry.isDirectory() == getDirectories)
        {
            directoryItems.add(entry.name());
        }
        entry.close();
    }
}

// ------------------------------------------------------------------------------------
// Piano Mode Notes Functions
// ------------------------------------------------------------------------------------

// Plays a piano note by the selected ping
void playPianoTone(int selectedPin)
{
    String playedPianoNote = getPlayedPianoNote(selectedPin);
    playNote(playedPianoNote);
}

// Plays a piano note by the selected note
void playNote(String note)
{
    String path = "/" + INSTRUMENT_DIRECTORY + "/" + melodiesList.get(selectedMelody) + "/" + tonesList.get(selectedTone) + "/" + note + ".wav";
    Serial.println("Playing note: " + path);
    playAudio(path);
    delay(200);
}

// Gets note name by selectedPin
String getPlayedPianoNote(int selectedPin)
{
    return NOTAS[selectedPin];
}

// ------------------------------------------------------------------------------------
// Piano Mode Controll Functions
// ------------------------------------------------------------------------------------

// Switches melody by the selected pin
void changMelody(int selectedPin)
{
    Serial.println("Change melody");
    changeValue(selectedPin, PIN_PREVIOUS_MELODY, selectedMelody, numMelodies);
    updateCurrentMelodyTones();
    displayPianoInfoOnScreen();
}

// Switches tone by the selected pin
void changeTone(int selectedPin)
{
    Serial.println("Change tone");
    changeValue(selectedPin, PIN_PREVIOUS_TONE, selectedTone, numTones);
}

// Loads selected melody availaible tones
void updateCurrentMelodyTones()
{
    tonesList.clear();
    File dir = SD.open("/" + INSTRUMENT_DIRECTORY + "/" + melodiesList.get(selectedMelody));
    getDirectoryFolders(dir, tonesList);
    numTones = tonesList.size();
    selectedTone = 0;
}

// Changes selected value by selectedPin, current value and cuantity of availaible values
void changeValue(int selectedPin, int pinPreviousValue, int &currentValue, int numValues)
{
    pauseAudio();
    currentValue = getSelectedValue(selectedPin, currentValue, pinPreviousValue, numValues);
    displayPianoInfoOnScreen();
    delay(200);
}

// Returns selected value by selectedPin, current value and cuantity of availaible values
int getSelectedValue(int selectedPin, int currentValue, int pinPreviousValue, int numValues)
{
    int valueVariation = 0;
    if (PINES[selectedPin] == pinPreviousValue)
    {
        if (currentValue == 0)
        {
            return numValues - 1;
        }
        valueVariation = -1;
    }
    else
    {
        valueVariation = 1;
    }
    return (currentValue + valueVariation) % numValues;
}

// ------------------------------------------------------------------------------------
// Detect Button presed on piano mode
// ------------------------------------------------------------------------------------

void playedButtonOnPianoMode()
{
    // Se obtiene el indice del botón pulsado
    int selectedPin = getSelectedPin();
    // En este caso no se ha pulsado ningún botón
    if (selectedPin < 0)
    {
        return;
    }

    Serial.print("SELECTED PIN: ");
    Serial.println(PINES[selectedPin]);

    // En este caso se ha pulsado un botón para tocar el piano
    if (selectedPin < NUM_NOTAS)
    {
        playPianoTone(selectedPin);
        return;
    }
    // En este caso se ha pulsado un botón para cambiar el instrumento
    if (selectedPin < NUM_NOTAS + NUM_MELODIES_PINS)
    {
        changMelody(selectedPin);
        return;
    }
    // En este caso se ha pulsado un botón para cambiar el tono
    if (selectedPin < NUM_NOTAS + NUM_MELODIES_PINS + NUM_TONES_PINS)
    {
        changeTone(selectedPin);
    }
}


int getSelectedPin()
{
    for (int i = 0; i < NUM_PINES; i++)
    {
        if (digitalRead(PINES[i]) == LOW)
        {
            return i;
        }
    }
    return -1;
}

// ------------------------------------------------------------------------------------
// Archive Reprodution mode controlls
// ------------------------------------------------------------------------------------

// Selects the following or the previous song
void changeSelectedSong(int songVariation)
{
    Serial.println("Change song");
    selectedSong = (selectedSong + songVariation) % numSongs;
    if (selectedSong < 0)
    {
        selectedSong = numSongs - 1;
    }
    displaySongInfoOnScren();
}

// Plays selected song
void playSelectedSong()
{
    String selectedSongName = songsList.get(selectedSong);
    String path = "/" + SONG_DIRECTORY + "/" + selectedSongName;
    Serial.println("Play song: " + path);
    playAudio(path);
}

// ------------------------------------------------------------------------------------
// Detect Button presed on archive roprodution mode
// ------------------------------------------------------------------------------------

void playedButtonOnMusicMode()
{
    if (digitalRead(PIN_NEXT_SONG) == LOW)
    {
        changeSelectedSong(+1);
    }
    else if (digitalRead(PIN_PREVOUS_SONG) == LOW)
    {
        changeSelectedSong(-1);
    }
    else if (digitalRead(PIN_PAUSE_SONG) == LOW)
    {
        Serial.println("Pause/Resume song");
        pauseResumeAudio();
    }
    else if (digitalRead(PIN_PLAY_SONG) == LOW)
    {
        playSelectedSong();
    }

    delay(200);
}

// ------------------------------------------------------------------------------------
// Mode Controll
// ------------------------------------------------------------------------------------

// Changes the mode of the execution, if it is some archive being reproduced it get paused
void changeMode()
{
    Serial.println("Change mode");
    playPianoMode = !playPianoMode;
    pauseAudio();
    if (playPianoMode)
    {
        displayPianoInfoOnScreen();
    }
    else
    {
        displaySongInfoOnScren();
    }
    delay(200);
}

// ------------------------------------------------------------------------------------
// Audio Play Controll
// ------------------------------------------------------------------------------------

// Pauses audio if its playing, if its not playing it has no effect
void pauseAudio()
{
    if (playingAudio)
    {
        playingAudio = false;
        audio.pause();
    }
    delay(200);
}

// Pauses audio if its playing, if the audio is paused it continous it
void pauseResumeAudio(){
    playingAudio = !playingAudio;
    audio.pause();
}

// Play a archive in the route passed as parameter
void playAudio(String path){
  if (!playingAudio){
    audio.pause();
  }
    playingAudio = true;
    audio.play(path.c_str());
}

// ------------------------------------------------------------------------------------
// Volume Controll
// ------------------------------------------------------------------------------------

void volumeUp()
{
    Serial.println("Volume up");
    audio.volume(1);
    delay(200);
}

void volumeDown()
{
    Serial.println("Volume down");
    audio.volume(0);
    delay(200);
}

// ------------------------------------------------------------------------------------
// Setup
// ------------------------------------------------------------------------------------

// Initializes, lcd, buttons, sd card, charges melodies, tones and archives
void setup()
{
    Serial.begin(9600);
    lcd.begin(16, 2);

    initializePianoKeyPins();
    initializeMelodyPins();
    initializeTonePins();
    initializeVolumePins();
    initiaizeModePin();

    initializeSD();
    initializeMelodies();
    updateCurrentMelodyTones();
    initializeSongs();

    displayPianoInfoOnScreen();
    audio.speakerPin = PIN_SPEAKER;
    audio.setVolume(5);
    audio.quality(1);
}

// ------------------------------------------------------------------------------------
// loop
// ------------------------------------------------------------------------------------

void loop()
{
    if (digitalRead(PIN_CHANGE_MODE) == LOW)
    {
        changeMode();
        return;
    }

    if (digitalRead(PIN_VOLUME_UP) == LOW)
    {
        volumeUp();
        return;
    }

    if (digitalRead(PIN_VOLUME_DOWN) == LOW)
    {
        volumeDown();
        return;
    }

    if (playPianoMode)
    {
        playedButtonOnPianoMode();
    }
    else
    {
        playedButtonOnMusicMode();
    }
}

Materiales, costes y precios

Esta sección está compuesta por una tabla con los materiales y componentes utilizados para la realización del proyecto, también se muestra el precio que tienen todos los materiales y el coste que ha repercutido sobre nosotros:

Nombre	Coste	Precio
Módulo Lector SD	5,49 €	5,49 €
Altavoz 3W	1,99 €	1,99 €
Potenciómetro 10K	–	1,00 €
Pantalla LCD 16X02	–	6,00 €
1 Arduino Mega	19,99 €	19,99 €
1 Protoboard	–	4,79 €
1 mini-Protoboard	–	2,33 €
20 Botones	1 €	1 €
Cables	7,50 €	9,50 €
Transistor NPN	–	0,50 €
Tornillos	–	2 €
Metacrilato	10 €	10 €
Madera	–	10 €
Cinta Doble Cara	3,50 €	3,50 €
Total	49,47 €	78,09 €

Nos gustaría aclarar que la madera utilizada ya la teníamos en casa por eso no ha repercutido un coste sobre nosotros. El metacrilato para las piezas sí que lo tuvimos que adquirir aunque el servicio de corte fue gratuito.

Casos de uso

En esta sección se comentarán los distintos casos de uso que podemos encontrarnos en el proyecto:

• Lectura archivos SD: Al conectar el artefacto al ordenador, el primer paso que da el programa es leer el sistema de archivos archivos de la tarjeta SD. El primer paso es comprobar que la SD está insertada, indicando al usuario el resultado de esta comprobación a través de la pantalla LCD. La primera información que lee el programa es la relativa a los instrumentos y a los tonos, mostrándole al usuario la cantidad de instrumentos encontrados en la tarjeta SD. En caso de que no se hubiera insertado ningún instrumento el programa se bloquearía impidiendo el uso del artefacto. Posteriormente reconoce los archivos que se podrán reproducir en el modo “Reproductor de archivos”. En este caso no muestra ningún tipo de información al usuario. Una vez se ha finalizado esta lectura de archivos, se pasa al modo para reproducir los instrumentos, indicando el instrumento y tono seleccionados y este paso habría terminado.

• Pulsación nota musical: En el modo de reproducción de instrumentos si se acciona una de las notas del piano, se emite el sonido correspondiente con el tono e instrumento seleccionados.

• Cambio de instrumento: En el modo de reproducción de instrumentos se pueden accionar 2 botones para seleccionar el próximo instrumento o el anterior. En el caso de que se accione uno de estos botones, se cambia el instrumento seleccionado, la información del nuevo instrumento se muestra por pantalla y se ajusta el tono con el que se corresponde en el nuevo instrumento seleccionado.

• Cambio de tono: En el modo de reproducción de instrumentos, se pueden accionar 2 botones para seleccionar el tono del instrumento que está seleccionado. En el caso de que se accione uno de estos botones, se cambia el tono del instrumento seleccionado. Una vez se ha cambiado el tono, se muestra el nuevo tono por pantalla.

• Cambio de modo: Existe un botón para alternar entre el modo “Reproducción de archivos” y “Reproducción de instrumentos”. Al alternar entre modos se muestra la información correspondiente con el modo seleccionado. En el modo de “Reproducción de archivos” se muestra el archivo seleccionado para la reproducción. En el modo de “Reproducción de instrumentos” se muestra el instrumento y tono seleccionados. Cuando se realiza un cambio de modo,  se pausa el audio que estaba siendo reproducido.

• Reproducir archivo: En el modo de “Reproducción de archivos” existe un botón para comenzar la reproducción del archivo seleccionado.

• Pausar/Reanudar reproducción: En el modo de “Reproducción de archivos” existe un botón para pausar la reproducción del audio actual o en caso de que esté pausado para reanudar la reproducción del mismo.

• Selección de archivo para reproducir: En el modo de “Reproducción de archivos” existen 2 botones para seleccionar el archivo siguiente o el anterior. Cuando se selecciona un nuevo archivo se muestra el archivo seleccionado en la pantalla.
  
• Subir y bajar volumen: En cualquier modo se pueden accionar 2 botones para subir o bajar el volumen del audio que se reproduce.

Reparto de las tareas

En esta sección se comentará la distribución de las tareas a la hora de realizar el proyecto.

Brais Cabo Felpete: Desarrollo del software del proyecto, construcción del artefacto y diseño del hardware en simulador.

Iker Pizarro Fernández: Desarrollo del software del proyecto, construcción del artefacto y ensamblado de hardware en la placa.

Nos gustaría destacar que en general ambos nos hemos ayudado en todas las tareas intentando resolver los bloqueos que pudiéramos ir teniendo. También nos gustaría mencionar que hemos realizado varias videollamadas y encuentros presenciales para trabajar de manera conjunta.

Problemas y soluciones encontradas

En relación a los problemas que nos hemos ido encontrando durante el desarrollo del proyecto, a continuación comentaremos los más significativos y como hemos lidiado con ellos:

• Utilización tarjeta SD: En un principio nos habíamos planteado reproducir los archivos almacenados en el ordenador. Buscando por internet hemos visto que esto no era posible por lo que tuvimos que buscar otro método para la reproducción de los archivos. Fue en este momento cuando nos planteamos la viabilidad del proyecto, pero terminamos descubriendo que se podían reproducir archivos almacenados en una tarjeta SD con la conexión de un lector de tarjetas SD.

• Gestión de la alta cantidad de botones: En este proyecto como hemos ido comentando a lo largo de todo el documento, necesitamos una gran cantidad de botones. Para manejar esta gran cantidad de botones nos encontramos con dos problemas. El primer problema fue la falta de pines en el microcontrolador Arduino Uno, para resolver este problema adquirimos un microcontrolador Arduino Mega, que contaba con suficientes pines para resolver nuestro problema. El segundo problema encontrado fue la cantidad de resistencias, y conexiones extra que implica la conexión de botones, lo que puede conllevar el fallo de ciertos contactos y el mal funcionamiento de los mismos. Para resolver este problema configuramos los botones como INPUT_PULL_UP para necesitar únicamente una conexión al GND y al pin del microcontrolador correspondiente.

• Volumen casi inaudible: Otro de los principales problemas encontrados fue el bajo volumen del altavoz. Esto nos llevó a pensar que estaba defectuoso o que lo habíamos roto.Indagando por internet descubrimos que se puede construir un amplificador de sonido con un transistor NPN por lo que con este método pudimos incrementar el volumen del sonido.

Mejoras a futuro del proyecto

En esta sección se comentarán algunas de las mejoras que hemos pensado que se pueden incluir al proyecto de forma razonable:

• Batería con interruptor: Para mejorar la experiencia de utilización del proyecto se podría incluir una pila de 9V con un interruptor para dejar pasar la alimentación para que se pueda encender y apagar el aparato sin necesidad de conectar y desconectar la alimentación y sin tener que conectarlo al ordenador.

• Mejorar la pulsación de las teclas: La pulsación actual de las teclas es algo inestable, hemos pensado que se podría incluir algún tipo de estabilizador para mejorar esta sensación de pulsación de las teclas.

• Mejorar la comodidad y tamaño del aparato: Otro de los aspectos que se podrían mejorar es la comodidad y el tamaño de la caja que contiene la electrónica, ya que ahora mismo es bastante grande y un poco incómoda de utilizar.

• Mejorar la calidad del sonido: Un aspecto que creemos que también sería interesante es el de introducir unos altavoces de mejor calidad que proporcionen un sonido más nítido.

• Aumentar volumen del sonido: Otro de los aspectos que se podría mejorar respecto al sonido es el del volumen del mismo. Para esto se podría cambiar el amplificador casero por un amplificador ya construido con una mayor capacidad de amplificación.

Video explicativo del proyecto

Documentación adicional

Presentación: https://docs.google.com/presentation/d/1xlcjC-kpZw60qGgTj-UTNc07vkcb6J_p8nuIlMjlADo/edit?usp=sharing