Fabrica tu propio controlador MIDI con Arduino Deja un comentario

Si eres amante de la música o directamente un músico amateur o profesional seguro que en tu hogar has ido acumulando una gran colección de instrumentos musicales. Para hacer que todo estos se mezclen a la perfección lo mejor es hacerte con un controlador MIDI. Lamentablemente este tipo de objetos suelen ser bastante caros por lo que una persona sin demasiados recursos tiene difícil acceder a todo lo que pueden llegar a ofrecer.

Para entender mucho mejor lo que es un controlador MIDI, comentarte que la palabra MIDI proviene de Musical Instrument Digital Interface, es decir, una especie de controlador que hace que los dispositivos musicales electrónicos puedan comunicarse entre sí. En caso de que tengas en tu casa, por ejemplo, un teclado electrónico, es más que probable que este posea una interfaz MIDI. Antes de continuar avanzando, a pesar de que hay ciertos detalles técnicos que pueden hacer creer lo contrario, hay que tener muy claro que MIDI no es audio.

Crea tu propio controlado MIDI con este sencillo tutorial

Una vez tenemos claro esto, seguro que te será mucho más fácil entender que MIDI tan sólo es un simple conjunto de instrucciones capaz de soportar hasta 16 canales independientes, lo que significa que puede haber hasta 16 dispositivos diferentes comunicándose independientemente entre sí. Estos dispositivos han de conectarse a través de un cable DIN de 5 patillas que básicamente es un cable con cinco pines dentro de un conector. Como detalle, es bastante común utilizar un USB en lugar de un DIN de 5 patillas, en caso de utilizar un USB debemos crear una interfaz USB-MIDI.

Sin más, te dejo con el enlace donde poder encontrar el tutorial paso a paso con una gran cantidad de imágenes descriptivas donde poder realizar todas las acciones necesarias para crear nuestro propio controlador MIDI.

Cómo fabricar tu propio controlador MIDI con Arduino

Muchas son las personas que necesitan, por diferentes motivos tanto personales como profesionales, utilizar un controlador MIDI totalmente personalizado debido a que quizá y como ejemplo, en algún momento de su vida como artista pueda que comprar un controlador MIDI económico no cumpla con las expectativas o necesidades mientras que, llegado el momento, decantarse por una versión profesional, pueda ser excesivo tanto en recursos económicos que necesitas, como en la gran cantidad de características que pueden ofrecer.

Debido a esto, hoy quiero mostrarte todo lo necesario para que puedas fabricar tu propio controlador MIDI indicando tanto todo lo necesario para su construcción como ofrecerte el software que necesitarás instalar. Como detalle, para este proyecto es fundamental el uso de una tarjeta Arduino, un controlador que es lo suficientemente potente como para llevar a cabo esta labro.

¿Que es un controlador MIDI?

Básicamente un controlador MIDI es el encargado, a grandes rasgos, de conectar diferentes dispositivos musicales entre sí. Muchos son los instrumentos que lo incorporan un interfaz MIDI aunque, esto hay que tenerlo muy claro ya que hay muchos usuarios que suelen confundirse, MIDI no es ni mucho menos un archivo de audio, sino un conjunto muy simple de instrucciones que un instrumento puede recibir para realizar diferentes ajustes de control o en los sonidos.

Dentro del MIDI existen dos tipos diferentes, por un lado tenemos el denominado como Control de Cambio donde el mismo posee el número de controlador y un valor entre 0 y 127. Gracias a esto se pueden emitir mensajes donde se pueden cambiar diferentes parámetros como el volumen o el tono. Los diferentes instrumentos que aceptan MIDI deben traer consigo un manual donde explica qué canales y mensajes se configuran de forma predeterminada y cómo cambiarlos.

En segundo lugar tenemos el Cambio de Programa, una serie de mensajes que a su vez son mucho más simples que los que conforman el Control de Cambio. Este tipo de mensajes se utilizan para cambiar el preset o el parche de un dispositivo. Al igual que en Control de Cambio, junto con tu instrumento el fabricante debe incluir un manual donde se indica qué presets se cambian por un mensaje en particular.

Piezas necesarias para construir tu propio controlador MIDI casero

Para conseguir construir tu propio controlador MIDI necesitarás una serie de piezas además, como ya hemos mencionado, de una placa Arduino. Antes de continuar, comentarte tan sólo que quizá, en un futuro debido a que quieras ampliar el proyecto, necesites más cosas aunque, en este momento con unas pocas piezas tendrás de sobra.

Necesitaremos un cable DIN de 5 polos hembra, 2 resistencias de 220 ohmios, 2 interruptores momentáneos, 2 resistencias de 10k ohmios, hilos para conexión, un tablero de circuitos, cable MIDI y un dispositivo MIDI o interfaz USB. Con tan sólo estas piezas ya podrás empezar, siguiendo mis pasos, a fabricar tu propio controlador MIDI.

Primeros pasos

Antes de empezar te dejo una fotografía donde poder ver los pines de tu cable MIDI, de esta forma podremos indentificar correctamente los pines y sobre todo dónde hay que conectar cada uno. A grandes rasgos lo único que hay que hacer en este punto es conectar el pin 5 del cable a una resistencia de 220 ohmios y de ahí al Arduino Transmit 1, el pin 4 a una resistencia de 220 ohmios y de ahí a la toma de 5V de Arduino mientras que el pin 2 hay que conectarlo a la conexión de Tierra de tu controlador.

Una vez realizado este paso, no tienes un esquema detallado en la foto que hay situada justo bajo estas líneas, llega el momento de conectar los botones. La idea en este apartado es la de conseguir, utilizando el pin digitalRead (capaz de detectar cuándo cambia el voltaje que llega al mismo) poder utilizar un transistor para conseguir, con tan sólo pulsar un botón. Para esto tan sólo tenemos que utilizar un botón de forma que, el lado izquierdo del mismo lo conectamos a 5V, el lado derecho a una resistencia de 220 ohmios y de ahí a tierra mientras que, a su vez, el lado derecho también lo conectamos al pin 6. El segundo botón se instalaría de la misma manera aunque, como puedes ver en el diagrama, en lugar de al pin 6 lo conectamos al 7.

Software a utilizar para el controlador midi casero

Una vez hemos terminado con todo el hardware, llega el momento de conectar nuestro instrumento y probar. Antes de eso necesitamos disponer de una interfaz USB-MIDI y un cable MIDI para conectar la placa, que está enviando datos, con nuestro ordenador. Para conseguir esto, nos hemos decantado por la biblioteca MIDI v4.2 creada por los chicos de Forty Seven Effects que debemos tenerla instalada en nuestra Arduino e incluida en el proyecto.

En el caso del ordenador necesitaremos un programa que sea capaz de supervisar todos los datos MIDI que llegan al mismo desde Arduino. Para esto tenemos diferentes posibilidades como puede ser Monitor MIDI (OS X), MIDI-OX (Windows) o Kmidimon (Linux)

Para hacer una pequeña prueba tan sólo tenemos que conectar la Arduino a nuestro ordenador y ejecutar el siguiente código:

#include
#include
#include
#include
#include

MIDI_CREATE_INSTANCE(HardwareSerial,Serial, midiOut); // crear objeto de salida MIDI llamado midiOut

void setup() {
Serial.begin(31250); // configuracion de serial para MIDI
}

void loop() {
midiOut.sendControlChange(56,127,1); // envío de señal MIDI CC -- 56 = nota, 127 = velocidad, 1 = canal
delay(1000); // retraso
midiOut.sendProgramChange(12,1); // envío de una señal MIDI PC -- 12 = valor, 1 = canal
delay(1000); // retraso de 1 segundo
}

Si todo ha ido bien, puedes pasar a la prueba de botones, en caso de que no te haya funcionado esta prueba debes asegurarte de que todas las conexiones son correctas, el circuito está exactamente igual al esquema anterior, el circuito está conectado a una interfaz USB-MIDI con un cable MIDI, los cables del puerto MIDI están correctamente conectados, el cable MIDI está conectado a la entrada de la interfaz USB-MIDI, la placa Arduino está correctamente conectada a la red eléctrica y le llega alimentación suficiente…

Probando que los botones funcionan correctamente

Antes de seguir alimentando nuestro programa con nuevas funcionalidades y código en el que podamos perdernos, merece la pena pararse un momento y probar que los botones funcionan correctamente. Para ellos tenemos que cargar el siguiente código:

const int boton1 = 6; // asignacion del boton a una variable
const int boton2 = 7; // asignacion del boton a una variable

void setup() {
Serial.begin(9600); // configuracion del serial
pinMode(boton1,INPUT); // configuracion del boton1 como entrada
pinMode(boton2,INPUT); // configuracion del boton2 como entrada
}

void loop() {

if(digitalRead(boton1) == HIGH) { // prueba de estado del boton1
delay(10); // retraso
if(digitalRead(boton1) == HIGH) { // prueba de estado de nuevo
Serial.println("Boton 1 funciona correctamente!"); // log
delay(250);
}
}

if(digitalRead(boton2) == HIGH) { // prueba de boton 2
delay(10); // retraso
if(digitalRead(boton2) == HIGH) { // prueba de estado de nuevo
Serial.println("Boton 2 funciona correctamente!"); // log
delay(250);
}
}

}

Este código tan sólo hay que compilarlo y ejecutarlo de forma que, con el cable USB conectado, el programa nos indique si alguno de los botones ha sido pulsado.

Creamos nuestro controlador MIDI casero

Una vez hemos ejecutado estas pruebas llega el momento de montar nuestro propio controlador MIDI para eso tan sólo tendrás que compilar el siguiente código:

#include
#include
#include
#include
#include

const int boton1 = 6; // asignamos boton a la variable
const int boton2 = 7; // asignamos boton a la variable

MIDI_CREATE_INSTANCE(HardwareSerial,Serial, midiOut); // create a MIDI object called midiOut

void setup() {
pinMode(boton1,INPUT); // configuracion del boton1 como una entrada
pinMode(boton2,INPUT); // configuracion del boton2 como una entrada
Serial.begin(31250); // configuracion MIDI de salida
}

void loop() {
if(digitalRead(buttonOne) == HIGH) { // comprobacion de estado
delay(10); // retraso
if(digitalRead(buttonOne) == HIGH) { // comprobacion de estado de nuevo
midiOut.sendControlChange(56,127,1); // envío un MIDI CC -- 56 = nota, 127 = velocidad, 1 = canal
delay(250);
}
}

if(digitalRead(buttonTwo) == HIGH) { // comprobacion de estado
delay(10); // retraso
if(digitalRead(buttonTwo) == HIGH) { // nueva comprobacion de estado
midiOut.sendControlChange(42,127,1); // envío un MIDI CC -- 42 = nota, 127 = velocidad, 1 = canal
delay(250);
}
}
}

Como detalle, comentarte que no puedes utilizar en esta ocasión la orden Serial.println() con una salida MIDI, si quieres mostrar algún tipo de mensaje en el ordenador tan sólo cambia:

midiOut.sendControlChange(42,127,1);

por:

midiOut.sendControlChange(value, channel);

donde value y channel deben tener los valores deseados que quieres mostrar.

Ejemplo de funcionamiento:

[youtube https://www.youtube.com/watch?v=sEZxFIEvjSo?feature=oembed]