Contruyendo un controlador midi con Arduino

Capítulo I – Declaración de intenciones

En este proyecto trataré de explicar los pasos a seguir para construir un controlador midi con la placa Arduino. El controlador midi lo utilizaremos para mandar mensajes midi a dispositivos que acepten este protocolo, como Cubase y similares. El objetivo final es llegar a controlar el panel de mezcla VST de Cubase

Lo primero de todo decir que el que esté buscando un controlador midi barato lo mejor que puede hacer es comprarlo en la tienda más cercana; no es sólo el tiempo que hay que invertir, si no también lo caro que resultan muchos de los componentes, por no hablar de la caja donde se monta todo o del propio Arduino. Aun así, sale más barato que ir a la tienda, pero si contabilizas todas las horas invertidas a precio de fontanero o electricista el negocio es ruinoso.

Especificaciones

• 6 potenciómetros deslizantes para controlar el volumen
• 6 potenciómetros para controlar el balance
  
• 6 botones para lanzar eventos midi (por ejemplo de percusión)
• 1 Salida midi standard para poder conectar el dispositivo.

Aquí podéis ver el cacharro terminado… aunque estas cosas nunca se acaban.

¡Totalmente Vintage!

En próximos capítulos iré contando como se llega desde una placa Arduino hasta este trasto.

Pulsa abajo para seguir leyendo…

Capítulo II Multiplexando

Como dije anteriormente, el ‘invento’ tiene 12 potenciómetros y la placa Arduino solo cinco entradas analógicas. Es necesario multiplexar la señal de los 12 potenciómetros. Para ello usé el 4051BP, que no sé si será el más adecuado pero sí un viejo conocido mío.

Cada uno de estos multiplexores tiene una salida y 8 entradas (direccionables mediante 3 pines). Se necesitan 2 multiplexores para dirigir 16 entradas a dos salidas (aunque en nuestro caso solo necesitasemos 12 entradas)

Aquí podéis ver la placa que usé para colocar los multiplexores y el esquema de uno de los multiplexores

Los botones fueron conectado directamente a las entradas digitales así (sin usar resistencias pull-up):

Capítulo III – ¿Pero dónde lo meto todo?

Una cosa es la teoría y otra muy diferente la práctica. Sobre papel, todo es fácil, pero la realidad suele estar hecha de una plancha de aluminio de 2 mm de espesor, atornillada a una caja. Encontrar un contenedor de ‘diseño’ me resultó imposible, así que tuve que aprovechar una caja de segunda mano (no muy estilizada que digamos)

No voy a perder el tiempo explicando lo complicado que es hacer líneas en una plancha de aluminio para colocar los potenciómetros deslizantes usando un dremel. O lo dificultoso que es taladrar los agujeros de los botones siguiendo un alineamiento medianamente ‘decente’. Gracias a dios, después de algún catastrófico intento, me dejaron un taladro vertical (agradecimientos) Eso, junto con una plantilla de Autocad con los taladros indicados, hizo el trabajo bastante más fácil. Aprovechando la plantilla, posteriormente la usé como carátula (pegándola al aluminio con cinta de doble cara sobre el aluminio)

Hice un par de agujeros en la parte posterior de la caja para poder conectar el Arduino al USB y a un cable midi.

Un descubrimiento interesante fue el uso de la resina Epoxipol para colocar unos soportes donde atornillar la placa del arduino e impedir que se moviese.

Capítulo IV – Lo blandito (el software)

El programa lo que hace es escanear una a una todas las entradas (digitales y analógicas) para ver si se ha producido algún cambio de estado desde la última vez que se chequearon. Con esto, se evita estar continuamente mandando eventos midi. Si se ha producido un cambio en los potenciómetros, se envía un evento midi de control (CC). Por otro lado, si se produce una pulsación de uno de los seis botones se manda un MidiNoteOn y si se libera el pulsador un MidiNoteOff.

A grandes rasgos los evento eventos midi son una ristra de tres bytes que se envía a través del puerto serie. El primero lleva información sobre el tipo de evento además del canal. El segundo y el tercer dato (byte) da información sobre el evento en cuestión.

MidiNoteOn = {0x90, 36, 127}

MidiNoteOff = {0x90, 36, 0}

MidiFaderChange = {0xB0 + c, 0x07, z} ; // x = 0 – 127 y c = 0 – 15

MidiPanChange = {0xB0 + c, 0x0A, z} ; // x = 0 – 127 y c = 0 -15

Lo más importante del código es lo siguiente (fíjate que para mandar comandos midi es necesario establecer la frecuencia del puerto serie a 31250 baudios)

/*
* MIDI Subrutines
*/
void sendMidiCmd(char cmd, char data1, char data2) {
Serial.print(cmd, BYTE);
Serial.print(data1, BYTE);
Serial.print(data2, BYTE);
}

void setup() {
// Define pin used for reading
int ibutton = firstButton;
do {
pinMode(ibutton, INPUT);
digitalWrite(ibutton, HIGH);
ibutton++;
} while( ibutton > lastButton );

// Define pins used for writing address
for(int pin=firstPinAddress ; pin <= lastPinAddress; pin++) {
pinMode(pin, OUTPUT);

}
// Set MIDI serial settings
Serial.begin(31250); // Midi serial
}

Una cosa muy importante, que me ahorró bastante trabajo a la hora de soldar componentes, es escribir en las entradas digitales un valor HIGH (aunque parezca raro) De esta forma se evita tener que usar una resistencia para cada uno de los botones.

Fin de la primera parte

Aquí me quedo de momento. Espero que a alguien le sea de utilidad esta información e intentaré añadir más documentación sobre la configuración de Cubase o las mejoras que se pueden añadir al ‘dispositivo’