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 años 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 años 60 (y el protocolo MIDI fue desarrollado veinte años 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 pequeña 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 López (@alvarolrevuelta) y hoy os enseñaré como fabricar vuestro propio piano controladorusando Arduino y MIDI. Muchos diréis ¿Qué es eso del MIDI? ¿Para qué sirve? Pues muy sencillo, MIDI (Musical Instrument Digital Interface) es un protocolo de comunicación serial que permite conectar ordenadores, sintetizadores, controladores y demás elementos destinados a la creación de sonidos. Dicho protocolo data de los años ochenta pero aún se sigue usando hoy en día 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 botón ha sido pulsado y qué nota debe enviar (un Do, un Re,...). Una vez en el ordenador deberemos usar algún 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 (también se pueden usar menos) x01 Resistencia 10k Ohm Arduino UNO y cable USB ProtoBoard Programa Arduino DFU-Programmer (sobre Linux o Mac) Hiduino Firmware Librería MIDI 1. Realizar conexiones Pero vayamos paso a paso, lo primero conectar los 11 botones. Como podéis ver la conexión es muy sencilla, conectamos cada botón 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 código). Ojo si usáis el pin 13, que requiere una resistencia de pullup externa.
2. Introducir código prueba (no es MIDI) Hasta aquí fácil ¿no?. Vamos a cargar un código que verifique el correcto funcionamiento de todos los botones. Aún 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
pinMode(i+2, INPUT_PULLUP); valorAnterior[i]=1;
// Recorremos cada pin y lo ponemos como entrada // Inicializamos el valor anterior a 1 (no pulsado)
} }
void loop(){ for(int i=0; i
}
Ahora abrir el puerto serial con un baud rate de 9600 e ir pulsando y liberando los botones. Podréis ver como al pulsarlo se nos indica por el monitor serial que botón 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 código que usaremos. 3. Vamos con MIDI A continuación debemos cargar el siguiente código. Este código hace uso de la librería MIDI de Arduino. (Descargar la librería e instalarla). Simplemente se emplea un baud rate de 31250 y se envía mensajes serial con la sintaxis de MIDI. Nos centraremos en el mensaje de NoteOn es decir, nota activada. Este mensaje lleva información de la nota pulsada (Do, Re,...), con que intensidad se pulsó esta nota (127 es el máximo, nosotros usaremos el máximo ya que nuestros botones no tienen sensibilidad) y en que canal MIDI se quiere enviar el mensaje (hay 16 disponibles). Cargamos el código, nada más. #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
// Inicializamos el valor anterior a 1 (no pulsado)
} }
void loop(){ for(int i=0; i
}
Se puede apreciar que el código es muy parecido al anterior, solo que cuando se detecta botón pulsado/liberado se envía un mensaje de nota activada o desactivada. El valor de nota enviado por el primer botón es 48 que según el protocolo MIDI corresponde a DO. Por lo tanto el siguiente botón 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 fácil para después. Ahora nos tenemos que bajar el "dfu-programmer". Si estamos en Linux:
sudo apt-get install dfu-programmer A continuación necesitaremos que nuestro Arduino entre en modo DFU para que se nos permita introducirle el código. Antes de nada es muy importante que hayáis cargado el código anterior (el del MIDI). Una vez que introducimos este nuevo firmware, no podemos volver a meter código en el Arduino, pero ¡tranquilos! que si volvemos a meter el firmware original de Arduino todo volverá a la normalidad (Se hace de manera idéntica a introducir cualquier firmware). Como he dicho hay que entrar en modo DFU con nuestro Arduino, para ello:
Mira tu versión: 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 Deberás ver como una luz parpadea y se apaga, retira las conexiones anteriores. Estás en modo DFU.
Si todo ha salido correctamente y dejasteis el HIDUINO_MIDI.hex en el Escritorio, deberías 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. Conéctalo al programa de audio que desees (Ableton, Cubase, Nuendo, Sonar, Traktor,...), asígnale 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, we’ve got a complete Arduino beginner’s 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, it’s 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 número de controlador y un valor entre 0 y 127. Los mensajes de CC se utilizan a menudo para cambiar la configuración, como el volumen o el tono. Dispositivos que aceptan MIDI debe venir con un manual explicando qué canales y mensajes están configurados por defecto, y cómo cambiarlos (conocida como mapeo MIDI). Cambio de programa (PC) Los mensajes son más simples que los mensajes CC. mensajes del PC constan de un solo número, 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 añadir más botones o hardware para satisfacer sus necesidades. Casi cualquier Arduino será adecuado - sólo 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 solución robusta.
Ensamblaje del circuito
MIDI Conneccion
Cablear el zócalo MIDI de la siguiente manera: • MIDI pin 5 a Arduino transmisión (TX1 a través de una resistencia de 220 ohmios • MIDI pin 4 a Arduino + 5V a través 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 través de una resistencia de 10k ohm (un "desplegable" resistencia, asegurando el valor se mantiene baja). Cuando se pulsa el botón, 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 botón de + 5V • El lado derecho del botón para Arduino tierra a través de una resistencia de 10k ohm • El lado derecho del botón 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 código por ir al Sketch > Include Library > MIDI. Usted también 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 código 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 - Instalación de los controladores y configuración El Junta y puerto Procedimientos iniciales con el Arduino starter kit - Instalación de los controladores y configuración La Junta y PortSo, que ha comprado a sí mismo un kit de iniciación Arduino, y posiblemente algunos otros componentes fresco al azar - y ahora qué? ¿Cómo se puede realmente comenzar con la programación de Arduino esta cosa? ¿Cómo se ajusta hasta que ... LEER MÁS
#include #include #include #include #include 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 código se envía 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: • Asegúrese 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 • Asegúrese de que el Arduino tiene poder • Instalar el controlador correcto para la interfaz USB-MIDI Si todavía tiene problemas que podría ser digno de la comprobación 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 código 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 código (pero mantener el cable USB está conectado) y abrir el monitor serie (Top Right > Serial Monitor). Cuando se pulsa un botón debería ver "botones de One Works!" O "Botón dos obras!", Dependiendo del botón 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 después de comprobar de nuevo el botón. Esto aumenta la precisión del botón de prensa y ayuda a prevenir el ruido de la activación 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 botón que se presiona. Estoy usando esto para controlar Ableton Live 9.6 en OS X. El código es similar tanto a las muestras de prueba anteriores.
#include #include #include #include #include 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, I’d 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 gustaría crear un dispositivo MIDI original y creativo? En este tutorial te enseñaremos cómo hacerlo con Arduino. El tutorial primero ofrece una visión general de Arduino y cómo se puede aplicar al mundo musical. Posteriormente, explica cómo 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 supervisión de Ana María Barbancho (profesora responsable) como práctica de la asignatura 'Laboratorio de Equipos de Audio', de la titulación de Grado en Ingeniería de Sonido e Imagen de la Universidad de Málaga. Creemos que puede ser de gran interés para aquellos interesados, o curiosos de Arduino. No obstante, la dificultad de este tutorial es creciente, y para completarlo es conveniente tener unos conocimientos mínimos de electrónica y de programación.
1. ¿Qué es Arduino? Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y un entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos multidisciplinares. Las placas se pueden adquirir en su página web (o montarlas a mano...) y el entorno de desarrollo integrado libre se puede descargar gratuitamente. Al ser open-hardware, tanto su diseño como su distribución 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 electrónica, con una amplia documentación en Internet, y no es necesario tener grandes conocimientos de electrónica para crear cosas sorprendentes. La página web oficial de Arduino es http://arduino.cc/ (la versión española es http://arduino.cc/es, pero es menos completa), y en ella puede encontrarse el software necesario, tutoriales y documentación, 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 características necesarias para montar un dispositivo MIDI por tan sólo 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 sólo 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 más recientes de Arduino (como Arduino Yun) poseen mejores prestaciones y merecería la pena seguir indagando en sus posibilidades para aplicarlas a la música. En este tutorial nos centraremos sólo en el manejo de mensajes MIDI en Arduino Uno (y superiores), ya que la síntesis de audio es un tema diferente y daría para un tutorial mucho más largo que este (ejemplo). Para comprender mejor qué es el MIDI, recomiendo este fantástico tutorial posteado en Hispasonic. El enfoque típico 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 electrónica, o se pueden encargar por Internet.
Figura 2 - Enfoque típico para elaborar dispositivos MIDI en Arduino.
3. Instalación de Arduino Uno y ejecución del ejemplo 'Blink.ino' La instalación de Arduino es bastante sencilla: es necesario instalar el entorno de desarrollo y configurar los drivers de la placa. En la versión española de la web oficial, se puede encontrar las instrucciones detalladas para instalar Arduino: http://arduino.cc/es/Guide/Windows. Aunque con eso debería de ser suficiente, en la versión inglesa aparecen unas instrucciones aún más detalladas: http://arduino.cc/en/Guide/Windows. Siguiéndolas, ya deberíamos 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 botón 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 través 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 funcionaría de forma autónoma igualmente. Para aprender a conectar LEDs, botones, potenciómetros... Muy recomendado: http://arduino.cc/es/Tutorial/HomePage
4. Cableando un conector MIDI de salida y ejecución 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 conexión 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 extraído 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 cuáles son los pines 5, 2, y 4 en un conector real, véase la siguiente foto:
Figura 4 - ¡Cuidado con la numeración de los pines! Si estas conexiones no se realizan correctamente, nuestro Arduino no emitirá ningún mensaje MIDI, e incluso puede llegar a dañarse. 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 estándar:
Figura 5 - Cable MIDI estándar Conectamos el MIDI OUT del Arduino al MIDI IN de una interfaz MIDI para ordenador o a un sintetizador. A continuación, ejecuta el ejemplo Archivo>Ejemplos>04.Communication>MIDI y cárgalo. Este ejemplo envía
secuencialmente una escala cromática ascendente. Para escuchar estos mensajes MIDI, es necesario algún tipo de instrumento virtual que actúe de sintetizador.
5. Extra: Análisis 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 información 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. Elaboración 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 función noteOn para que la selección de channel sea más 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); } Código 1 - Función alternativa a la ofrecida en 'MIDI.ino' para generar NoteOn. El uso de los canales se ha facilitado y están comprendidos entre 1 y 16. Nota: En Arduino, un número binario lleva el prefijo B (válido para un máximo de 8 bits), y un número 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); } Código 2 - Función para generar un NoteOff según 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 envía algunas notas utilizando estas funciones. Por ejemplo, puedes hacer uso de diferentes canales. 6.2. Control change
Cualquier sintetizador tiene numerosos parámetros que pueden ser controlados vía MIDI. Un parámetro puede asignarse a cualquier número de control MIDI (0ccccccc), aunque existen algunos valores que siempre están asociados a características 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 función que envíe 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); } Código 3 - Función para generar un mensaje de cambio de parámetro 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 técnicas como el vibrato, el bending o el glissando. Para ello, es posible enviar un mensaje de "cambio de rueda de tono" (muy común en los controladores MIDI). Vamos a implementar una función que envíe este tipo de parámetros: 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); } Código 4 - Función que genera un mensaje de cambio de rueda de pitch. Observa cómo 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 configuración de MIDI OUT también funciona como MIDI IN, utilizaremos una configuración algo más compleja para evitar daños por exceso de corriente. Esta configuración es la recomendada en la mayoría 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 daños. Nota: El diodo común de pequeña señal 1N4148 podría sustituir al diodo 1N914. Envío 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 opción Actions>Keyboard, y el teclado del ordenador pasará a funcionar como un teclado MIDI según la distribución siguiente:
Nota: La tecla Q, por defecto, envía la nota MIDI C4 (número 60).
8. Gestión en Arduino de mensajes MIDI entrantes Esta sección del tutorial creo que es la más valiosa y la que más horas de trabajo tiene, ya que la gestión de mensajes MIDI no es fácil y cuesta mucho trabajo encontrar documentación para realizarla correctamente. Para recibir los mensajes MIDI, se hará uso de las siguientes funciones: · Serial.available(): Devuelve el número de bytes (caracteres) disponibles para ser leidos por el puerto serie. Se refiere a datos ya recibidos y disponibles en el buffer de recepción 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 sólo cuando ya han sido recibidos. A continuación se presenta la implementación de una función que devuelve los parámetros de un mensaje MIDI entrante de 3 bytes. Si se detecta el primer byte de un mensaje MIDI válido (byte de status), la función 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 aún no han llegado los datos, // los Serial.read() devolverán -1: while (Serial.available() < 2){ } *data1 = Serial.read(); *data2 = Serial.read(); break; // Sale porque ha leído un mensaje MIDI correcto } } } Código 5 - Función para leer mensajes MIDI haciendo uso de la gestión de buffers para evitar leer mensajes incompletos. Nota: Se han definido los parámetros de la función como punteros para pasar los parámetros por referencia (parámetros de entrada/salida). A continuación 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 programación se realiza a través del mismo puerto serie conectado al USB.
/* Programa completo para la recepción 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 aún no han llegado los datos, // los Serial.read() devolverán -1: while (Serial.available() < 2){ } *data1 = Serial.read(); *data2 = Serial.read(); break; // Sale porque ha leído un mensaje MIDI correcto
} } }
Código 6 - Programa completo para leer mensajes MIDI haciendo uso de la gestión de buffers para evitar leer mensajes incompletos. Propuesta de ejercicio: Programación de un 'MIDI-thru' selectivo
En este apartado se propone un ejercicio que utiliza simultáneamente el MIDI IN y el MIDI OUT que hemos construido sobre nuestro Arduino. Importante: Si estás 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 conexión entre la entrada y la salida MIDI de tu interfaz, con el botón derecho sobre ella puede eliminarse para evitar realimentaciones indeseadas. Se propone la elaboración 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 condición (por ejemplo, se pueden ignorar los Note Off para simular un pedal de sustain). Si el programa funciona correctamente, se podrán 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 estén comprendidos entre 0 y 15. *Sugerencias para un 'MIDI hack' en Arduino*
Un 'MIDI hack' es algún 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. FTDI’s FT232R chip is used for Arduino Duemilanove to process USB communication with PC. Atmel’s 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 don’t 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 Arduino’s main processor and send them to PC as USB-MIDI packet. It will receive USB-MIDI packets from PC and send them to Arduino’s main CPU as serial MIDI signal.
Moco on Uno Your program on Arduino’s 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 USBMIDI 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 Adafruit’s 32u4 breakout board. I also plan to build a MIDI-based general platform, like Monaka, with Moco.
