Arduino + Resolume

Para poder trabajar con Arduino y MIDI, y si no contamos con puertos MIDI (de esos
redonditos), existe una posibilidad para poder trabajar con el puerto USB que usamos con Arduino
y convertirlo “virtualmente” en un puerto MIDI.
Para ello, necesitaremos la ayuda de dos programas:
MIDI YOKE → Programa para crear puertos MIDI Virtuales.
S2Midi → Programa para convertir los datos serie que enviamos desde Arduino a datos MIDI
y enviarlos a Midi Yoke.
Ahora, lo primero que tenemos que hacer es descargarnos Midi Yoke e instalarlo en nuestro
ordenador. Para descargarlo, podemos ir a la página:
www.midiox.com
Entraremos dentro de la pestaña MIDI Yoke y pulsamos “Download”:
Ahora nos descargaremos el programa:
Nos acabamos de descargar el archivo “MidiYokeSetup.msi”. Ahora vamos a ejecutarlo
para instalarlo en nuestro ordenador. Si intentamos instalarlo, nos daremos cuenta que no
podemos (bueno, yo por lo menos no podía instalarlo en Windows Vista y 7. En Mac o Linux no sé si
dará problemas o no...). Esto es debido a que el programa estaba pensado para XP (es bastante
antiguo) y en los nuevos sistemas operativos, pues da algún problema. Después de mucho
investigar por la red, encontré este link donde explica cómo instalar el programa:
www.resolume.com/forum/viewtopic.php?f=5&t=4634
Resumiendo, lo que tenemos que hacer es:
1 → Abrir “msconfig” de nuestro ordenador. Si no lo tenemos localizado, vamos a inicio, y
en “iniciar búsqueda” escribimos el nombre y lo buscamos.
Ahora abrimos msconfig, nos vamos a la pestaña de Herramientas y “Deshabilitamos el
control de las cuentas de Usuario (UAC)”. Esta acción requiere reiniciar el ordenador. (Después de
instalar MIDI Yoke, volveremos a “Hablitar el control de las cuentas de Usuario (UAC)”, reiniciando
otra vez el ordenador).
Ahora, con el ordenador ya reiniciado, si que podremos instalar Midi Yoke. La instalación
de Midi Yoke es la típica de “siguiente, siguiente,...aceptar”. Sin embargo, cuando el asistente nos
indique que para terminar la instalación, es necesario reiniciar el equipo, en lugar de darle a
aceptar, pulsaremos “Next”.
Ahora iremos a Inicio → Panel de Control y veremos que ya tenemos Midi Yoke instalado (a
faltar de reiniciar el equipo). Abriremos MyokeNT y lo configuraremos para tener los puertos que
queramos usar, y como último paso, reiniciaremos el equipo.
Ahora vamos a buscar el segundo programa que necesitamos que es el S2MIDI. Vamos a Google,
y en el primer link que nos aparece, podemos descargar el programa que buscamos.
Tras descargar el programa S2MIDI y descomprimirlo. Podremos ver en su interior unos
ejemplos para Arduino y el programa en sí, que al abrirlo tiene esta forma.
Como ya intuimos, tanto el COM# como el Baud Rate, tiene que ser IDÉNTICO al que
definiremos en Arduino. En la pestaña de MIDI Output Port tendremos que seleccionar el puerto
que tiene que estar a la escucha de Arduino (este punto lo veremos cuando analicemos el
código). En la ventanita de la izquierda, veremos los datos que enviamos desde Arduino cuando
lo conectemos. Para establecer la conexión, es necesario pulsar el botón “Start” y dejar el
programa abierto, ya que éste es el encargado de mandar los datos MIDI a Resolume.
Ahora cargamos nuestro código de prueba en Arduino, que sería el siguiente:
void setup() {
Serial.begin(31250); // Abrimos el puerto Serie con la velocidad típica para trabajar con MIDI *
}
void loop() {
sonarNota(0x90,15,63); // Ver aclaración más abajo
delay(1000);
}
void sonarNota(char comando, char nota, char duracion){
Serial.print(comando,BYTE);
Serial.print(nota,BYTE);
Serial.print(duracion,BYTE);
}
*
→ Esta velocidad no está en las velocidades típicas del Monitor Serie de Arduino. Pero nos da
igual, porque no lo vamos a usar para leer valores.
El protocolo MIDI se basa en enviar 3 bytes:
1--> El primero es para indicar el comando a ejecutar. En este caso, 0x90 equivale a
indicarle que queremos que suene una nota. Para analizar más comandos para ejecutar,
consultar el siguiente link:
http://www.lpi.tel.uva.es/~nacho/docencia/ing_ond_1/trabajos_01_02/formatos_audio_digital/ht
ml/midiformat.htm
2 → El segundo sirve para indicarle qué nota queremos que suene. En la siguiente imagen,
se pueden ver las 128 notas que existen para MIDI. Desde 0 que equivale a (C0 = 8,17 Hz) hasta
127 que equivale a (G10 = 12543,89 Hz). En este ejemplo, estamos enviando la nota D# (15).
Como se puede apreciar, estamos usando la notación musical alfabética americana. En la
imagen siguiente se puede apreciar la correlación con la notación tradicional.
3 → El tercer byte sirve para indicarle la duración de tiempo (en milisegundos) que
queremos que esté sonando la nota elegida con el byte anterior.
Una vez explicado el código, lo compilamos y subimos a nuestro Arduino. Una vez subido,
podemos cerrar Arduino, pero NO podemos quitar el cable USB, porque sino no podríamos enviar
los datos. Ahora abrimos el programa S2MIDI y lo configuramos para que esté a la escucha de
Arduino.
En la pestaña de MIDI Output Port, elegimos uno de los dos puertos que hemos habilitado
cuando instalamos MIDI Yoke. En este caso es el UNO. Y, lógicamente, COM Port y Baud Rate serán
idénticos a los definidos en Arduino. Ahora sólo queda pulsar “Start” para empezar a recibir datos.
En la ventana de la izquierda podemos ver nuestra nota enviándose en formato MIDI.
Hemos colocado un delay(1000) para verlo más claro.
Una vez establecida la conexión, buscaremos el programa Resolume que es donde vamos
a poder apreciar todo el trabajo anterior. El programa S2MIDI NO lo cerraremos, ya que sino, se
rompería la conexión y Resolume no podría recibir nada.
La misma página oficial de Resolume nos permite descargarnos su programa con una
licencia Demo que nos dejará una marca de agua en la visualización y una voz robótica en el
sonido, pero para lo que queremos hacer, nos vale de sobra, así que nos descargaremos
Resolume en el siguiente link:
http://www.resolume.com/download/
La instalación de Resolume Avenue es la típica de “siguiente, siguiente....aceptar”, no tiene
ninguna complicación.
Esta será la ventana que veremos al abrir Resolume Avenue y antes de marearnos con
tantas pestañas, sliders y demás, podemos aprender un poquito de Resolume con el siguiente
tutorial:
http://rapidshare.com/#!download|562|153680088|manual_resolume_3_cat.pdf|1266
La comunidad catalana de VJ es muy activa, por lo que el manual está en catalán, pero
no creo que tarde mucho en estar en castellano.
Como os podéis imaginar un programa para realizar sesiones de VJ en directo, pues tiene
una complejidad elevada, pero nosotros vamos a hacer sólo un pequeño ejemplo, que va a ser
conectar 2 potenciómetros a 2 pines analógicos de Arduino y con los datos que enviemos,
modificar la opacidad de dos loops de video que tengamos en Resolume.
Para ello, nos vamos a la carpeta donde tenemos el S2MIDI y modificando un poco el
ejemplo de Arduino de envío de una señal analógica, podríamos tener algo como esto:
// Variables para el Potenciómetro 1
int canalMidi_1 = 1;
// Usaremos el canal 1 de MIDI Yoke
int potPin_1 = 0;
// Pot_1 conectado al pin analógico 0
int ultimaMedidaPot_1;
// Variable para guardar la última medida del Pot_1
int suavizadoPot_1 = 2;
// Factor de suavizado para el Pot_1
int lecturaPot_1;
// Variable para guardar la lectura del Pot_1
// Variables para el Potenciómetro 2
int canalMidi_2 = 1;
// Usaremos el canal 1 de MIDI Yoke
int potPin_2 = 1;
// Pot_2 conectado al pin analógico 1
int ultimaMedidaPot_2;
// Variable para guardar la última medida del Pot_2
int suavizadoPot_2 = 2 ;
// Factor de suavizado para el Pot_2
int lecturaPot_2;
// Variable para guardar la lectura del Pot_2
void setup() {
Serial.begin(31250);
}
// Abrimos el puerto Serie con la velocidad típica para trabajar con MIDI
void loop() {
Pot_1();
// Enviamos la lectura del Pot_1
Pot_2();
// Enviamos la lectura del Pot_2
}
void Pot_1() {
// Dividimos la lectura entre 8 para adecuar el rango del pot [0-1023] al rango MIDI [0-127]
lecturaPot_1 = analogRead(potPin_1)/8;
// Comparamos la nueva lectura con la última guardada y si es mayor que el factor de suavizado …
if (abs(lecturaPot_1 - ultimaMedidaPot_1) > suavizadoPot_1) {
// Guardamos la nueva última lectura
ultimaMedidaPot_1 = lecturaPot_1;
// Mandamos la nueva última lectura vía MIDI a Resolume. Obsérvese que enviamos un 10 como
nota. La nota sinceramente, nos da igual...lo que nos importa es enviar el último byte!!!!
envioNuevaLectura ( canalMidi_1 , 10 , lecturaPot_1 );
}
}
void Pot_2() {
// Dividimos la lectura entre 8 para adecuar el rango del pot [0-1023] al rango MIDI [0-127]
lecturaPot_2 = analogRead(potPin_2)/8;
// Comparamos la nueva lectura con la última guardada y si es mayor que el factor de suavizado …
if (abs(lecturaPot_2 - ultimaMedidaPot_2) > suavizadoPot_2) {
// Guardamos la nueva última lectura
ultimaMedidaPot_2 = lecturaPot_2;
// Mandamos la nueva última lectura vía MIDI a Resolume. Observes que enviamos un 127 como
nota. La nota sinceramente, nos da igual...lo que nos importa es enviar el último byte!!!!
envioNuevaLectura ( canalMidi_2, 127 , lecturaPot_2 );
}
}
void envioNuevaLectura(byte canal, byte controlador, byte valor) {
// Le sumamos al canal “0xB0” para indicarle que se ha detectado una nueva lectura.
mensajeMidi(canal+0xB0, controlador, valor);
}
// Mensaje Midi que mandamos con un comando, una nota y una duración
void mensajeMidi(byte comando, byte nota, byte duracion) {
Serial.print(comando, BYTE);
Serial.print(nota, BYTE);
Serial.print(duracion, BYTE);
}
Antes de pasar a Resolume, me gustaría hacer una observación. El factor de Suavizado de
ambos potenciómetros sirve para evitar el ruido de estos elementos. Se puede ampliar o reducir
según la calidad de los potenciómetros que estemos usando.
Ahora compilaremos este código y lo cargaremos en nuestro Arduino. Una vez realizado
esto, procederemos a abrir el programa S2MIDI, lo configuraremos como ya hemos comentado
en el ejemplo anterior y comprobaremos que los datos se envían correctamente. Deberíamos ver
algo así:
Se puede apreciar como cuando la nota es 10, es porque usamos el Pot_1 y cuando la
nota es 127, usamos el Pot_2.
Una vez comprobado que todo funciona correctamente, abriremos Resolume Avenue. Y
nos iremos al menú Avenue → Preferences y abriremos la pestaña MIDI. Ahora habilitaremos el
canal por el que Arduino está mandando datos (como se puede ver en la imagen anterior, se
trata del canal 1). Deberíamos ver algo así:
Una vez comprobado que Resolume está a la escucha de los datos de Arduino,
cargaremos 2 loops de video en capas separadas (esto se hace localizando en el buscador una
carpeta donde tengamos 2 loops de videos y arrastrándolos a las columnas de dos capas
distintas). En la siguiente imagen, se puede ver como cargo el primer loop.
Se puede ver a la derecha de la imagen el buscador para localizar videos en nuestro
equipo, como he seleccionado uno y lo he arrastrado hasta la Columna 1 de la Capa 2. El
segundo video lo cargaremos de forma análoga, pero en la Capa 1.
Una vez que tengamos los videos colocados en sus respectivas capas, nos iremos al menú
Mapping → Edit Composition MIDI Map.
Cuando lo pulsemos, veremos que todo se nos ilumina de amarillo. Esto nos indica que
opciones de Resolume Avenue, respecto a los videos que hemos cargado, podemos mapear con
los datos que vamos a enviar desde Arduino, ahora convertidos en datos MIDI. Deberíamos ver
algo así:
Como hemos comentado anteriormente, nuestro objetivo es controlar la opacidad de los
videos según los valores de los 2 potenciómetros desde Arduino. Si observamos la imagen anterior,
vemos que el slider que controla la opacidad se encuentra en la segunda ventanita de la parte
inferior (desde la izquierda). Pues, para que con el dato que nos envía Arduino del primer
poteciómetro podamos modificar la opacidad del video insertado en la capa 2 (ver imagen
anterior), lo único que tenemos que hacer es pinchar sobre el slider de la opacidad y mover el
potenciómetro, ya que según el código de Arduino, sólo mandamos un nuevo valor, cuando se
detecta un cambio en la lectura del potenciómetro. Deberíamos ver algo así:
Observemos como sobre el slider de la opacidad del video en la capa 2, han aparecido
unos numeritos en blanco. Esto nos indica que el mapeo ya está realizado. Podemos ver en la
parte superior que los mismos numeritos aparecen sobre otro slider. Esto es debido a que por
motivos de atajos y similares el control de la opacidad se puede realizar desde varios lugares.
Ahora nos iremos a la capa 1 y mapearemos la opacidad del otro video de la misma forma.
Recuerdo que para realizar estos mapeos es imprescindible que el programa S2MIDI esté abierto y
leyendo los datos que le envía Arduino.
Una vez que tengamos la opacidad de los dos videos mapeada, procederemos a finalizar
el mapeo, por lo que volveremos al menú Mapping → Stop Mapping y la pantalla de Resolume
volverá a su estado normal.
Ahora, ya sólo nos queda ir al Timeline de ambos videos y darle al “Play” y empezar a jugar
con la opacidad de los videos desde los potenciómetros. Si queremos modificar el mapeado que
hemos realizado, sólo tendremos que irnos a menú Mapping → Edit Composition MIDI Map,
situarnos encima del elemento que hemos mapeado (y queremos devolverle el control a
Resolume), pulsar botón derecho y seleccionar “clear shortcut”. Después podemos asignar el
potenciómeto a otro parámetro o no. Para finalizar, iremos al menú Mapping → Edit Composition
MIDI Map → Stop Mapping.
Este es un ejemplo muy sencillo de conexión Arduino + Resolume Avenue, pero la gente
que trabaja como VJ seguro que ya estará pensando en construirse una controladora MIDI casera
con Arduino y poder controlar multitud de efectos, eventos, pistas de audio,...