Sunteți pe pagina 1din 39

Transforme un piano electrico en un teclado

MIDI con Arduino


Hola! en este post les traigo un experimento que me surgio mas por necesidad que por diversion, nunca habia
usado arduino (los que no sepan que es arduino los invita a buscar en google, si les gusta la electronica y la
programacion seguro que les va a gustar) asi que no sabia si realmente todo esto iba a funcionar pero para mi
sorpresa el proyecto termino de la mejor manera posible!

ACLARACION: En el post no doy instrucciones para que hagan lo mismo (no creo que nadie tenga este
piano, es muy viejo, asi que no quise complicarme con datos tecnicos)

Primero el problema:

Yo tengo un piano Yamaha Cn-50, que debe datar de los aos 60' es de madera, tiene un sonido de 8 bits (parece
el sonido del family) y no es sensitivo. Queria algo con una buena calidad de sonido para hacer temas e incluir
piano, pero no queria comprar un teclado MIDI o un organo nuevo porque no estoy precisamente nadando en plata.
este es el piano:
Bueno, el organo este no tenia salida MIDI, la busque por todas partes pero nada, lo primero que se me ocurrio fue
esto, una vez programe unos drivers para una impresora y descubri que enviando ciertos parametros mejoraba la
calidad de la impresion (o sea, que te vendian un modelo como mejor pero lo unico que cambiaba era el modelo de
la carcasa y los drivers, pero tecnicamente en modelos anteriores las mejoras ya estaban implementadas, una
cuestion de mercado). Entonces pense, quizas este organo tenga una salida MIDI implementada y la dejaron
pendiente para modelos posteriores (esta el yamaha cn-70 que es casi igual con algunas funciones nuevas) asi que
agarre las herramientas y abri el organo para encontrarme con este panorama:
Busque por todos lados pero no habia ninguna salida MIDI, despues buscando informacion en internet, no se en
donde, lei que el organo era de los aos 60 (y el protocolo MIDI fue desarrollado veinte aos despues) y me di
cuenta que habia pocas posibilidades de encontrar una solucion rapida a lo que yo necesitaba.

Para que sirve la salida MIDI?

El MIDI es un protocolo de comunicacion que utilizan los instrumentos musicales, y sirve entre otras cosas para
decirle a un sintetizador que nota se pulso, a que volumen, y cosas por el estilo, y el sintetizador transforma esa
informacion en sonido (se conecta el teclado MIDI a la pc con un programa onda FL Studio y listo, suena de puta
madre!)

Que solucion encontre?

Bueno, pensando y buscando informacion, casi dandome por vencido me tope con algo que venden por internet
que se llama Arduino, es basicamente una pequea computadora programable que se puede usar para casi
cualquier proyecto de electronica, hay que saber electronica y programacion, yo tengo la suerte de saber ambas
cosas, este es el arduino:
Asi que fui y compre uno, me salio 230 pesos, medio caringui pero bue... instale el programa para cargarle los
programas al arduino, aprendi como se usaba y en menos de un dia ya estaba experimentando, primero quite el
teclado del organo de su carcasa y conecte todos sus conectores al arduino
Y de ahi a la compu!

Lo que hice despues fue con el tester, o voltimetro o como se llame, entender como es que las 61 notas del teclado
(porque tiene 5 octavas) se enviaban a travez de 17 cablecitos, me un par de horas sacarle la vuelta a eso,
basicamente se cerraban y abrian conexiones, nada espectacular, y desde el arduino podia leer esos cierres,
interpretarlos y enviarlos como un dato MIDI.

Una vez que el programa para el arduino se termino, y las pruebas se hicieron, coloque el arduino dentro del
organo, le conecte la alimentacion con un transformador de esos que te venden por ahi, e hice la salida MIDI, toda
la data esta en internet si les interesa, pero tienen que comprar esta fichita que esta 2 pesos, es la ficha estandar
para el MIDI:

Hice un agujero atras del piano, le coloque la ficha, conecte la ficha a la salida de datos del arduino y programe el
arduino para que envie datos a la velocidad estandar del MIDI, que ahora no me acuerdo cual es, y tampoco le
saque fotos a esa parte del proceso, la cuestion es que conecte todo y funciono!!!

El organo se conecto un cable midi-usb, el usb a la computadora, y la computadora tiene una placa de audio de
grabacion externa (para evitar la latencia si usas la placa de sonido del pc) y de la placa la conecte a la mezcladora
de sonido, instale el FL Studio le cargue soundfonts de piano y listo! empeze a tocar, disculpen que no tengo video
final, is me hago tiempo subo un video para que vean como suena ahora, la unica cagada es que no es sensitivo el
piano, pero es mucho mejor que desembolsar plata en un teclado midi que no estan nada baratos.
ARDUINO+MIDI: TU PROPIO PIANO
Hola! Me llamo lvaro Lpez (@alvarolrevuelta) y hoy os ensear como fabricar vuestro propio piano
controladorusando Arduino y MIDI. Muchos diris Qu es eso del MIDI? Para qu sirve? Pues muy sencillo,
MIDI (Musical Instrument Digital Interface) es un protocolo de comunicacin serial que permite conectar
ordenadores, sintetizadores, controladores y dems elementos destinados a la creacin de sonidos. Dicho
protocolo data de los aos ochenta pero an se sigue usando hoy en da y de manera muy extendida, nos
podemos encontrar gente que lo usa hasta para controlar luces y servos.

Este es un ejemplo de controlador MIDI comercial. Posee una salida USB para conectar al ordenador.

Lo que haremos ser usar varios botones conectados al Arduino que leer cuando se pulsan. En el caso de que se
pulse uno haremos que Arduino envi a nuestro ordenador por medio del cable USB unos datos indicando que
botn ha sido pulsado y qu nota debe enviar (un Do, un Re,...). Una vez en el ordenador deberemos usar algn
programa como Traktor, Ableton, Cubase, Nuendo, Reason,... que interpretar los datos MIDI recibidos y generar
un sonido que podremos escuchar por los altavoces de nuestro ordenador. Este ltimo paso es importante ya
que MIDI es solamente un protocolo, es decir, no suena por si solo.

Como Arduino no es un dispositivo pensado para estos fines, no puede ser reconocido por los programas de audio
mencionados anteriormente como si fuera un dispositivo midi comercial. Una de las formas es emplear unos
convertidores Serial a MIDI y unos puertos virtuales (cosa muy extendida por Internet, como HairLess y MidiYoke).
Sin embargo, lo que vamos a hacer es reflashear nuestro Arduino UNO con un nuevo firmware llamado
Hiduino, lo que nos permitir crear un dispositivo "Plug & Play" como si fuera un controlador MIDI comercial.

Manos a la obra, necesitaremos:

x11 Switches (tambin se pueden usar menos)


x01 Resistencia 10k Ohm
Arduino UNO y cable USB
ProtoBoard
Programa Arduino
DFU-Programmer (sobre Linux o Mac)
Hiduino Firmware
Librera MIDI

1. Realizar conexiones

Pero vayamos paso a paso, lo primero conectar los 11 botones. Como podis ver la conexin es muy sencilla,
conectamos cada botn entre GND y el pin correspondiente (del 2 al 12). Para que se pueda funcionar as, ser
necesario habilitar las resistencias de pullup internas (se hace desde el cdigo). Ojo si usis el pin 13, que
requiere una resistencia de pullup externa.
2. Introducir cdigo prueba (no es MIDI)

Hasta aqu fcil no?. Vamos a cargar un cdigo que verifique el correcto funcionamiento de todos los
botones. An no hemos empezado con MIDI.

/**
Alvaro Lopez Revuelta para http://geekytheory.com/
http://alvarorevuelta.net/

Este ejemplo es para ver en el monitor serial los botones pulsados/despulsados


En el siguiente ejemplo veremos como enviar midi
Ojo con usar mas de 11 botones empleando la resistencia de pullup interna
Para el pin 13 debe usarse una resistencia de pullup externa
*/

const int numBotones=11; // Definir aqui el numero de botones (11 max)


int valorLeido[numBotones]; // Array con los valores leidos de cada boton
int valorAnterior[numBotones]; // Array con el valor anterior leido

void setup() {
Serial.begin(9600); // Inicializamos la comunicacion serial
for(int i=0; i<numBotones; i++){
pinMode(i+2, INPUT_PULLUP); // Recorremos cada pin y lo ponemos como entrada
valorAnterior[i]=1; // Inicializamos el valor anterior a 1 (no pulsado)
}
}

void loop(){
for(int i=0; i<numBotones; i++){
valorLeido[i]=digitalRead(i+2); // Leer valor
// Solo enviamos cuando ha existido un cambio, para no sobrecargar el puerto serial
if((valorLeido[i]==0) && (valorLeido[i]!=valorAnterior[i])){
Serial.print("Pulsado el boton: ");
Serial.println(i);
Serial.println("------------");
}
else if ((valorLeido[i]==1) && (valorLeido[i]!=valorAnterior[i])){
Serial.print("Ya no el boton: ");
Serial.println(i);
Serial.println("------------");
}
valorAnterior[i]=valorLeido[i]; // El valor anterior es el nuevo valor para la siguiente itera
cion
}

Ahora abrir el puerto serial con un baud rate de 9600 e ir pulsando y liberando los botones. Podris ver como al
pulsarlo se nos indica por el monitor serial que botn ha sido pulsado, y cuando se libera cual ha sido liberado.
Repito que hasta aqu no hemos hecho nada de MIDI, simplemente estamos testando el hardware e introduciendo
el cdigo que usaremos.

3. Vamos con MIDI

A continuacin debemos cargar el siguiente cdigo. Este cdigo hace uso de la librera MIDI de Arduino.
(Descargar la librera e instalarla). Simplemente se emplea un baud rate de 31250 y se enva mensajes serial con
la sintaxis de MIDI. Nos centraremos en el mensaje de NoteOn es decir, nota activada. Este mensaje lleva
informacin de la nota pulsada (Do, Re,...), con que intensidad se puls esta nota (127 es el mximo, nosotros
usaremos el mximo ya que nuestros botones no tienen sensibilidad) y en que canal MIDI se quiere enviar el
mensaje (hay 16 disponibles). Cargamos el cdigo, nada ms.

#include // Incluimos la libreria MIDI


/**
* Alvaro Lopez Revuelta para http://geekytheory.com/
* http://alvarorevuelta.net/
*
* Este ejemplo sirve para enviar midi a nuestro ordenador
* Sera necesario emplear el firmware hiduino para que funcione correctamente
* https://github.com/ddiakopoulos/hiduino
* Ojo con usar mas de 11 botones empleando la resistencia de pullup interna
* Para el pin 13 debe usarse una resistencia de pullup externa
*/
const int numBotones=11;
int valorLeido[numBotones]; // Array con los valores leidos de cada boton
int valorAnterior[numBotones]; // Array con el valor anterior leido
MIDI_CREATE_DEFAULT_INSTANCE();

void setup() {
MIDI.begin(); // Inicializamos la comunicacion midi (realmente es serial)
for(int i=0; i<numBotones; i++){
pinMode(i+2, INPUT_PULLUP);// Recorremos cada pin y lo ponemos como entrada
valorAnterior[i]=1; // Inicializamos el valor anterior a 1 (no pulsado)
}
}

void loop(){
for(int i=0; i<numBotones; i++){
valorLeido[i]=digitalRead(i+2); // Leer valor
// Solo enviamos cuando ha existido un cambio, para no sobrecargar el puerto serial
if((valorLeido[i]==0) && (valorLeido[i]!=valorAnterior[i])){
MIDI.sendNoteOn(48+i, 127, 1); //48 corresponde a C es decir DO.
}
else if ((valorLeido[i]==1) && (valorLeido[i]!=valorAnterior[i])){
MIDI.sendNoteOff(48+i, 0, 1);
}
valorAnterior[i]=valorLeido[i]; // El valor anterior es el nuevo valor para la siguiente itera
cion
}

}
Se puede apreciar que el cdigo es muy parecido al anterior, solo que cuando se detecta botn pulsado/liberado se
enva un mensaje de nota activada o desactivada. El valor de nota enviado por el primer botn es 48 que segn el
protocolo MIDI corresponde a DO. Por lo tanto el siguiente botn enviar DO Sostenido, el siguiente RE,...

Ahora ya no tiene sentido visualizar el puerto serial, ya que veremos caracteres sin aparente sentido. Lo que
tenemos que hacer ahora es hacer que nuestro Arduino sea reconocido como un dispositivo MIDI, para lo
que deberemos reflashear el Arduino con un nuevo firmware.

4. Reflasheando el Arduino con Hiduino. (Desde Linux, en Mac es parecido).

Lo primero que deberemos hacer es descargarnos el firmware de Hiduino. Vayamos a la carpeta de "Compiled
Firmware" y localicemos el archivo que nos interesa "HIDUINO_MIDI.hex". Pon ese archivo en el escritorio por
ejemplo, es simplemente por tener una ruta mas fcil para despus.

Ahora nos tenemos que bajar el "dfu-programmer". Si estamos en Linux:

sudo apt-get install dfu-programmer


A continuacin necesitaremos que nuestro Arduino entre en modo DFU para que se nos permita introducirle el
cdigo. Antes de nada es muy importante que hayis cargado el cdigo anterior (el del MIDI). Una vez que
introducimos este nuevo firmware, no podemos volver a meter cdigo en el Arduino, pero tranquilos! que si
volvemos a meter el firmware original de Arduino todo volver a la normalidad (Se hace de manera idntica a
introducir cualquier firmware). Como he dicho hay que entrar en modo DFU con nuestro Arduino, para ello:

Mira tu versin: La de un condensador o la de dos (ver fotos)


Conecta un jumper entre los terminales que se ven en la figura
Toca con la resistencia entre GND y el pad izquierdo del condensador
Debers ver como una luz parpadea y se apaga, retira las conexiones anteriores.
Ests en modo DFU.

Si todo ha salido correctamente y dejasteis el HIDUINO_MIDI.hex en el Escritorio, deberas de poder hacer lo


siguiente. Repito, desde consola Linux:

cd \Desktop

sudo dfu-programmer at90usb82 erase

sudo dfu-programmer at90usb82 flash HIDUINO_MIDI.hex

sudo dfu-programmer at90usb82 reset


Desconecta y vuelve a conectar el cable del Arduino. Ahora tu Arduino ya se comporta como si fuera un
controlador MIDI comercial. Conctalo al programa de audio que desees (Ableton, Cubase, Nuendo, Sonar,
Traktor,...), asgnale los sonidos que desees y A tocar!. Si no sabes usar estos programas, nunca es mal
momento para iniciarse. Son bien sencillos y muy divertidos.

irst time using an Arduino? No worries, weve got a complete Arduino beginners guide to read through before
you tackle this project.

What is MIDI?
MIDI stands for Musical Instrument Digital Interface. It outlines a standard way for musical devices to
communicate with each other. If you own an electronic keyboard you probably have a MIDI interface. Whilst
there are a few technical details involved in the implementation of MIDI, its important to remember that MIDI
is not audio! MIDI data is a simple set of instructions (one instruction is called a message) that another device
may implement to make different sounds or control parameters.

MIDI supports 16 channels. This means that each cable can support 16 different devices communicating
independently with each other. Devices are connected using a 5-pin DIN cable. DIN stands for German
Institute for Standardization, and is simply a cable with five pins inside the connector. USB is often used in
place of 5-pin DIN, or a USB-MIDI interface can be used.
Ads by Google

Control Change and Program Change


Hay dos tipos principales de mensajes MIDI: Cambio de control y cambio de programa.
Cambio de control (CC) mensajes contienen un nmero de controlador y un valor entre 0 y 127. Los mensajes de CC se
utilizan a menudo para cambiar la configuracin, como el volumen o el tono. Dispositivos que aceptan MIDI debe venir
con un manual explicando qu canales y mensajes estn configurados por defecto, y cmo cambiarlos (conocida como
mapeo MIDI).
Cambio de programa (PC) Los mensajes son ms simples que los mensajes CC. mensajes del PC constan de un solo
nmero, y se utilizan para cambiar el valor predefinido o un parche en un dispositivo. mensajes de PC son a veces
conocidos como "cambio de parche". De manera similar a los mensajes CC, los fabricantes deben proporcionar un
documento que indica de qu ajustes preestablecidos se cambian por un mensaje
en particular.

What You Will Need


Arduino
5-pin DIN female socket
2 x 220 ohm resistors
2 x 10k ohm resistors
2 x momentary switches
Hook-up wires
Breadboard
MIDI cable
MIDI device or USB interface
Water & Wood 5 Pcs DIN 5 Pin PCB Mounting Female Sockets for PC KeyboardWater & Wood 5

Pcs DIN 5 Pin PCB Mounting Female Sockets for PC Keyboard5 Pcs DIN 5 Pin PCB Mounting

Female Sockets for PC Keyboard BUY NOW AT AMAZON $3.25

Construir plan
Este proyecto ser bastante simple. Por supuesto, puede aadir ms botones o hardware para satisfacer sus
necesidades. Casi cualquier Arduino ser adecuado - slo se necesitan tres pines para este ejemplo. Este proyecto
consta de dos botones para controlar el programa, un puerto MIDI para enviar los datos, y un dispositivo para recibir los
mensajes. Este circuito se ha construido en un circuito que aqu, sin embargo, es posible transferir a una caja de
conectores del proyecto y soldadas para una solucin robusta.

Ensamblaje del circuito


MIDI Conneccion

Cablear el zcalo MIDI de la siguiente manera:


MIDI pin 5 a Arduino transmisin (TX1 a travs de una resistencia de 220 ohmios
MIDI pin 4 a Arduino + 5V a travs de una resistencia de 220 ohmios
MIDI pin 2 a Arduino tierra

Button Connection
Los botones funcionan cambiando la resistencia del Arduino "ve". El pin de Arduino pasa por el interruptor directamente
a tierra (low) a travs de una resistencia de 10k ohm (un "desplegable" resistencia, asegurando el valor se mantiene
baja). Cuando se pulsa el botn, el valor visto por los cambios en el circuito a + 5v sin una resistencia (high). El Arduino
puede detectar este cambio con el comando digitalRead(pin). Conectar los botones a los pines 6 y 7 en el Arduino digital
input/ output (I / O).
Conecte los dos botones:
El lado izquierdo del botn de + 5V
El lado derecho del botn para Arduino tierra a travs de una resistencia de 10k ohm
El lado derecho del botn para Arduino pasador (6 o 7)

MIDI Testing
Ahora que todo el hardware est terminado, es hora de probarlo. Usted necesitar una interfaz USB-MIDI (muchas
interfaces de audio pueden hacer esto) y un cable MIDI. El puerto MIDI cableada en el tablero est enviando datos, por
lo que es la salida. El ordenador est recibiendo los datos, por lo que es la entrada. Este proyecto utiliza la excelente
Arduino Biblioteca MIDI v4.2 por cuarenta y siete Efectos. Una vez que haya instalado la biblioteca, puede incluirlo en su
cdigo por ir al Sketch > Include Library > MIDI.
Usted tambin necesitar un programa para monitorear los datos MIDI entrante:

MIDI Monitor for OS X


MIDI-OX for Windows
KMidimon for Linux
Conectar el Arduino al ordenador y cargar el siguiente cdigo de prueba (no se olvide de seleccionar el tablero y el
puerto correcto de la > Board and Tools > Port menus) .Getting iniciales con el Arduino Starter Kit - Instalacin de los
controladores y configuracin El Junta y puerto Procedimientos iniciales con el Arduino starter kit - Instalacin de los
controladores y configuracin La Junta y PortSo, que ha comprado a s mismo un kit de iniciacin Arduino, y
posiblemente algunos otros componentes fresco al azar - y ahora qu? Cmo se puede realmente comenzar con la
programacin de Arduino esta cosa? Cmo se ajusta hasta que ... LEER MS

#include <midi.h>
#include <midi_defs.h>
#include <midi_message.h>
#include <midi_namespace.h>
#include <midi_settings.h>

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


called midiOut

void setup() {
Serial.begin(31250); // setup serial for MIDI
}

void loop() {
midiOut.sendControlChange(56,127,1); // send a MIDI CC -- 56 = note, 127 =
velocity, 1 = channel
delay(1000); // wait 1 second
midiOut.sendProgramChange(12,1); // send a MIDI PC -- 12 = value, 1 = channel
delay(1000); // wait 1 second
}
Este cdigo se enva un mensaje CC, espere de 1 segundo, enviar un mensaje de PC y luego esperar 1 segundo
indefinidamente. Si todo funciona correctamente, aparecer el siguiente mensaje aparece en el monitor MIDI.
Si no ocurre nada, no se asuste! Intenta resolver el problema:
Asegrese de que todas las conexiones son correctas
Compruebe el puerto MIDI est conectado correctamente - no debe ser de 2 pines de repuesto a los bordes exteriores
Haga doble revisar el circuito es correcta
Verificar que el circuito est conectado a una interfaz USB-MIDI con un cable MIDI
Compruebe el cable MIDI est conectado a la entrada de su interfaz USB-MIDI
Asegrese de que el Arduino tiene poder
Instalar el controlador correcto para la interfaz USB-MIDI
Si todava tiene problemas que podra ser digno de la comprobacin de su placa. tableros baratos a veces puede ser muy
inconsistente y de baja calidad - me sucedi mientras trabajaba en este proyecto

.
Button Testing

Ahora es el momento para poner a prueba los botones funcionan correctamente. Sube el siguiente cdigo de prueba.
MIDI no necesita estar conectado a probar esta parte.
const int buttonOne = 6; // assign button pin to variable
const int buttonTwo = 7; // assign button pin to variable

void setup() {
Serial.begin(9600); // setup serial for text
pinMode(buttonOne,INPUT); // setup button as input
pinMode(buttonTwo,INPUT); // setup button as input
}

void loop() {

if(digitalRead(buttonOne) == HIGH) { // check button state


delay(10); // software de-bounce
if(digitalRead(buttonOne) == HIGH) { // check button state again
Serial.println("Button One Works!"); // log result
delay(250);
}
}

if(digitalRead(buttonTwo) == HIGH) { // check button state


delay(10); // software de-bounce
if(digitalRead(buttonTwo) == HIGH) { // check button state again
Serial.println("Button Two Works!"); // log result
delay(250);
}
}

}
Ejecutar este cdigo (pero mantener el cable USB est conectado) y abrir el monitor serie (Top Right > Serial Monitor).
Cuando se pulsa un botn debera ver "botones de One Works!" O "Botn dos obras!", Dependiendo del botn pulsado.
Hay una nota importante para llevar de este ejemplo - el software de-bounce (latencia). Se trata de un simple retraso de
10 milisegundos (ms) entre el control de la tecla y despus de comprobar de nuevo el botn. Esto aumenta la precisin
del botn de prensa y ayuda a prevenir el ruido de la activacin de la Arduino. Usted no tiene que hacer esto, aunque se
recomienda.

Creating the Controller


Ahora que todo est conectado y funcionando, es el momento de montar el controlador completo.
En este ejemplo se enviar un mensaje CC diferente para cada botn que se presiona. Estoy usando esto para controlar
Ableton Live 9.6 en OS X. El cdigo es similar tanto a las muestras de prueba anteriores.

#include <MIDI.h>
#include <midi_Defs.h>
#include <midi_Message.h>
#include <midi_Namespace.h>
#include <midi_Settings.h>

const int buttonOne = 6; // assign button pin to variable


const int buttonTwo = 7; // assign button pin to variable

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


called midiOut

void setup() {
pinMode(buttonOne,INPUT); // setup button as input
pinMode(buttonTwo,INPUT); // setup button as input
Serial.begin(31250); // setup MIDI output
}

void loop() {
if(digitalRead(buttonOne) == HIGH) { // check button state
delay(10); // software de-bounce
if(digitalRead(buttonOne) == HIGH) { // check button state again
midiOut.sendControlChange(56,127,1); // send a MIDI CC -- 56 = note, 127 =
velocity, 1 = channel
delay(250);
}
}
if(digitalRead(buttonTwo) == HIGH) { // check button state
delay(10); // software de-bounce
if(digitalRead(buttonTwo) == HIGH) { // check button state again
midiOut.sendControlChange(42,127,1); // send a MIDI CC -- 42 = note, 127 =
velocity, 1 = channel
delay(250);
}
}
}

Note you will not be able to use Serial.println() with MIDI output.
If you wanted to send a PC message instead of a CC simply replace:

midiOut.sendControlChange(42,127,1);

With:

midiOut.sendProgramChange(value, channel);

In Action
Below is a demonstration as a controller for Ableton Live (Best DJ software for every budget). The top right
shows the audio meters, and the top middle shows the incoming midi messages (via MIDI Monitor on OS
X).The Best DJ Software For Every Budget The Best DJ Software For Every BudgetGood mixing
software can make all the difference in your performance. Whether you're using a Mac, Windows, or Linux, every level of skill
and budget is catered for if you want to start DJing.READ MORE

Have you Made a MIDI Controller?


There are a lot of practical uses for a custom MIDI controller. You could build a vast foot-controlled unit, or a
sleek studio controller. Have you made a custom MIDI controller? Let me know in the comments, Id love
to see them!

arduino MIDI Library v4.2


Franky47 released this on 11 Jun 2014 121 commits to master since this release
Changelog

Fix bug when receiving large SysEx messages - Issue #22


Fix Thru bug - Issue #13
Removed preprocessor-based settings, replaced by an overridable template-based struct. This allows to change
settings without editing the library code.

Compatibility

Instanciation

The default MIDI object has been removed, so you will need to create it using one of the following macros:

For straightforward compatibility with sketches written with v4.1 and older:

MIDI_CREATE_DEFAULT_INSTANCE();

To specify which serial port to use:

MIDI_CREATE_INSTANCE(HardwareSerial, Serial2, MIDI);

To override settings - see http://arduinomidilib.fortyseveneffects.com/a00013.html#details

struct MySettings : public midi::DefaultSettings


{
static const bool UseRunningStatus = false; // Messes with my old equipment!
};

MIDI_CREATE_CUSTOM_INSTANCE(HardwareSerial, Serial, MIDI, MySettings);

SysEx Callback

The SysEx callback has a new signature:

void handleSysEx(byte* data, unsigned size);

This fixes a bug when receiving SysEx messages larger than 255 bytes.
Midi for the Arduino - Build a Midi Input Circuit

Less talking, more building!

In this installment we are going to assemble a Midi Input Circuit and connect it to your Arduino UNO. The Circuit itself is
actually quite simple consisting of only a handful of parts.

In the last installment, we looked at a Circuit Analysis of a Midi Input and Output Circuit. If you are new to this series, I
suggest you check it out. It will give you a better understanding of what you are actually building. Now, let's put this
knowledge to use and start building the hardware.

I am assembling the circuit on a small solder-less breadboard. The video will walk you through the steps of putting it
together. Take your time and double check your work. You'll be fine!

Parts List (Click links to view parts on Amazon.com)

1 x Arduino Uno
1 x Solderless Breadboard
1 x 6n138 Optocoupler
1 x 1n914 Diode
1 x 5-Pin Din Jack (Midi jack)
3 x 220 Ohm Resistor (1/4 Watt)
1 x 4.7K Ohm Resistor (1/4 Watt)
Jumper wires

Schematic (I find it helpful to have a printed copy when I am building)

In the next installment, we look at the Arduino MIDI Library and write software for this circuit.
Arduino MIDI Library v4.2
Franky47 released this on 11 Jun 2014 121 commits to master since this release

Changelog

Fix bug when receiving large SysEx messages - Issue #22


Fix Thru bug - Issue #13
Removed preprocessor-based settings, replaced by an overridable template-based struct. This allows to change
settings without editing the library code.

Compatibility

Instanciation

The default MIDI object has been removed, so you will need to create it using one of the following macros:

For straightforward compatibility with sketches written with v4.1 and older:

MIDI_CREATE_DEFAULT_INSTANCE();

To specify which serial port to use:

MIDI_CREATE_INSTANCE(HardwareSerial, Serial2, MIDI);

To override settings - see http://arduinomidilib.fortyseveneffects.com/a00013.html#details

struct MySettings : public midi::DefaultSettings


{
static const bool UseRunningStatus = false; // Messes with my old equipment!
};

MIDI_CREATE_CUSTOM_INSTANCE(HardwareSerial, Serial, MIDI, MySettings);

SysEx Callback

The SysEx callback has a new signature:

void handleSysEx(byte* data, unsigned size);

This fixes a bug when receiving SysEx messages larger than 255 bytes.

Downloads

30.1 KB Arduino_MIDI_Library_v4.2.zip
Source code (zip)
Source code (tar.gz)
Bricolaje MIDI con Arduino

por emiliomm | 10/09/2013

Te gustara crear un dispositivo MIDI original y creativo? En este tutorial te ensearemos cmo hacerlo con
Arduino. El tutorial primero ofrece una visin general de Arduino y cmo se puede aplicar al mundo musical.
Posteriormente, explica cmo crear (1) un dispositivo capaz de enviar diferentes tipos de mensajes MIDI, y (2)
un dispositivo capaz de recibir mensajes MIDI. Por ltimo, se plantea un ejercicio para combinar todo lo
aprendido y se proponen ideas para inspirar a aquellos valientes que decidan construirse su propia locura MIDI.

0. Sobre este tutorial...

Este tutorial ha sido elaborado por Emilio Molina bajo la supervisin de Ana Mara Barbancho (profesora
responsable) como prctica de la asignatura 'Laboratorio de Equipos de Audio', de la titulacin de Grado en
Ingeniera de Sonido e Imagen de la Universidad de Mlaga. Creemos que puede ser de gran inters para
aquellos interesados, o curiosos de Arduino. No obstante, la dificultad de este tutorial es creciente, y para
completarlo es conveniente tener unos conocimientos mnimos de electrnica y de programacin.

1. Qu es Arduino?

Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y un entorno de
desarrollo, diseada para facilitar el uso de la electrnica en proyectos multidisciplinares. Las placas se pueden
adquirir en su pgina web (o montarlas a mano...) y el entorno de desarrollo integrado libre se puede descargar
gratuitamente. Al ser open-hardware, tanto su diseo como su distribucin es libre; es decir, puede utilizarse
libremente para el desarrollo de cualquier tipo de proyecto sin haber adquirido ninguna licencia. En
consecuencia, es una forma muy sencilla de introducirse en el mundo de la electrnica, con una amplia
documentacin en Internet, y no es necesario tener grandes conocimientos de electrnica para crear cosas
sorprendentes.

La pgina web oficial de Arduino es http://arduino.cc/ (la versin espaola es http://arduino.cc/es, pero es
menos completa), y en ella puede encontrarse el software necesario, tutoriales y documentacin, as como un
enlace a la Arduino Store (http://store.arduino.cc) donde se puede encontrar un gran surtido de placas (los
precios rondan los 30-60). En este tutorial, nos centraremos en la placa Arduino Uno, porque dispone de todas
las caractersticas necesarias para montar un dispositivo MIDI por tan slo 20.
Figura 1 - Arduino Uno (20 aproximadamente)

2. MIDI y Arduino

Arduino Uno est basado en el microcontrolador ATmega328, el cual funciona a 16Mhz, tiene una memoria
flash de tan slo 32KB (lo justo para almacenar el programa a ejecutar) y una memoria SRAM de 2KB. Estas
bajas prestaciones lo limita para procesar audio de alta calidad, pero lo hace muy apropiado para trabajar con
mensajes MIDI o para sintetizar sonidos de baja calidad. No obstante, los modelos ms recientes de Arduino
(como Arduino Yun) poseen mejores prestaciones y merecera la pena seguir indagando en sus posibilidades
para aplicarlas a la msica. En este tutorial nos centraremos slo en el manejo de mensajes MIDI en Arduino
Uno (y superiores), ya que la sntesis de audio es un tema diferente y dara para un tutorial mucho ms largo que
este (ejemplo). Para comprender mejor qu es el MIDI, recomiendo este fantstico tutorial posteado en
Hispasonic.

El enfoque tpico para hacer inventos creativos con Arduino consiste en combinar sensores, botones, luces, etc.
y utilizar Arduino como interfaz MIDI con sintetizadores u otro tipo de controladores MIDI. Este tipo de
elementos se pueden encontrar en tiendas de electrnica, o se pueden encargar por Internet.
Figura 2 - Enfoque tpico para elaborar dispositivos MIDI en Arduino.
3. Instalacin de Arduino Uno y ejecucin del ejemplo 'Blink.ino'

La instalacin de Arduino es bastante sencilla: es necesario instalar el entorno de desarrollo y configurar los
drivers de la placa. En la versin espaola de la web oficial, se puede encontrar las instrucciones detalladas para
instalar Arduino: http://arduino.cc/es/Guide/Windows. Aunque con eso debera de ser suficiente, en la versin
inglesa aparecen unas instrucciones an ms detalladas: http://arduino.cc/en/Guide/Windows.

Siguindolas, ya deberamos tener Arduino funcionando. Ejecuta el IDE de Arduino, selecciona el tipo de
tarjeta (Arduino UNO) y el puerto (en mi caso COM4) en el men Herramientas. Abre el ejemplo 'Blink.ino', en
Archivo>Ejemplos>01.Basics>Blink y cargalo en la placa mediante el botn Cargar. Si el LED integrado en la
placa del pin 13 parpadea, tu Arduino est correctamente programado.

Nota: Una vez que Arduino ya se ha programado a travs del puerto USB, el PC es prescindible. En nuestro
caso el USB lo utilizamos para alimentar la placa, pero con un alimentador externo de entre 7 y 12V, la placa
funcionara de forma autnoma igualmente.

Para aprender a conectar LEDs, botones, potencimetros... Muy


recomendado: http://arduino.cc/es/Tutorial/HomePage

4. Cableando un conector MIDI de salida y ejecucin del ejemplo 'MIDI.ino'

En este apartado vamos a construir un mini-secuenciador MIDI y lo vamos a conectar a un sintetizador, o a la


interfaz MIDI de nuestro ordenador para escuchar las notas generadas. La conexin de un conector MIDI a
Arduino es muy simple, y el nico material necesario es una resistencia de 220, varios cablecitos y un
soldador. El conector MIDI de salida se conecta a Arduino tal y como se muestra en la siguiente figura:

Figura 3 - Cableado de un conector MIDI OUT en Ardunio


En mi caso, la resistencia la he soldado en el cable directamente y funciona muy bien. Este esquema ha sido
extrado de: http://arduino.cc/es/Tutorial/Midi

IMPORTANTE!

Es muy importante conectar los pines tal y como se muestra en la figura. Por si existe alguna duda de cules son
los pines 5, 2, y 4 en un conector real, vase la siguiente foto:

Figura 4 - Cuidado con la numeracin de los pines!

Si estas conexiones no se realizan correctamente, nuestro Arduino no emitir ningn mensaje MIDI, e incluso
puede llegar a daarse.

Utilizaremos el puerto serie de Arduino UNO, correspondiente a los pines 0 y 1. De esta forma, acabamos de
construir un MIDI OUT para el Arduino. Con un cable MIDI estndar:

Figura 5 - Cable MIDI estndar

Conectamos el MIDI OUT del Arduino al MIDI IN de una interfaz MIDI para ordenador o a un sintetizador. A
continuacin, ejecuta el ejemplo Archivo>Ejemplos>04.Communication>MIDI y crgalo. Este ejemplo enva
secuencialmente una escala cromtica ascendente. Para escuchar estos mensajes MIDI, es necesario algn tipo
de instrumento virtual que acte de sintetizador.

5. Extra: Anlisis de mensajes MIDI con la herramienta MIDI-OX

MIDI-OX es una herramienta muy til para monitorizar los mensajes MIDI que entran y salen del PC. Es
gratuita y permite analizar con detalle la informacin que entra y sale por los puertos MIDI asociados a nuestro
PC. Puedes descargarla de http://www.midiox.com/ y utilizarla para depurar tus programas de Arduino.

Figura 6 - Captura de pantalla de MIDI-OX

En nuestro caso, abriremos el Monitor - Input (View>Input Monitor). En el Monitor - Input veremos todos los
campos de los mensajes MIDI entrantes.

Nota: Puede ser necesario configurar los puertos MIDI de entrada y salida en Options>Midi devices para
seleccionar los de la interfaz MIDI que estemos usando.
6. Elaboracin de diferentes tipos de mensajes MIDI
6.1. Note on- Note off

Estos mensajes constan de 3 bytes, tal y como se indica en la tabla superior. Vamos a elaborar dos funciones
llamadas noteOn y noteOff, encargadas de enviar estos mensajes. Hemos reelaborado la funcin noteOn para
que la seleccin de channel sea ms intuitiva que la que hay en el ejemplo MIDI.ino.

void noteOn(int channel, int note, int velocity) {

// channel comprendido entre 1 y 16.

Serial.write(B10010000+channel-1);

Serial.write(note);

Serial.write(velocity);

Cdigo 1 - Funcin alternativa a la ofrecida en 'MIDI.ino' para generar NoteOn. El uso de los canales se ha
facilitado y estn comprendidos entre 1 y 16.

Nota: En Arduino, un nmero binario lleva el prefijo B (vlido para un mximo de 8 bits), y un nmero
hexadecimal el prefijo 0x, e.g. 15 = B1111 = 0xFF.

void noteOff(int channel, int note) {

Serial.write(B10000000+channel-1);

Serial.write(note);

Serial.write(0);

Cdigo 2 - Funcin para generar un NoteOff segn indica el protocolo MIDI.


Nota: El protocolo MIDI contempla dos formas de hacer un noteOff. La primera utiliza el mensaje Note Off que
comienza por B1000nnnn. La segunda utiliza el mensaje Note On (B1001nnnn) con velocidad igual a cero.
Ambos producen el mismo efecto sobre un sintetizador.

Modifica ahora el ejemplo MIDI que se utiliz anteriormente y enva algunas notas utilizando estas funciones.
Por ejemplo, puedes hacer uso de diferentes canales.

6.2. Control change

Cualquier sintetizador tiene numerosos parmetros que pueden ser controlados va MIDI. Un parmetro puede
asignarse a cualquier nmero de control MIDI (0ccccccc), aunque existen algunos valores que siempre estn
asociados a caractersticas concretas del instrumento. Algunos controles comunes son:

Modulation (CC #1)


Breath (CC #2)
Foot Pedal (CC #4)
Portamento Time (CC #5)
Volume (CC #7)
Pan (CC #10)
Expression (CC #11)
Sustain Pedal (CC #64)
Soft Pedal (CC #68)

En este ejemplo, vamos a modificar algunos controles del instrumento virtual o sintetizador que estemos
usando. Vamos a hacer una funcin que enve un cambio de control y comprobaremos qu sucede al asignarle
distintos tipos de controles.

void controlChange(int channel, int control, int value){

Serial.write(0xB0+channel-1);

Serial.write(control);

Serial.write(value);

Cdigo 3 - Funcin para generar un mensaje de cambio de parmetro de control

Ejercicio: Haz un programa que modifique el estado del pedal de sustain cada 1000ms. Comprueba que el
estado del pedal de sustain va variando. Recuerda que el control correspondiente al pedal de sustain es el CC
#64.
6.3. Pitch wheel change

El protocolo MIDI contempla la posibilidad de 'desafinar' las notas para simular tcnicas como el vibrato, el
bending o el glissando. Para ello, es posible enviar un mensaje de "cambio de rueda de tono" (muy comn en
los controladores MIDI). Vamos a implementar una funcin que enve este tipo de parmetros:

void PitchWheelChange(int channel, int value) {

// value: [-8192, 8191] (14 bits)

unsigned int change = 0x2000 + value; // 0x2000 == No Change

unsigned char low = change & 0x7F; // Low 7 bits

unsigned char high = (change >> 7) & 0x7F; // High 7 bits

Serial.write(B11100000+channel-1);

Serial.write(low);

Serial.write(high);

Cdigo 4 - Funcin que genera un mensaje de cambio de rueda de pitch. Observa cmo hay que dividir la
variable 'value' en byte bajo y byte alto para enviarlo por el puerto serie.

Puedes hacer algunas pruebas enviando diferentes valores de pitch bending y comprobar de qu forma afecta al
resultado del sonido sintetizado.

7. Cableado del conector MIDI de entrada

Aunque la configuracin de MIDI OUT tambin funciona como MIDI IN, utilizaremos una configuracin algo
ms compleja para evitar daos por exceso de corriente. Esta configuracin es la recomendada en la mayora de
los tutoriales. Por lo tanto, haremos uso de un optoacoplador para proteger al dispositivo:
Figura 7 - Esquema y montaje de un conector MIDI de entrada con optoacoplador para evitar daos.

Nota: El diodo comn de pequea seal 1N4148 podra sustituir al diodo 1N914.

Envo de mensajes MIDI con la herramienta MIDI-OX

Si no se dispone de un controlador MIDI externo, la herramienta MIDI-OX puede ser til para enviar mensajes
MIDI a la placa Arduino. Activa la opcin Actions>Keyboard, y el teclado del ordenador pasar a funcionar
como un teclado MIDI segn la distribucin siguiente:

Nota: La tecla Q, por defecto, enva la nota MIDI C4 (nmero 60).


8. Gestin en Arduino de mensajes MIDI entrantes

Esta seccin del tutorial creo que es la ms valiosa y la que ms horas de trabajo tiene, ya que la gestin de
mensajes MIDI no es fcil y cuesta mucho trabajo encontrar documentacin para realizarla correctamente. Para
recibir los mensajes MIDI, se har uso de las siguientes funciones:

Serial.available(): Devuelve el nmero de bytes (caracteres) disponibles para ser leidos por el puerto
serie. Se refiere a datos ya recibidos y disponibles en el buffer de recepcin del puerto (que tiene una capacidad
de 128 bytes).

Serial.read(): Devuelve el primer byte disponible recibido por el puerto serie (devuelve -1 si no hay datos
disponibles).

Ninguna de estas funciones es bloqueante, por lo que es necesario usarlas correctamente para asegurarse que se
leen los mensajes MIDI slo cuando ya han sido recibidos. A continuacin se presenta la implementacin de
una funcin que devuelve los parmetros de un mensaje MIDI entrante de 3 bytes. Si se detecta el primer byte
de un mensaje MIDI vlido (byte de status), la funcin espera hasta recibir el mensaje MIDI completo, en caso
contrario no es bloqueante.

void readMIDI(byte* channel ,byte* type, byte* data1, byte* data2)


{
int aux;
while (Serial.available()>0){
aux=Serial.read();

if ((aux >= B10000000)&&(aux <= B11101111)){


// Si es byte STATUS legal:

*channel=(aux&B00001111)+1; //canales entre 1 y 16


*type=(aux&B11110000);
// Esperamos porque si an no han llegado los datos,
// los Serial.read() devolvern -1:

while (Serial.available() < 2){


}

*data1 = Serial.read();
*data2 = Serial.read();

break; // Sale porque ha ledo un mensaje MIDI correcto


}
}
}
Cdigo 5 - Funcin para leer mensajes MIDI haciendo uso de la gestin de buffers para evitar leer mensajes incompletos.
Nota: Se han definido los parmetros de la funcin como punteros para pasar los parmetros por referencia
(parmetros de entrada/salida).
A continuacin se muestra un programa completo que lee un mensaje MIDI, y si es un NoteOn en el canal 1
correspondiente a la nota C3 (nota 60, tecla Q en MIDI-OX) se enciende el LED integrado del pin 13 durante 1 segundo.
Importante !! : Es imprescindible desconectar totalmente los pines 0 (RX) y 1 (TX) mientras se carga el programa a la
placa Arduino, puesto que la programacin se realiza a travs del mismo puerto serie conectado al USB.
/*
Programa completo para la recepcin de mensajes MIDI. Copia y pega!
*/

byte type;
byte channel;
byte data1;
byte data2;

void setup() {
// Set MIDI baud rate:
Serial.begin(31250);
pinMode(13,OUTPUT);
}

void loop() {
channel=0;
type=0;
data1=0;
data2=0;
readMIDI(&channel,&type, &data1,&data2);
//type 0x90: Note On
//data1 60: C4 (tecla Q en MIDI-OX)
if ((channel==1)&&(type==0x90)&&(data1==60)){
digitalWrite(13,HIGH);
delay(1000);
}
else
{
digitalWrite(13,LOW);
}
}
void readMIDI(byte* channel ,byte* type, byte* data1, byte* data2)
{
int aux;
while (Serial.available()>0){
aux=Serial.read();

if ((aux >= B10000000)&&(aux <= B11101111)){


// Si es byte STATUS legal:

*channel=(aux&B00001111)+1; //canales entre 1 y 16


*type=(aux&B11110000);
// Esperamos porque si an no han llegado los datos,
// los Serial.read() devolvern -1:

while (Serial.available() < 2){


}

*data1 = Serial.read();
*data2 = Serial.read();

break; // Sale porque ha ledo un mensaje MIDI correcto


}
}
}

Cdigo 6 - Programa completo para leer mensajes MIDI haciendo uso de la gestin de buffers para evitar leer
mensajes incompletos.

Propuesta de ejercicio: Programacin de un 'MIDI-thru' selectivo

En este apartado se propone un ejercicio que utiliza simultneamente el MIDI IN y el MIDI OUT que hemos
construido sobre nuestro Arduino.

Importante: Si ests usando MIDI-OX, comprueba no est realizando un eco entre la entrada y la salida MIDI
de tu interfaz MIDI en View>Port routings... Si existiese una conexin entre la entrada y la salida MIDI de tu
interfaz, con el botn derecho sobre ella puede eliminarse para evitar realimentaciones indeseadas.

Se propone la elaboracin de un programa en Arduino que funcione como un MIDI-thru selectivo. El objetivo
es que los mensajes entrantes por nuestro MIDI-IN se vuelvan a enviar por el MIDI-OUT si cumplen alguna
condicin (por ejemplo, se pueden ignorar los Note Off para simular un pedal de sustain).

Si el programa funciona correctamente, se podrn enviar mensajes con el QWERTY en MIDI-OX y escucharlos
en el sintetizador que estemos usando.

Nota: Recuerda que los canales en el programa los estamos manejando entre 1 y 16, pero al enviarlos con
Serial.write() es necesario restarle uno, para que estn comprendidos entre 0 y 15.

*Sugerencias para un 'MIDI hack' en Arduino*

Un 'MIDI hack' es algn invento creativo que combina MIDI con otro tipo de elementos. Puedes encontrar
algunos MIDI hacks curiosos en http://hacknmod.com/tag/midi/ o en Youtube.

Ejemplo de MIDI HACK con Arduino, 'Laser Harp':


Midi Firmware for Arduino Uno (Moco)
Sunday April 12th, 2015

Midi Firmware for Arduino Uno (Moco)

Arduino-Uno-SMD Close-up of 8U2

1. Introduction
The design of the internal USB process on Arduino was changed since Arduino Uno in 2010.

Before Uno, Arduino Duemilanove for example, an special purpose chip is used to convert USB to serial. On Arduino
Uno, the chip is replaced by a general purpose CPU with USB peripheral circuit. With this change, the users of Arduino
got ability to reprogram the chip.

FTDIs FT232R chip is used for Arduino Duemilanove to process USB communication with PC. Atmels Mega8U2(or
16U2) is introduced on Arduino Uno. By default, Mega8U2/16U2 is program to act just like FT232RL. By
reprogramming Mega8U2/16U2, we can change Arduino Uno to act as Human Interface Device(HID), like mouse and
keyboard, for example.

Moco is one of alternative firmware for Mega8U2/16U2. By replacing the original firmware on Mega8u2/16U2 with
Moco, Arduino Uno will act as USB-MIDI device (Standard Midi Class), which is suitable to build music instruments and
devices.

With Moco, you dont need to install additional device drivers on Windows, MaxOSX, and linux, as Moco act as a device
of Standard Midi Class. It will recognize as MIDI device on iPad without any additional software.

2. How Moco works


Moco is a bridge program which converts USB-MIDI packets to serial MIDI signal, and vice versa.

It will receive serial MIDI from Arduinos main processor and send them to PC as USB-MIDI packet. It will receive
USB-MIDI packets from PC and send them to Arduinos main CPU as serial MIDI signal.
Moco on Uno
Your program on Arduinos main processor is just need to act as serial MIDI device. Moco takes care of USB-MIDI
process to communicate with PC. In other words, you need to write a program with MIDI library, you can build USB-
MIDI device.

In many cased, Arduino MIDI Library is used for the development of MIDI device for Arduino MIDI. Moco is compatible
with Arduino MIDI library.

Moco is based on LUFA as USB stack.

3. How to develop applications for Arduino Uno NEW!


It will be a little complicated process to the develop devices with Moco. This is because one need to go back and forth
between the original firmware and Uno in development process.

In order to write a program to Mega328, the original firmware for Mega8u2/16U2 is required. On the other hand,
Moco is required to test the program on USB-MIDI environment .

The following steps describe the details of the development process which I recommend.

1. Install dualMocoLUFA firmware to Mega8u2/16U2

In this step, I recommend to debug with serial MIDI environment, as you cannot use USB-MIDI at this point.

You need to use DFU programmer , or ISP, for the replacement. The following page describe the former method in
details.

http://arduino.cc/en/Hacking/DFUProgramming8U2

2. Write your program with Arduino IDE

Before connect Uno to PC, install a jumper between pin4 and pin6 on ICSP connector for Mega8u2/16U2. With the
jumper, Arduino-serial mode is initiated. You can use Arduino IDE to program mega328 on Uno.

Jumper on ICSP
3. Try your program with USB-MIDI firmware

Disconnect Uno and remove the jumper, then connect Uno again. This will initiate USB-MIDI bridge mode of
dualMocoLUFA. At this step, you can verify the device works as USB-MIDI. At this time, you can try your application
as USB-MIDI device .

If sometings goes wrong, back to step 2 and modify your program.Follows the instructions described step2, then
reprogram Mega328 with Arduino IDE.

4. Examples
(1) PSG shield
PSG shield which is designed by Genies-san and HKHacks-san, works on Arduino Uno with Moco firmware.

For Mega328, you need to install original firmware supplied for PSG shield. For Mega8U2/16U2, you need to install
Moco. You are ready to drive PSG shield from PC only with a USB cable.

http://shield.io/psg

PS shield
(2) FM (OPLL) shield

FM (OPLL) shield is under development. This shield will make use of Moco.

FM shield(OPLL)
Note the following examples are known to use Moco for the implementation of USB-MIDI on Arduino Uno.
(3) USB midi controller (Theremin style) on Arduino Uno
http://baldwisdom.com/usb-midi-controller-theremin-style-on-arduino-uno/

(4) AirHarp
http://www.airharp.com/

(5) DJ Shield 2 for arduino

http://www.dm9records.com/index.php/release/dj-shield2/

(6) USB MIDI interface for Raspberry Pi Controller

http://rpc.gehennom.org/2013/03/usb-midi-interface/

(7) A DIY Arduino MIDI Controller with Purpleheart

http://jazarimusic.com/finally-a-diy-midi-controller-with-purpleheart/

(8) MIDI Controller built by Arduino by @tadfmac

Homepage

Link to Slideshare Page

5. Download
The latest file is in github UPDATE 2015/04/11

6. Final Notes and future works


Moco firmware can use as USB-MIDI <-> USB-Serial bridge with a 8u2 or 32u4 board, like Adafruits 32u4 breakout
board.

I also plan to build a MIDI-based general platform, like Monaka, with Moco.