ARPA VIRTUAL CON PROCESSING Y ARDUINO

Carlos David Puerta Sánchez.

Control I

Ingeniería Electrónica.

Universidad del Magdalena.

El siguiente proyecto corresponde a la simulación de forma virtual de los sonidos de un arpa. Para lograr dicha tarea se hace uso de herramientas de hardware y software libre por su facilidad y versatilidad que presentan.

En esta ocasión se hace uso de Processing no solo por la sencillez que presenta este software, sino también por la utilidad que presenta en caso que se desee implementar el proyecto en sistemas Android.

EL ARPA

Este fascinante instrumento de cuerda tiene sus orígenes en Asia y África desde hace miles de años. Debido a su larga edad, ha tenido varios cambios en su fabricación a lo largo de los años.

Actualmente se pueden encontrar distintos tipos de arpas, donde sus principales variaciones radican en el tamaño del instrumento, el número de cuerdas y el material de las mismas.

El número de cuerdas de un arpa puede extenderse hasta las 47, sin embargo hay variaciones en la que estas pueden reducirse hasta 26 cuerdas.

Es interesante resaltar que en algunas arpas las tonalidades correspondientes a los sostenidos y bemoles se obtienen por medio de pedales.

DESARROLLO DEL PROYECTO

Lo primero que se hizo fue seleccionar una imagen, la cual se editó de tal forma que fuese posible separa lo suficiente las cuerdas para una mejor distinción entre ellas a la hora de deslizar el mouse sobre ellas.

Después de haber seleccionado  la imagen y cargarla en processing, fue necesario correr un pequeño programa para poder saber la coordenada de cada una de las cuerdas y sobre esta información trabajar en la clasificación de cada cuerda.

Este código fue el empleado para obtener la coordenada X de cada cuerda del arpa virtual con la q se trabajó.

Una vez conocida la posición de cada una de las cuerdas, se procedió asignando a cada una de ellas una respectiva nota de la escala musical. Vale la pena resaltar que las cuerdas rojas son la de la tonalidad de DO y van aumentando de izquierda a derecha. Las cuerdas azules corresponden a FA.

Posteriormente se procedió a la asignación de los sonidos a cada cuerda, para eso se hizo uso de la librería maxim y se definieron las variables necesarias donde a cada una de ellas se cargó un archivo de audio con la nota musical respectiva.

En la porción de código anterior se observa cómo se cargan los archivos .wav donde está el sonido de cada nota del arpa. Y se selecciona el setLooping (false) para que no se repita el sonido sino que suene una vez cada vez q se seleccione la cuerda.

Una vez cargada la imagen y los sonidos, se hizo uso de la función mouseDragged, la cual nos permite reproducir la nota correspondiente cada vez que pasamos el cursor del mouse (presionado) sobre la cuerda.

Como se puede observar, se pregunta por la coordenada del mouse y dependiendo de esta, se reproduce el sonido almacenado en la variable player que corresponda.

Es importante indicar que la velocidad de reproducción se va aumentando a medida que la escala de notas aumente, es decir, para la primera escala la velocidad de reproducción es 1, mientras que para la segunda escala musical la velocidad se duplica y así hasta abarcar las 4 escalas que posee esta arpa.

Un ítem adicional, fue la implementación de hardware en el proyecto. En este caso se utilizó la tarjeta arduino uno, para que encendiera un led por cada nota musical que sonaba en el instrumento virtual. La comunicación entre arduino y processing se hizo mediante el puerto serial. Como se vio en la porción de código anterior dependiendo de la coordenada en que esta el mouse, se va a reproducir cierto sonido, pero a su vez se escribe un dato en el puerto “puerto.Write(‘dato’)”

Una vez asignado dicho dato en el puerto, lo que se hace en arduino es preguntar por el valor que esté en el puerto serial y dependiendo de la información que  haya se va a encender el led correspondiente.

En este caso se encenderá el led que está en el pin 13 cada vez que la nota que suene sea DO.

Para finalizar solo resta destacar lo interesante que resulta hacer uso del software y hardware libre donde los proyectos o tareas a realizar pueden ser prácticamente ilimitadas. Fue muy grato conocer herramientas como processing y darse cuenta que es posible programar y generar códigos capaces de interactuar con distintos dispositivos Android.

Sin duda esta fue una experiencia gratificante y que nos permite ver que muchas veces las cosas no son tan difíciles como quizá imaginamos. 

Clarinete, Interfaz Grafico En Processing

Control I - Clarinete, Interfaz Grafico En Processing

Por: Luis D. Sierra C.

Processing es un lenguaje de programación y entorno de desarrollo integrado de código abierto basado en Java, de fácil utilización. 

En este caso se hará una pequeña aplicación que demuestre que tan fácil es programar en él (sin necesidad de tener conocimientos extensos en java), dicha aplicación será una especie de modelamiento entre la interfaz gráfica de Processing y un instrumento musical. ¿Con que motivo? Para demostrar que para este software se pueden tener infinitas posibilidades en cuanto áreas de  trabajo se refiere en cuestiones de efectos gráficos, herramientas multimedia, recursos interactivos etc… todo esto solo limitado a cuanto te lo permitas tu imaginación.

El instrumento

El instrumento sobre el cual trabajare será el clarinete, este instrumento aunque es poco conocido es un instrumento musical de la familia de los aerófonos, de viento madera, se encuentra en la sección del viento-madera, junto a la flauta, el oboe, el corno inglés y el fagot. En nuestro país se le podrá ver y escuchar en los bailes típicos de la región caribe.

¿Comenzamos ya? ¡Listo!

Primero que todo como se mencionó anteriormente uno de los límites lo pone la imaginación, y la imaginación es de cada quien….en este caso cada quien tendrá una idea (guidado por razones como experiencia, creatividad e ingenio) de como querrá hacer sus programa, estructura del código, sentencias a usar, librerías que utilizar en fin, mi idea la describiré a continuación:

1    Necesitare para la implementación en el software Processing, los sonidos que se utilizare para reproducir el  clarinete, estos los conseguí gracias  a la página web www.freeecardgreeting.ne y más precisamente en la dirección http://www.freeecardgreeting.net/home/clarinet_online.php allí solo encontré los acordes pero estos no están disponibles para descargar, lo cual me hizo buscar ayuda de un software que me permitiera grabar, editar y amplificar un poco los sonidos (desde la página se notan algo tenues) es así en donde decidí utilizar el programa (por recomendación de mis compañeros), Audacity:

Teniendo los sonidos ya grabados (en extensión .wav y con duración de 1 segundo aproximadamente) continuemos con nuestro paso a paso.

2.    Saber dentro del programa que librerías usare y la estructura del código en general, teniendo en cuenta que uno de nuestros intereses principales es gastar la mínima memoria requerida para ejecutar el programa. Para nuestro código usaremos las librerías PImage img; Maxim maxim; que en ese orden son: la librería encargada de almacenar y cargar las imágenes del programa, encargada de la reproducción de sonidos .wav y por ultimo

Explicación del código y estructura:

El código es sumamente sencillo y después de esta breve explicación se podrá observar. Primero que todo inicializamos las variables e incluimos las librerías antes mencionadas en el programa.

La aplicación comienza mostrando la imagen principal. Esta:

clarinete.png

En la cual se ve nuestro instrumento y en la parte inferior izquierdas las notas que se podrían tocar (solo se podrán tocar 14 entre notas mayores y menores),  estamos utilizando en primera medida las teclas del computador. Si el usuario no toca ninguna tecla el programa siempre estará cargando la imagen interior, si el usuario presiona una tecla el programa la leerá y comparara con las que si cumplen una función en el programa, dicha acción la hace gracias a sentencia keyPressed que lee el teclado. Por ejemplo, para este código las notas y teclas asignadas así:

q/DO	w/RE	e/MI	r/FA	t/SOL	y/LA	u/SI
a/do	s/re	d/mi	f/fa	g/sol	h/la	j/si

Letra (minúscula) en el teclado asignada a una nota.

Como el código se está ejecutando siempre si el usuario presiona una de estas teclas entra a un ciclo if  y realiza la siguiente acción:

1.     Carga otra imagen, esta vez sale el clarinete mostrando cuales son las aberturas del instrumento que se deben cerrar con los dedos para producir dicho acorde, también se muestra abajo, el acorde que esta sonando. acá un ejemplo:

Nota DO, al presionar la tecla q (DO.png)

2.     También dentro de este mismo if se ejecuta el comando player = maxim.loadFile("DO.wav"); que es quien carga el sonido que anteriormente se había grabado en Audacity, player.cue(0); hace que el sonido suene solo una vez y por ultimo player.play(); hace que el sonido se reproduzca .

En resumen se tienen, 14 sonidos .wav y 14 imágenes .png, este es resumen la estructura del código. Habrá entonces 14 if para cada tecla y acorde. Siempre se cargara una imagen por cada tecla que se oprima y es obvio decir que si se presionan teclas que no están en el código el programa no hará nada. A continuación se muestra el código.

Código

int x=0;

PImage img;

Maxim maxim;

AudioPlayer player;

void setup()

{

img=loadImage("clarinete.png");

size(img.width, img.height);

}

void draw(){image(img, 0, 0);

if (mousePressed == true){ 

x=1;

println(x);

}else{

x=0;

 

}

}

void keyPressed()

{

if ((key == 'q))

{

img=loadImage("DO.png");

size(img.width, img.height);

maxim = new Maxim(this);

player = maxim.loadFile("DO.wav");

player.setLooping(false);

player.cue(0);

player.play();

}

if ((key == 'a')) {

img=loadImage("do.png");

size(img.width, img.height);

maxim = new Maxim(this);

player = maxim.loadFile("dom.wav");

player.setLooping(false);

player.cue(0);

player.play();

}

if ((key == 'w')) {

img=loadImage("RE.png");

size(img.width, img.height);

maxim = new Maxim(this);

player = maxim.loadFile("RE.wav");

player.setLooping(false);

player.cue(0);

player.play();

}

if ((key == 's'))

{

img=loadImage("re.png");

size(img.width, img.height);

maxim = new Maxim(this);

player = maxim.loadFile("re.wav");

player.setLooping(false);

player.cue(0);

player.play();

}

if ((key == 'e'))

{

img=loadImage("mi.png");

size(img.width, img.height);

maxim = new Maxim(this);

player = maxim.loadFile("MI.wav");

player.setLooping(false);

player.cue(0);

player.play();

}

if ((key == 'd'))

{

img=loadImage("mi.png");

size(img.width, img.height);

maxim = new Maxim(this);

player = maxim.loadFile("mi.wav");

player.setLooping(false);

player.cue(0);

player.play();

}

if ((key == 'r'))

{

img=loadImage("FA.png");

size(img.width, img.height);

maxim = new Maxim(this);

player = maxim.loadFile("FA.wav");

player.setLooping(false);

player.cue(0);

player.play();

}

if ((key == 'f'))

{

img=loadImage("fa.png");

size(img.width, img.height);

maxim = new Maxim(this);

player = maxim.loadFile("fa.wav");

player.setLooping(false);

player.cue(0);

player.play();

}

if ((key == 't'))

{

img=loadImage("SOL.png");

size(img.width, img.height);

maxim = new Maxim(this);

player = maxim.loadFile("SOL.wav");

player.setLooping(false);

player.cue(0);

player.play();

}

if ((key == 'g'))

{

img=loadImage("sol.png");

size(img.width, img.height);

maxim = new Maxim(this);

player = maxim.loadFile("sol.wav");

player.setLooping(false);

player.cue(0);

player.play();

}

if ((key == 'y')) {

img=loadImage("LA.png");

size(img.width, img.height);

maxim = new Maxim(this);

player = maxim.loadFile("LA.wav");

player.setLooping(false);

player.cue(0);

player.play();

}

if ((key == 'h'))

{

img=loadImage("la.png");

size(img.width, img.height);

maxim = new Maxim(this);

player = maxim.loadFile("la.wav");

player.setLooping(false);

player.cue(0);

player.play();

}

if ((key == 'u'))

{

img=loadImage("SI.png");

size(img.width, img.height);

maxim = new Maxim(this);

player = maxim.loadFile("SI.wav");

player.setLooping(false);

player.cue(0);

player.play();

}

if ((key == 'j')) {

img=loadImage("si.png");

size(img.width, img.height);

maxim = new Maxim(this);

player = maxim.loadFile("si.wav");

player.setLooping(false);

player.cue(0);

player.play();}

}

Presentado Por:

Luis D. Sierra C.

contro1 violin jose jaime

Control I

Instrumento musical violin.

INTRODUCCION

La idea fundamental de este proyecto era realizar la construcción de un instrumento musical, para este particular caso se hizo énfasis en el violin.

CONSTRUCCION.

1.      LIBRERIAS A USAR:

·         Maxim

·         Serial

·         Video

·         Minim

2.      Para este paso se buscaron todas las ingentes que se necesitarían, a su vez se extrajeron las notas musicales con un software llamado AUDACITY.

3.      Se procedio a darle vida al proyecto atres de la programación.

4.      Móntate con arduido.

Ahora miremos un poco el código.

Bueno luego visto el código miremos algunas imágenes de como se ve funcionando.

Imagen principal.

Esta imagen de toca el primer tono, este asu vez carga la nota musical y además muestra la posición de las manos en el violin.

Esta imagen se muestra otro tono.

En esta imagen es cuando se pone en reproducción el video.

PROBLEMAS.

1.       Lo estructuración del código.

CONCLUSION

Muy interesante processing, pues es un software fácil de manejar y didáctico pero de gran potencia. Además nos permite comunicarnos con arduino y fusionados son realmente de gran utilidad en el campo de la ingeniería electrónica.

VIOLÍN INTERFAZ: PROCESSING – ARDUINO

VIOLÍN  INTERFAZ: PROCESSING – ARDUINO

CEYENDY DANIEL CABALLERO CAMARGO - ceyendy@hotmail.com

PROGRAMA DE INGENIERÍA ELECTRÓNICA - FACULTAD DE INGENIERÍA

UNIVERSIDAD DEL MAGDALENA - SANTA MARTA - 2013

En este trabajo se mostrara el proceso de cómo realizar una interfaz de violín a través de PROCESSING  y ARDUINO,

PROCESSING:

Es una herramienta de software libre, diseñado para el desarrollo de arte gráfico, animaciones y aplicaciones gráficas. Es de fácil uso, permitiendo realizar  aplicaciones desde las más sencillas a las más complejas.

Al mismo tiempo, hace posible la elaboración  de aplicaciones,  ya sea para uso en Internet  dispositivos móviles, o conexión con dispositivos y prototipos electrónicos, como por ejemplo Arduino. [1]

ARDUINO:

 Es una plataforma de creación de prototipos electrónicos de código abierto,  basado en  una  placa de open hardware, es decir, su diseño es de libre distribución y  utilización.[2]

Figura 1. Placa arduino

La creación de esta interfaz, fue dividido en dos secciones, que son  hardware y software.

Para el  software, el código fue empleado  en processing,  2.0, y  estructurado en seis partes.

1)    Librerías y variables a utilizar:  

Figura 2. Librerías

·         La librería minim: implementada  para la reproducción y manipulación de archivos de audio, utilizando processing como lenguaje de desarrollo.

·         Librería Gif animation: ayuda a cargar imágenes .gif, los archivos gif contienen múltiples imágenes que se muestran en sucesión. [3]

Figura 3. Imagen .gif

·         Processing.serial e cc. Arduino: estas dos librerías, son las usadas para lograr comunicación con la placa de desarrollo arduino, la cual estará interactuando con la aplicación realizada en processing a través del puerto serial,  dicha placa podrá ser programada directamente desde el mismo processing,  declarando los pines como entrada o salida, para la recesión o transmisión de datos.  En la siguiente figura se muestra como fue realizado todo el proceso y la declaración de las variables a utilizar.

                                         

Figura 4. Declaración de variables

Después del void draw(), se pasan a llamar las funciones realizadas para facilidad del código. Se empezará preguntando por un pulsador de la tarjeta arduino llamada ledpin  que  corresponde al pin 12 de la placa.

Figura 5.  Llamado de funciones

La  imagen que se presenta a continuación corresponde a la espera, para que el pulsador sea oprimido  dar inicio a la aplicación.

Figura 6.

  

Al ser presionado el pulsador del pin 12 de la placa arduino, se mostrará una imagen introductoria, donde se podrá escoger lo que se desee realizar,  si jugar o afinar su violín.

Figura 7. Ventana principal

El  código que se muestra a continuación corresponde a la pagina introductoria de esta interfaz.

Figura 8. Código de la ventana principal

Si la opción escogida era jugar (PLAY), aparecerá una nueva ventana la cual tendrá todas la notas correspondientes a cada traste del violín; si una de esta es presionada  se obtendrá la melodía correspondiente a la nota musical tocada.

Figura 9. Ventana de Play

La siguiente imagen presenta la forma de como fue desarrollada esta ventana, correspondiente a las notas del violín  cuyos botones fueron realizados con  ayuda de las instrucciones brindadas por el software.

Figura 10.

Por otro lado, cuando el botón afinar es presionado, aparecerá una gráfica correspondiente a las notas de cada cuerda del violín  Si uno de los cuatro pulsadores, que se encuentran en un medio físico es seleccionado, emitirá el sonido correspondiente a la cuerda que se quiera afinar.

Figura 11. Ventana del afinador

Codigo empleado para la realización del afinador:

Figura 12. Código del afinador

Cabe resaltar, que cada uno de los pulsadores encontrados en el software, fueron diseñados a través de la función mausepressed y la herramienta dist(), la cual mide la distancia existente en una circunferencia.

Figura 13. Código para los pulsadores por software

Referencias

[1] http://users.dsic.upv.es/~jlinares/grafics/processing_spa_1.pdf

[2] http://arduino.cc/

[3] http://www.extrapixel.ch/processing/gifAnimation/