Tutorial: Crear un minipiano con Arduino

Siguiendo con nuestros pequeños tutoriales, hoy os traemos un pequeño tutorial, de como crear un pequeño piano con arduino y controlarlo desde nuestro propio ordenador. En este caso, vamos a utilizar el propio teclado de nuestro ordenador(ya sea portátil o de sobremesa) para que usando las teclas a,s,d,f,g,etc.. podamos tocar las notas musicales las cuales serán generadas por distintos tonos a través de nuestro arduino.

como siempre, vamos a mostrar los distintos componentes que vamos  a utilizar en este tutorial.

  • 1 Arduino Uno(también es válido un Mega)
  • 1 resistencia 100 Ohmios.
  • 1 altavoz de 8 Ohmios(puede valer cualquier altavoz de un Pc Viejo que tengáis por casa.
  • 1 Cable USB para conectar al PC

Una vez que tenemos estos componentes, vamos a realizar el montaje que simplemente es conectar el altavoz a nuestro Arduino con la resistencia conectada.

montaje piano

 

 

En este caso, como vemos el montaje es muy sencillo por lo que solo tenemos que conectar los distintos componentes(como siempre hemos utilizado fritzing para realizar este montaje). Una vez hemos realizado este montaje vamos a pasar a realizar la programación de nuestro arduino.

Seguidamente os mostramos el código de nuestro programa arduino:

 

/*
  booleanbite.com: este ejemplo permite crear un pequeo piano con algunas notas
  a traves de USB. Este ejemplo se basa en el tutorial:
 
 http://arduino.cc/en/Tutorial/Tone
  Fecha: 28/12/2014
  Autor: Booleanbite
 */
 #include "pitches.h"
 
// notes in the melody:
int melody[] = {
  NOTE_C4, NOTE_G3,NOTE_G3, NOTE_A3, NOTE_G3,0, NOTE_B3, NOTE_C4};
 
// note durations: 4 = quarter note, 8 = eighth note, etc.:
int noteDurations[] = {
  4, 8, 8, 4,4,4,4,4 };
 
void setup() {
  //Inicializacion del puerto serie
  Serial.begin(9600);
  //El siguiente fragmento de codigo simplemente inicializa una melodia para probar
  //que funciona correctamente.
 
  // iterate over the notes of the melody:
  for (int thisNote = 0; thisNote < 8; thisNote++) {
 
    // to calculate the note duration, take one second 
    // divided by the note type.
    //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
    int noteDuration = 1000/noteDurations[thisNote];
    tone(8, melody[thisNote],noteDuration);
 
    // to distinguish the notes, set a minimum time between them.
    // the note's duration + 30% seems to work well:
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    // stop the tone playing:
    noTone(8);
  }
}
 
void loop() {
  //Si hay datos disponibles en el puerto serie
  if(Serial.available()){
     char note = Serial.read(); //Leemos el caracter
      switch(note){
       case 'a':
       case 'A':
          makeTone(NOTE_C4); //DO
         break;
       case 's':
       case 'S':
          makeTone(NOTE_D4); //RE
          break;
        case 'd':
       case 'D':
          makeTone(NOTE_E4); //MI
          break;
        case 'f':
       case 'F':
          makeTone(NOTE_F4); //FA
          break;
        case 'g':
       case 'G':
          makeTone(NOTE_G4); //SOL
          break;
        case 'h':
       case 'H':
          makeTone(NOTE_A4); //LA
          break;
         case 'j':
       case 'J':
          makeTone(NOTE_B4); //SI
          break;
         case 'k':
       case 'K':
          makeTone(NOTE_C5); //DO
          break;
      }
  }
 
}
//Crea una nota que dura 1/4 a traves del pin 8.
void makeTone(int melody){
  tone(8,melody,1000/4);
  delay((1000/4)*1.30);
  noTone(8);
}

En este caso, podemos ver que  en primer lugar, inicializamos el puerto serie con el objeto Serial y que después mostramos una pequeña melodía que se trata de la melodía “El canguro feliz” para que podamos ver que funciona correctamente. Una vez hecho esto, en la función loop leemos del puerto serie y en función del carácter que hemos recibido, se envía un tono u otro con la función makeTone; en este caso, todas las notas tienen el mismo tiempo 1/4 se puede extrapolar este ejemplo para que acepte otro tiempo de tono. Si copia este ejemplo y lo intenta compilar, no funcionará por que al inicio de este verá que se añade un fichero llamado pitches.h en este fichero se definen todas las notas que podemos realizar con nuestro arduino. Seguidamente se deja un enlace para que pueda descargarlo:

archivo pitches.h

este archivo debe estar en la misma carpeta que el programa de ejemplo. Una vez que tenemos el código y el archivo .h listo, vamos a subirlo a nuestra placa arduino. Si todo va bien, se escuchará una melodía inicial que será la canción del “canguro feliz” y seguidamente podemos mandarle caracteres a través del monitor serial(en otros artículos se ha mencionado como hacerlo). Ahora mismo podemos ver que pulsando las teclas y pulsando enter para enviar, se escuchan las notas. Sin embargo, esto no es útil para hacer nuestro pequeño piano controlado por nuestro ordenador. Para ello, vamos a realizar un programa en python que nos permitirá leer del teclado y mandar dicha tecla automáticamente.

en primer lugar, vamos a necesitar los siguientes paquetes python:

  • serial
  • readchar

Para ello, ejecutamos las siguientes ordenes en nuestra consola de comandos:

 

 pip install pyserial
 pip install readchar

Una vez instalados estos paquetes, vamos a escribir el siguiente código:

 

##########################################################################
# ejemplo de creacion de un piano; en este caso, vamos a mandar datos    #
#  a través del puerto serie por el USB                                  #
# Fecha: 28/12/2014                                                      #
# Autor: Booleanbite                                                     # 
########################################################################## 
 
import serial
import readchar
#mensaje inicial
print("Piano Arduino. Presiona las telcas A,S,D,F,G,H,J,K Para las notas o Esc para salir.")
arduino = serial.Serial('/dev/tty.usbmodem1421',9600) #se abre el puerto usb
 
while True:
	char = readchar.readchar()#leer un caracter del teclado
	if(char == '\x1b'): # si es la tecla Esc. se cierra el bucle y se sale del programa
	  break;
	arduino.write(bytearray(char,'ascii')) # se manda el dato por el usb
arduino.close()#se cierra el puerto serie

Con este código ya podemos ejecutar dicho script y poder hacer funcionar nuestro piano. Sin embargo, hay un punto que el lector debe saber, y es saber que dispositivo debe usar(este ejemplo es válido para Linux y Mac Os para Windows hay que cambiar el dispositivo). Esto puede saberse fácilmente usando el IDE de Arduino. Cuando el IDE de arduino esta encendido y pasamos el programa, tenemos que elegir el puerto a usar. Esto puede verse en el menú herramientas->port.

Captura de pantalla 2014-12-28 a las 16.13.59

 

Como podeís ver en cada puerto que estemos usando aparecerá el dispositivo a utilizar. Simplemente en la línea:

 

arduino = serial.Serial('/dev/tty.usbmodem1421',9600) #se abre el puerto usb

Debemos cambiar el /dev/tty.usbmodem1421 por el correspondiente. Además que debe estar cerrado el IDE Arduino. Por último ya solo nos queda ejecutar el script con el siguiente comando.

python pianoduino.py

Podemos probar cada una de las notas y comprobar que funcionan todas además de si pulsamos la tecla escape, saldrá del programa. Esto ha sido todo para tener un pequeño piano y poder tocar algunos villancicos. Esperemos que tengáis unas felices fiestas. Aquí os dejamos un vídeo de como funciona nuestro piano y además este enlace a nuestro repositorio GitHub con el ejemplo.

1 Comment on "Tutorial: Crear un minipiano con Arduino"

  1. Muy interesante me ha gustado mucho

Deja un comentario.

Tu dirección de correo no será publicada.


*


*