sábado, 14 de septiembre de 2013
SAXOFÓN EN PROCESSING
SAXOFÓN EN PROCESSING
Armando
Camacho
1Ingeniería Electrónica,
Facultad de Ingeniería
Universidad del Magdalena
Para este proyecto, se desea
es realizar de manera muy sencilla la
creación de una interfaz capaz de simular un instrumento musical, para este
caso el saxofón, para ello se utilizará el software Processing 2.0 el cual nos
permite esto sin tener un amplio conocimiento sobre programación.
La primera parte a explicar
es la ventana con la cual el usuario tendrá acceso:
En esta podemos ver las
diferentes notas naturales expresadas en el saxofón. Además observamos el
instrumento y las variaciones de las notas con respecto al teclado, es decir,
la interacción se produce por el teclado del computador cuando se utiliza una
de las teclas estipuladas en el código esta genera una nota musical la cual es
visible por el usuario de la siguiente manera.
Generando una nota musical
mientras se oprime la tecla indicada, esto con la finalidad de facilitar la
interacción del usuario con el instrumento ya que físicamente este es muy
complicado de utilizar por la gran cantidad de agujeros a manejar:
Una vez conocida la interfaz
se procederá a la explicación del código utilizado en el software Processing
2.0.
En la primera pare del
código podemos ver lo que es la declaración de variables enteras y booleanas
también se logra apreciar la declaración de la librería Maxim_Java_api mediante
Maxim Maxim; y la declaración de Do, Re,
Mi, Fa… etc como variables para almacenamiento del audio y Pfont para la aparición
de fuente por encima de la imagen.
En segunda instancia nos
encontramos con el void setup(); en el cual declararemos mediante la función
size el tamaño de la ventana que verá el usuario. Img es una variable utilizada
para cargar la imagen de fondo, background se utiliza para realizar un relleno
grisáceo el cual estará por debajo de la imagen de fondo. Mediante Font
cargamos una fuente la cual creamos nosotros mismos desde el mismo processing de
la siguiente manera:
Una vez realizado este procedimiento se
selecciona la fuente actual y se carga Do, Re, Mi,… etc. Con los archivos de
audio correspondientes para así acabar con el void setup();
Para esta parte lo que se
desea es comenzar a dibujar o a imprimir lo que uno quiere que el usuario vea.
Mediante la función println se imprimen las coordenadas del mouse para ser
visualizadas por el programador para así tener un buen sentido de orientación
en la ventana del usuario
Luego se imprimen las notas
con la función text la cual nos permite incluir cualquier palabra con su
ubicación por encima de la imagen. Y ellipse que es una función como su nombre
lo indica para creación de este tipo de forma que le permitirá al usuario saber
la noa que está tocando.
Para la siguiente pare del
void draw(); se coloca la una condición que nos asegurará que cuando no se
pulse ninguna letra las notas se detengan y se repitan para que cuando sean
pulsadas arranquen desde cero. Este procedimiento se hace ara cada una de
ellas, Y se imprimen como se mostró anteriormente otra vez los círculos.
Luego se preguntará por la
letra pulsada y dependiendo del tipo de letra se pondrá a reproducir el sonido
que está guardado en cada una de las variables de audio. Este paso se realiza
para cada una de las notas musicales que se van a tratar, es decir para las
naturales.
Arpa electronica PROCESSING+ARDUINO
| Arpa Electrónica En Processing y Arduino |
|
Pomares Hernández Hugo
Alberto
Ingeniería Electrónica,
Facultad de Ingeniería Universidad del Magdalena |
Resumen— En el siguiente informe se muestra el uso adecuado de processing, un
lenguaje de programación y entorno de desarrollo integrado de código abierto
basado en java, además del uso de este para la realización de interfaz gráfica
para la producción
de proyectos multimedia e interactivos de diseño digital.
Otros de los puntos importantes de este escrito es principalmente la
realización de un arpa electrónica con el fin de tener una herramienta virtual
en la cual se puede interactuar con el instrumento sin necesidad de tenerlo
físicamente como tal y así aprender tener habilidades y destrezas en la
herramienta musical.
Además explicar detalladamente como se lleva a cabo la realización con
sus respectivos códigos de este instrumento musical.
Palabras Claves—processing, arpa,
multimedia, instrumento.
Abstract— The following report shows the proper use of processing, a programming
language and integrated development environment based on open source java, and
use this to perform graphical interface for producing multimedia projects and
interactive digital design.
Other important points of
this paper is mainly conducting electronic harp in order to have a virtual tool
in which you can interact with the instrument without physically having it as
such and learn to have abilities and skills in the tool musical.
Spell addition
is performed as the embodiment with the respective codes of the musical
instrument.
Index Terms— processing,
harp, multimedia, instrument.
I. Introducción
En el siguiente documento se describe la realización de una interfaz
gráfica de un instrumento musical conocido como el arpa aplicando los
conocimientos de processing manejando un lenguaje de programación basado en
java, la importancia de este propósito es que la interacción que hay con el
usuario y la interfaz será de una manera fácil y dinámica en los cuales la
persona tendrá una manera distinta de manejar un instrumento musical.
Uno de los principales factores de este informe es que se tenga
claramente el uso debido de las diferentes sentencias para la creación de este
proyecto y así tener una mayor contexto de la realización de futuras
aplicaciones en esta fuente de lenguaje abierta de lenguaje de programación y
entorno de desarrollo integrado.
Processing es una herramienta para no programadores la cual la hace más
versátil a la hora de manejar.
II. Marco teórico
El arpa
es un instrumento de
cuerda pulsada compuesto por un
marco resonante y una serie variable de cuerdas tensadas entre la sección
inferior y la superior. Las cuerdas pueden ser pulsadas con los dedos o con una
púa o plectro. Además del arpa
clásica, usada actualmente en las orquestas,
existen otros tipos, como el arpa celta y el arpa paraguaya.
El arpa es
el instrumento musical nacional de Irlanda, Paraguay y Perú.
Se puede dividir el arpa europea en dos
modelos:
Arpa medieval, (de origen
irlandés), también conocida como arpa bárdica.
No superior a los 75 cm de altura y de afinación diatónica, cuerdas
metálicas, ornamentalmente rica en tallas, dibujos e incrustaciones de metal.
En la actualidad aún se tienen dos ejemplos claros, uno es el arpa del rey Brian Boru (muerto en 1014) que se puede encontrar en el Museo de Dublín, y otra es el arpa de
la reina Mary de escocia, en el Museo
Nacional de Edimburgo.
Arpa celta (de origen galés), puede
tener hasta 105 cm de altura, 34 cuerdas y con la posibilidad de
incorporar sistemas de semitonos.
Ambas tienen el pilar curvado y su caja de
resonancia se ensanchaba en las cuerdas graves
El arpa medieval era diatónica, y el arpa moderna, por el
contrario, nació con los primeros intentos de cromatismo que la evolución de la música
occidental exigía. Los primeros intentos surgieron de los talleres de luthiers
irlandeses en el siglo XVI, que
proveyeron al arpa de una doble fila de cuerdas. En el siglo XVII se incorpora una tercera fila, la 1ª
la 3ª fila eran diatónicas (29 cuerdas cada fila) mientras que la 2ª fila,
con 20 cuerdas, estaba reservada para los semitonos.
A mediados del XVII unos constructores
tiroleses inventaron el arpa de ganchos, con los cuales era posible estirar la
cuerda y subirla un semitono. En esta época fueron muchos los mecanismos
incorporados para subir el tono, pero todos accionados manualmente, por lo que
debían hacerse antes de empezar la interpretación.
A finales del siglo XVII, lutier bávaro fabricó la primera arpa con
pedales que situados a ambos lados del soporte del instrumento, estaban unidos
a los ganchos fijos de la consola mediante un sistema de transmisión. Eran
siete los pedales, correspondientes a los siete grados de la escala
musical y para cuyo instrumento Mozart escribió su Concierto
para flauta y arpa en 1778. A raíz del descubrimiento se
inspiraron numerosas ideas a cual más estrafalarias para ampliar las
posibilidades del arpa (como fue la colocación de doble número de pedales y sordinas), pero el mayor éxito lo
obtuvo S. Erard en 1811. Erard
presentó el modelo llamado de «doble acción» que, con ligeras modificaciones
posteriores, es la que se usa normalmente en la actualidad.
El arpa se usa ampliamente en la música académica, normalmente para
efectos como el glisando o los arpegios. En la ópera italiana y alemana se usa para arias románticas y bailes, como el «Vals de Musetta» en La
bohème. Compositores franceses como Claude
Debussy y Maurice Ravel compusieron conciertos para arpa y música de cámara que se siguen interpretando. Durante
el siglo XIX, el compositor y
arpista francés Nicolas Bochsa
compuso cientos de piezas de todo tipo (transcripciones de ópera, música
de cámara, conciertos, óperas, métodos para el arpa).
Los arpistas del siglo XX Henriette Renié y Marcel
Grandjany compusieron muchos
solos y piezas de cámara que figuran en el repertorio de arpa. Los compositores
modernos utilizan el arpa con frecuencia porque los pedales de un arpa de
concierto permiten toda clase de escalas y sonidos con efectos, aunque algunas
piezas modernas requieren mucho uso del pedal.
Processing es un lenguaje de programación
de código abierto y el medio ambiente para las personas que quieren programar
imágenes, animaciones y sonido. Es utilizado por estudiantes, artistas,
diseñadores, arquitectos, investigadores y aficionados para el aprendizaje,
creación de prototipos y producción. Se creó para enseñar a los fundamentos de
la programación informática dentro de un contexto visual y para servir como un
cuaderno de bocetos de software y la herramienta de producción profesional.
Processing es desarrollado por artistas y diseñadores como una alternativa a
las herramientas de software propietario en el mismo dominio.
La Interfaz de Processing es sencilla. Esto permite que uno pueda
familiarizarse con ella muy rápidamente. Si la comparamos con la complejidad de
interfaces como las de Flash o Director, la diferencia es muy considerable.
Cuando creamos un proyecto nuevo en Processing, creamos un Sketch, y el Sketch folder es la carpeta donde éste se guarda. En
principio, el Sketch consta tan solo de la misma carpeta y de un archivo .pde que contiene el código. Luego se
pueden añadir carpetas para archivos de imagen, video, etc.
RUN: Sirve para ejecutar el código. Con la mágia de este simple botón nos ahorramos lo que en programación se conoce como compilación.
STOP: Para el programa
NEW: Crea un Sketch nuevo
OPEN: Abre un Sketch existente
SAVE: Guarda el Sketch con el que se está
trabajando. Hay que utilizarlo mucho, por si acaso, pero aún más utilizar el
"Save as" (ctrl+shift+s) para ir guardando versiones mientras
trabajamos en nuestros proyectos.
EXPORT: Sirve para preparar el sketch para ser
ejecutado a través de un navegador, ya sea en la web o simplemente fuera del
entorno Processing.
Tan sólo conociendo estos botones de la interfaz (y el siempre
útil “save as”) tenemos bastante como para empezar a trabajar con Processing, y
posiblemente no necesitemos nada más durante estas primeras sesiones.
III.
Montaje experimental
A
continuación se mostraran los pasos realizados para la realización de este
proyecto:
En
la siguiente parte del código (Figura.1) se refleja la declaración de las
variable deck1x y deck1y que son las coordenadas donde estará ubicada la imagen
de la interfaz, luego se declara como booleano deck1Playing se coloca false
para no generar un ciclo infinito en la reproducción del audio, después
colocamos como entero una variable a la que le vamos a asignar un ancho
respectivo para la imagen, declaramos el nombre de la variable en la cual vamos
a cargar la imagen, importamos la librería MaximJava como se ve en la quinta
línea “Maxim maxim”, que es una librería encargada de la producción de sonidos
.wav. y al finalizar declaramos las variables con en las cuales va a ir cargado
el sonido.
Figura.1
En
la (Figura.2) void setup sirve para definir el tamaño de la ventana, el sonido
y la imagen de nuestra interfaz gráfica. Size sirve para colocarle el tamaño a
la ventana de la aplicación. image Mode sirve para elegir el centro de la
imagen, con load image que es una librería que sirve para el procesamiento de
imágenes lo que se hace es cargar la imagen en este caso “arpa2.png,
maxim.loadFile lo que hace es asignar el sonido para que se reproduzca y
setlooping es para hacer que el ciclo del sonido sea o no repetitivo, si se
coloca “true” se repite el tono una y
otra vez si se coloca “false” suena el tono, termina y no se repite.
Figura.2
En la (Figura.3) se utiliza el
background para colocar un fondo a la interfaz en este caso 255 que se refiere
al color blanco y el .volume se utiliza para aumentar de volumen el tono.
En
la (Figura.4) el void draw sirve para ajustar la imagen en la ventana de la
interfaz, con el background se elige el color de fondo, en imageMode elijo el
centrado de la imagen, en deck1x y deck1y arreglo las coordenadas en las cuales
quiero que este ubicada la imagen y el println sirve para que al momento de que
se pase el mouse por medio de la imagen me refleje las coordenadas, y así sea
más fácil trabajar.
Figura.4
En la (Figura.5) el voida
mousedDragged sirve para que cuando el mouse este sostenido y pase por la
coordenada de la imagen reproduce el tono, el if sirve para preguntar que
cuando este en esa parte del codigo en el eje de las x y en el eje de las y, se
represente el tono.
Figura.5
En la (Figura.6) se observa como
queda la intefaz grafica la cual se ejecuta presionando la tecla
"play" y para detener la aplicación se
presiona el boton
"stop".
para la utilizacion de arduino insertamos en processing la libreria de arduino como se muestra en la (Figura.7)
Figura.7
para inicializar los pines en arduino se hace se la siguiente manera en la (Figura.8)
Figura.8
se debe usar en la sentencia del if la palabra "arduino.digitalRead(pin2)==Arduino.HIGH" así como se ve en la siguiente figura (Figura.9).
Figura.9
se colocan los pones del programa como entradas (Figura.10).
Figura.10
ANEXOS
EN LA SIGUIENTE IMAGEN SE MUESTRA LA IMPLEMENTACIÓN DEL PROCESSING+ARDUINO.
REFERENCIA
Timables (arduino-processing)
Objetivo: Realizar una interfaz grafica que permita emular los timbales como instrumento muscial y conjuntamente se realize la comunicacion directa con arduino.
Inicialmente no se necesitan conocimientos previos del sofware processing ya que al transcurrir del desarrollo del proyecto y con un poco de investigación se lograran aclarar dudas ya que este sofware es libre y permite realizar aportes y correciones del mismo si se logra captar alguna, al ser gratuito da muchas ventajas porque permite tomar codigos ya realizados y utilizarlos para el desarrollo del proyecto a realizar, de manera ilutrastiva se muestran las interfaces graficas que manejan arduino y processing.
.jpg)
//comunicacion serial arduino processing
import processing.serial.*; // se importa la libreria de processing para comunicacion serial
import cc.arduino.*; // se importa la libreria de arduiono para processing
Arduino arduino;
int Pin1= 12; // se declaran variables para asignar los puertos del arduino
int Pin= 13;
//int Pin2= 11;
//int Pin3= 10;
//int Pin4= 9;
//final configuracion comunicacion serial
Maxim maxim; // se carga la libreria Maxim para reproducir audios
AudioPlayer player1; // se declaran las variables para asignar el audio requerido
AudioPlayer player;
AudioPlayer player2;
AudioPlayer player3;
AudioPlayer player4;
AudioPlayer player5;
AudioPlayer player6;
AudioPlayer player7;
AudioPlayer player8;
PImage Stivenson; // se carga la imagen por medio de la variable stivenson
int x;
void setup()
{
println(Arduino.list()); // imprime la lista de los puertos com
arduino = new Arduino(this, Arduino.list()[1], 57600); // se escoge la lista de los puertos com reconocidos por processing y la velicidad de transmisión
arduino.pinMode (Pin, Arduino.INPUT); // se declaran los puertos del arduino como entrada
arduino.pinMode (Pin1, Arduino.INPUT);
// arduino.pinMode (Pin2, Arduino.INPUT);
// arduino.pinMode (Pin3, Arduino.INPUT);
// arduino.pinMode (Pin4, Arduino.INPUT);
size(800,600); // de cargan los pixeles de la pizarra preferiblemente los pixeles de la imagen
Stivenson= loadImage("timbales.jpg");
maxim= new Maxim(this);
/// cargar sonidos altos de los timables
player= maxim.loadFile("Timbale1.wav");
player1= maxim.loadFile("Timbale2.wav");
player2= maxim.loadFile("Timbale3.wav");
player3= maxim.loadFile("Timbale4.wav");
player4= maxim.loadFile("Timbale5.wav");
player5= maxim.loadFile("Timbale6.wav");
player6= maxim.loadFile("Timbale7.wav");
player7= maxim.loadFile("Timbale8.wav");
player8= maxim.loadFile("Timbale9.wav");
player.setLooping(true);
player1.setLooping(true);
player2.setLooping(true);
player3.setLooping(true);
player4.setLooping(true);
player5.setLooping(true);
player6.setLooping(true);
player7.setLooping(true);
player8.setLooping(true);
}
void draw() {background(Stivenson);
println( pmouseX);// imprime la posicion en x del mouse si se llega a utilizar
println( pmouseY);
if (arduino.digitalRead(Pin)==Arduino.HIGH){// de esta manera se pregunta por el estado del pin del arduino y se realizan los condicionales necesarios.
ellipse(160, 107, 75, 55);
player8.play(); }
else{
player8.stop();}
if (arduino.digitalRead(Pin1)==Arduino.HIGH){
ellipse(350, 107, 75, 55);
player4.play(); }
else{
player4.stop();}
}
nota: la libreria maxim solo recibe audios .wav, se bede cargar la libreria de arduino para processing ya que si no se realiza este paso generara errores al compilar el codigo.
se puede concluir que la experiencia fue importante ya genero errores que fueron solucionados a tiempo como la libreria que generaba errores al establecer la comunicacion con el arduino y los .wav que recibe la libreria maxim.
CONGAS (PROCESSING - ARDUINO)
CONGAS (Processing - Arduino)
El objetivo principal de este documento es dar una breve explicacion sobre como desarrollar una interfaz grafica que emule un instrumento musical por medio del sofware Processing y a su ves que este se complemente con Arduino logrando que exista interaccion del ser humano con el proyecto adesarrollar.
Para el desarrollo de esta experiencia no es necesario saber cual es funcionamiento exacto del instrumento, por ello los sonidos necesitados se extraen de la web, cabe aclarar (no todas las librerias de processing admiten todos las de audio), luego de adquirir los archivos necesarios en este caso estos con extension .wav ya que se trabaja con la libreria Maxim Yava cuya caracteristica principal es que solo acepta archivos con dicha extensión, la interfaz grafica a utilizar es basicamente una imagen que se carga por el sofware Processing.
Incialmente se realiza la programacion en el sofware processing para adquirir experiencias con el mismo a continuacion se carga el codigo y explicación del mismo:
 |
| Imagen de Sofware Processing |
// se cargan librerias y se asignan variables
Maxim maxim;
AudioPlayer player;
PImage Mai;// libreria Maxim java, la variable player que guardara el sonido y PImage carga la imagen a la variable Mai
AudioPlayer player;
PImage Mai;// libreria Maxim java, la variable player que guardara el sonido y PImage carga la imagen a la variable Mai
//
void setup()
{ size(512,307); // se definen los pixeles preferiblemente los de la imagen a utilizar
Mai= loadImage("conga.jpg"); // se carga la imagen .jpg a la variable Mai
maxim= new Maxim(this);
player= maxim.loadFile("mykbeat.wav"); // se carga el sonido a la variable player
player.setLooping(true); }
void setup()
{ size(512,307); // se definen los pixeles preferiblemente los de la imagen a utilizar
Mai= loadImage("conga.jpg"); // se carga la imagen .jpg a la variable Mai
maxim= new Maxim(this);
player= maxim.loadFile("mykbeat.wav"); // se carga el sonido a la variable player
player.setLooping(true); }
//
void draw() {
background(Mai); // se dibuja la imagen por medio de la variable Mai
println( pmouseX);
println( pmouseY);} //estas dos instrucciones sirven para visualizar en el panel inferior la posicision en (x) e (y)
background(Mai); // se dibuja la imagen por medio de la variable Mai
println( pmouseX);
println( pmouseY);} //estas dos instrucciones sirven para visualizar en el panel inferior la posicision en (x) e (y)
void mousePressed(){ // en este punto se ejecutan todas las condiciones requeridad o condicionadas por el mouse
player.cue(0);
if (mouseX >=130 && mouseX <=190 && mouseY>=90 && mouseY<=125 ) { // en este condicional se pregunta por las posiciones en x e y del mouse dependiendo de estas se dibujas una elipse y se reproduce el sonido
ellipse(160, 107, 75, 55);
player.play(); }
else{
player.stop();} }
player.play(); }
else{
player.stop();} }
if (mouseX >=100 && mouseX <=120 && mouseY>=60 && mouseY<=148 ) {
buttonOn = !buttonOn;
if (buttonOn){
ellipse(160, 107, 75, 55);
player.play(); }
else{
player.stop();}
buttonOn = !buttonOn;
if (buttonOn){
ellipse(160, 107, 75, 55);
player.play(); }
else{
player.stop();}
if (mouseX >=121 && mouseX <=195 && mouseY>=135 && mouseY<=162 ) {
buttonOn = !buttonOn;
if (buttonOn){
ellipse(160, 107, 75, 55);
player.play(); }
else{
player.stop();} }
if (mouseX >=196 && mouseX <=220 && mouseY>=60 && mouseY<=148 ) {
buttonOn = !buttonOn;
if (buttonOn){
ellipse(160, 107, 75, 55);
player.play(); }
else{
player.stop();}}
if (mouseX >=121 && mouseX <=195 && mouseY>=45 && mouseY<=75 ) {
buttonOn = !buttonOn;
if (buttonOn){
ellipse(160, 107, 75, 55);
player.play(); }
else{
player.stop();}}}
buttonOn = !buttonOn;
if (buttonOn){
ellipse(160, 107, 75, 55);
player.play(); }
else{
player.stop();} }
if (mouseX >=196 && mouseX <=220 && mouseY>=60 && mouseY<=148 ) {
buttonOn = !buttonOn;
if (buttonOn){
ellipse(160, 107, 75, 55);
player.play(); }
else{
player.stop();}}
if (mouseX >=121 && mouseX <=195 && mouseY>=45 && mouseY<=75 ) {
buttonOn = !buttonOn;
if (buttonOn){
ellipse(160, 107, 75, 55);
player.play(); }
else{
player.stop();}}}
nota: los demas condicionales cumplen la misma función solo cambian las posiciones del mouse.
Despues de adquirir un poco de conocimiento solo falta ensayar un poco sobre como entrelazar arduino & processing realamente la unica complicacion que se tuvo fue por la libreria que no se habia cargado pero del resto todo funciona correctamente, pero cabe anotar que la funcion Maxim Java no es la mas eficiente al reproducir un sonido con alta calidad y fidelidad, como primera medida se debe contar con el sofware Arduino para configurar el hardware:
 |
| sofware arduino |
inicialmente se debe conectar el arduino configurar su tarjeta y el puerto com luego como se ve en la figura del sofware arduino se ubica en los ejemplos-firmata-standar firmata, luego de abrir el ejemplo lo cargamos al arduino cuando se complete la carga se cierra el sofware y el arduino ya se encuentra programado para entralazarse serialemnte con el processing, acontinuacion el sofware en procesing con la comunicacion necesaria para recibir y enviar datos hacia y desde el arduino:
//comunicacion serial arduino processing
import processing.serial.*; // se importa la libreria de processing para comunicacion serial
import cc.arduino.*; // se importa la libreria de arduino para processing
Arduino arduino; // se ha
int Pin1= 12;
int Pin= 13;
//final configuracion comunicacion serial
Maxim maxim;
AudioPlayer player1;
AudioPlayer player;
AudioPlayer player1;
AudioPlayer player;
PImage Mai;
void setup()
{println(Arduino.list()); //se imprimen las listas de los puertos com instaldos y que reconoce processing
arduino = new Arduino(this, Arduino.list()[1], 57600); // nuevo arduino conectado el [1] indica que processing reconoce el puerto com con ese numero especialmente
arduino.pinMode (Pin, Arduino.INPUT);
arduino.pinMode (Pin1, Arduino.INPUT);// se definen los pines pin, pin1 como entrada deben hacerse en mayuscula
size(512,307);
Mai= loadImage("conga.jpg");
maxim= new Maxim(this);
player= maxim.loadFile("Congas03.wav");
player1= maxim.loadFile("Congas07.wav");
{println(Arduino.list()); //se imprimen las listas de los puertos com instaldos y que reconoce processing
arduino = new Arduino(this, Arduino.list()[1], 57600); // nuevo arduino conectado el [1] indica que processing reconoce el puerto com con ese numero especialmente
arduino.pinMode (Pin, Arduino.INPUT);
arduino.pinMode (Pin1, Arduino.INPUT);// se definen los pines pin, pin1 como entrada deben hacerse en mayuscula
size(512,307);
Mai= loadImage("conga.jpg");
maxim= new Maxim(this);
player= maxim.loadFile("Congas03.wav");
player1= maxim.loadFile("Congas07.wav");
player.setLooping(true);
player1.setLooping(true);
}
player1.setLooping(true);
}
void draw() { // los condicionales deben hacerse por el void draw es donde se realizan los ciclos
background(Mai);
println( pmouseX);
println( pmouseY);
background(Mai);
println( pmouseX);
println( pmouseY);
if (arduino.digitalRead(Pin)==Arduino.HIGH){ // de esta manera especialmente se pregunta por el estado de los pines del arduino y se ejecutan los condicionales
ellipse(160, 107, 75, 55);
player.play(); }
else{
player.stop();}
if (arduino.digitalRead(Pin1)==Arduino.HIGH){
ellipse(350, 107, 75, 55);
player1.play(); }
else{
player1.stop();}
}
ellipse(160, 107, 75, 55);
player.play(); }
else{
player.stop();}
if (arduino.digitalRead(Pin1)==Arduino.HIGH){
ellipse(350, 107, 75, 55);
player1.play(); }
else{
player1.stop();}
}
nota: debe importarse por el skecth la libreria de arduino para procesing ya que sino la tiene por mas que se importe por el (import) genera errores si no la encuentra.
Se puede concluir que se logro con el objetivo planteado ya que fue muy buena experiencia recomiendo a las proximas personas que tengan algun trabajo de esta indole lo realicen con la mayor confiabilidad y les aseguro que aprenderan demasiado.
Proyecto
control 1: Aplicación acordeón con Processing y Arduino
Jiménez Juan
Carlos COD. 2010119031
GRUPO 2
Ingeniería Electrónica,
Facultad de Ingeniería
Universidad del Magdalena
Resumen—Este proyecto inició con
la capacitación en el manejo de Processing el cual es una herramienta de programación
muy didáctica y útil para quienes no son grandes programadores, con la ayuda de
éste programa se creó una aplicación muy interactiva y fue una acordeón virtual
luego para complementar la experiencia se introdujo el control por hardware, en
el cual se presionan los botones de la acordeón por medio de unos pulsadores
que se comunica con Processing a través
de una placa de desarrollo Arduino, usando comunicación serial se logró
transmitir y recibir datos entre el computador y el circuito de control
externo.
INTRODUCCIÓN
En este informe se tratan los
apartes más relevantes de la aplicación Arduino-Processing, se presenta el
desarrollo y construcción del código además de los inconvenientes principales
que se encontraron durante el proceso. La importancia de éste proyecto radica
en afianzar los conocimientos sobre programación de software y hardware y la
comunicación de medios externos al computador, la utilización de Processing y
Arduino es un campo nuevo en el manejo de las herramientas debido a esto se
requiere de las fuentes oficiales y foros en la web para agilizar la
programación.
MARCO TEÓRICO
Processing es un lenguaje de
programación, entorno de desarrollo, y comunidad en línea. Desde el año 2001, Processing
ha promovido la alfabetización de software con las artes visuales y la
alfabetización visual con la tecnología. Inicialmente creado para servir como
un bloc de dibujo de software, y para enseñar los fundamentos de programación
de computadoras dentro de un contexto visual, Processing se convirtió en una
herramienta de desarrollo para los profesionales.
Por otro lado Arduino es una
plataforma de electrónica abierta para la creación de prototipos basada en
software y hardware flexibles y fáciles de usar. Se creó para artistas,
diseñadores, aficionados y cualquiera interesado en crear entornos u objetos
interactivos. Arduino puede ser utilizado para desarrollar objetos autónomos e
interactivos, como prototipos o interactuar con software instalado en el ordenador.
Dada su rápida curva de aprendizaje y su precio económico es ideal para
educadores, diseñadores y cualquiera interesado en la electrónica y robótica.
DESARROLLO DE LA APLICACIÓN
En esta parte haremos una
explicación del código en Processing con el cual se generó la aplicación cabe
destacar que mediante el compilador de arduino se programó previamente el hardware para que pudiera hacerse la
comunicación serial directamente con Processing. También es importante decir
que el código aquí explicado es el de la aplicación final pero que previa a la
inclusión de arduino se tenía un código más extenso pero también con más
errores.
Primero que todo se llamaron las
librerías necesarias en éste caso
Luego se hacen las declaraciones
de variables correspondientes, cabe destacar que AudioPlayer se usa para
declarar los sonidos que se van a reproducir
Una vez hecho lo anterior hacemos
las configuraciones necesarias primero para la comunicación serial, para imagen
de fondo y tamaño de la pantalla, luego se le asignan a variables los distintos
fragmentos de sonido y por último se hace la configuración del arduino como lo
son los pines de entrada y salida.
El último fragmento de código
corresponde a la ejecución de las acciones de control. Primero colocamos la
imagen de fondo como fondo, a continuación explicaremos un fragmento de código
usado para la reproducción de un sonido y una vez tengamos esto la acción se
vuelve repetitiva para los demás sonidos
En un sí, preguntamos si en el
pin especifico que estamos usando para determinada tecla del acordeón tiene un
alto, si tiene un alto es porque hemos presionad la tecla. Dado que se
presentaron problemas con la reproducción entonces se vuelve a configurar la
variable para asignarle el sonido e inmediatamente ponemos a reproducirla. Como
queremos saber en la pantalla cual tecla del acordeón se reprodujo entonces las
siguientes sentencias son para dibujar un rectángulo en el lugar de la tecla
por último para que la comunicación sea bilateral se enciende y apaga un led en
un tiempo determinado por un retardo. Lo anterior se repite para los restantes
siete sonidos.
Para finalizar la explicación
podemos mencionar que frecuentemente se presentaron errores como:
Array Index Out Of Bounds: Este error se presenta por la
declaración de variables ya sea de la librería debido a esto se exede la
capacidad de algún vector que me genera un desbordamiento.
NullPointerException: Esta excepción puede ser lanzada por
múltiples causas, la más habitual es que estamos intentando acceder a un
atributo de un objeto para el que todavía no hemos reservado memoria.
Además de éstos dos comunes
errores se presentaron y se pueden presentar muchos otros éstos se dan debido a
la estructura y lógica que le demos a nuestro código de programa.
En las siguientes figuras se
muestran las partes de la aplicación:
Figura 1. Esquema
general
Figura 2. Arduino
Mega 2560
Figura 3. Processing
Figura 4. Pulsadores
para controlar botones del acordeón
Figura 5 interfaz
visual
REFERENCIAS
http://www.consultoriajava.com/index.shtml
Suscribirse a:
Comentarios (Atom)