====== Arduino et MIDI ======

Cette page est destinée à faire comprendre comment faire apparaître la carte Arduino comme un appareil midi via USB. Cette fonctionnalité est très utile car elle permet d'éviter l'installation de drivers sur les ordinateurs, comme dans une salle de classe de Collège où tous les ordinateurs sont sur un Windows décentralisé... 

Seules les cartes **Uno**, **Mega** et **Leonardo** peuvent être utilisée comme cela. En effet, sur les cartes Uno et Mega, il existe un petit micro-contrôleur (souvent **atmega8u2** ou **atmega16u2**) qui est dédié à la communication entre le port USB et le micro-contrôleur principal. C'est l'interface de communication. Par défaut le programme à l'intérieur utilise une communication Série, mais comme celui-ci est programmable, nous pouvons le changer pour faire apparaître l'Arduino en tant qu'appareil Midi, Joystick ou clavier. Pour informations, sur les anciennes cartes Arduino, il n'y avait pas ce micro-contrôleur, il y avait un composant nommé FTDI, pour la communication série. Étant propriétaire, il n'était pas modifiable. Sur la Leonardo, tout est compris dans le micro-contrôleur **atmega32u4**, la méthode est différente.

===== Arduino Uno Midi =====

Ressources : 
  * https://www.arduino.cc/en/Hacking/MidiWith8U2Firmware
  * http://www.arduino.org/learning/tutorials/hackings/updating-the-atmega-8u2-and-16u2-on-an-uno-or-mega-using-dfu
  * http://www.kevindemarco.com/2014/01/02/arduino-uno-as-a-usb-hid-interface/
  * https://github.com/kuwatay/mocolufa
  * https://github.com/ddiakopoulos/hiduino
  * https://github.com/FortySevenEffects/arduino_midi_library

==== 1 - DFU-programmer ====

{{:logiciels:arduino-midi:atmega16u2.png?600|}}

Sur les cartes Arduino Uno et Mega, il faut pouvoir reprogrammer le micro-contrôleur ATMEGA16U2. Pour cela il faut d'abord installer un programme sur votre ordinateur qui va pouvoir communiquer avec lui : le dfu-programmer (DFU pour //Device Update Firmware//). Ressource : [[https://www.arduino.cc/en/Hacking/DFUProgramming8U2|DFUProgramming8U2]].

Sur UBUNTU/Linux, cette commande installe le programme:
<code>sudo apt-get install dfu-programmer</code>

Mais la version semble ancienne (0.6.2) et ne pas prendre en compte la cible recherchée ici "atmega16u2".
<code>
dfu-programmer --version // pour vérifier la version
dfu-programmer --targets // pour lister les cibles, nous devrions y trouver atmega16u2
</code>

Il est donc nécessaire d'installer la dernière version. Télécharger la dernière version : https://sourceforge.net/projects/dfu-programmer/files/latest/download?source=files
<code>sudo apt-get install build-essential libusb-1.0-0-dev
cd dfu-programmer-0.7.2/
./bootstrap.sh
./configure
make
sudo make install
</code>

Nous avons maintenant une version plus récente (0.7.2) et dans la liste des cibles (targets), nous avons enfin "atmega16u2"
<code>dfu-programmer --version
dfu-programmer --targets</code>


==== 2 - Flash atmega16u2 ====
Pour reprogrammer la puce, on parle de //flash//.

<WRAP center round important 60%>
Attention, pour les cartes UNO rev.1 il faut souder une résistance comme sur cette [[https://www.arduino.cc/en/uploads/Hacking/Uno-back-DFU-resistor.png|image]].
</WRAP>


**1 - Reset**\\
Il faut d'abord faire un reset de la puce. Il faut connecter la carte Arduino en USB à l'ordinateur et connecter le GND et RESET des pins mâles au dessus de la puce atmega16u2, avec un //jumper// par exemple. Ces pins sont utiles pour programmer un micro-contrôleur de l'extérieur (//ISP//). Voir une [[https://www.youtube.com/watch?v=E8XyRwXQr8Q|vidéo]] de la manipulation.
{{:logiciels:arduino-midi:arduinouno_r3_front_450px.jpg|}}

À partir de ce moment-là, la carte Arduino n'est plus reconnue en tant que périphérique USB/Série.


**2 - Erase**\\
Après avoir enlever le //jumper//. Vous pouvez entrer cette commande pour effacer le programme de la puce
<code>sudo dfu-programmer atmega16u2 erase 
Checking memory from 0x0 to 0x2FFF...  Not blank at 0x1.
Erasing flash...  Success
</code>

**3 - Remettre le programme par défaut**\\
Ce n'est pas notre intention ici, mais vous pouvez revenir en arrière et remettre le programme par défaut, celui qui fait apparaître l'Arduino comme un appareil série.

Aller dans le répertoire de votre logiciel Arduino et naviguer pour trouver le répertoire "atmegaxxu2"
<code>cd ~/Softs/arduino-1.6.8/hardware/arduino/avr/firmwares/atmegaxxu2/arduino-usbserial</code>

Vous trouverez un fichier "Arduino-usbserial-uno.hex", c'est lui que nous allons flasher pour retrouver le comportement par défaut de la carte.
<code>sudo dfu-programmer atmega16u2 flash Arduino-usbserial-uno.hex
Checking memory from 0x0 to 0xFFF...  Empty.
0%                            100%  Programming 0x1000 bytes...
[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]  Success
0%                            100%  Reading 0x3000 bytes...
[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]  Success
Validating...  Success
0x1000 bytes written into 0x3000 bytes memory (33.33%).
</code>

Vous devriez pouvoir réutiliser l'Arduino comme avant.

==== 3 - Flash atmega16u2 avec le Midi ====

  - Télécharger **MOCOLufa** et dézipper le: https://github.com/kuwatay/mocolufa
  - **Reset** de l'atmega16u2, comme vu précédemment 
  - **Erase**
  - **Flash** du firmware Midi : **sudo dfu-programmer atmega16u2 flash mocolufa/HEX/dualMoco.hex**
<code>
$ sudo dfu-programmer atmega16u2 flash dualMoco.hex 
Checking memory from 0x0 to 0x167F...  Empty.
0%                            100%  Programming 0x1680 bytes...
[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]  Success
0%                            100%  Reading 0x3000 bytes...
[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]  Success
Validating...  Success
0x1680 bytes written into 0x3000 bytes memory (46.88%).
</code>

C'est ce firmware qui permet de faire passer l'Arduino comme un périphérique Midi. C'est lui qui fait tout le travail ! En plus, il permet une autre fonctionnalité très pratique, de  basculer en mode MIDI (par défaut) ou //serial// en connectant simplement les pins 4 et 6 de l'ISP, avec un //jumper//, comme sur cette photo.
{{:logiciels:arduino-midi:atmega16u2-mocolufa-serial.jpg?600|}}

Car vous ne pouvez pas reprogrammer l'Arduino en mode Midi. Vous ne pouvez le faire qu'en mode //serial// ou bien en passant par les pins //ISP// du micro-contrôleur principal. Vous pouvez ainsi assez facilement programmer l'Arduino et ensuite utiliser l'Arduino comme appareil MIDI. Pour basculer, il faut débrancher/rebrancher le câble USB.

En tapant la commande "lsusb", on voit apparaître une ligne "Atmel Corp. LUFA MIDI" nous indiquant que l'Arduino est désormais perçu par l'ordinateur comme un périphérique Midi.
{{:logiciels:arduino-midi:lsusb_midi_uno.png?600|}}

==== 4 - Programme Arduino Midi ====
  - Télécharger : https://github.com/FortySevenEffects/arduino_midi_library/releases/tag/4.2
  - Installer la bibliothèque **MIDI** dans votre dossier Arduino/libraries
  - Passer l'Arduino en mode //serial// (voir au dessus).  Débrancher, rebrancher. Vous verrez alors apparaître la carte dans le sélecteur de Ports du logiciel Arduino. 
  - Téléverser un exemple de la bibliothèque MIDI
  - Passer l'Arduino en mode Midi en enlevant simplement le //jumper//. Débrancher, rebrancher.
  - Visualiser le résultat sur un logiciel Midi

===== Arduino Leonardo Midi =====

La méthode est un peu plus simple car nous n'avons pas besoin de //flasher//. La plus récente consiste à utiliser l'environnement développer pour la carte Teensy dans Arduino et de faire passer la Leonardo comme une Teensy.

Ressources : 
  * https://learn.adafruit.com/untztrument-trellis-midi-instrument/code
  * http://www.pjrc.com/teensy/td_midi.html
  * https://learn.adafruit.com/add-boards-arduino-v164
  * https://github.com/adafruit/TeeOnArdu

==== 1 - Installer TeensyDuino  ====

Respectez la méthode d'installation sur https://www.pjrc.com/teensy/td_download.html

Attention, la version de TeensyDuino doit être compatible avec votre version d'Arduino. Par exemple, pour l'instant (25/10/2016), il faut utiliser Arduino 1.6.11, la version pour Arduino 1.6.12 n'est pas encore prête.
==== 2 - Installer de nouvelles cartes ==== 
Avec la nouvelle version d'Arduino, il est très facile d'ajouter du matériel. Il suffit d'ouvrir les préférences "Fichier > préférences" et d'ajouter le lien Internet suivant : <code>https://adafruit.github.io/arduino-board-index/package_adafruit_index.json</code>

{{:logiciels:arduino-midi:flora_urls.png|}}

Ensuite, nous allons installer le paquet **Adafruit TeeOnArdu**, en ouvrant le gestionnaire de carte "Outils > Carte > Gestionnaire de carte" , puis en sélectionnant "Adafruit TeeOnArdu" et en cliquant sur "installer".

{{:logiciels:arduino-midi:teeonardu_board.png|}}


==== 3 - Sélectionner la bonne carte ==== 
  - "Outils > carte TeeOnArdu"
  - "USB Type > Midi"

{{:logiciels:arduino-midi:teeonardu_selection.png|}}


==== 4 - Programme Arduino ==== 
N'importe quel programme pour la teensy marchera pour la Leonardo, voir http://www.pjrc.com/teensy/td_midi.html


<WRAP center round info 60%> Une fois le programme téléversé dans la carte Arduino, il faudra appuyer sur le bouton Reset de la carte pour la reprogrammer, car par défaut elle sera vue comme un appareil Midi.</WRAP>


++++ Code Midi Leonardo et Teensy | 
<code cpp>// the MIDI channel number to send messages
const int channel = 4;

// the MIDI continuous controller for each analog input
const int controllerA0 = 0;
const int controllerA1 = 1;
const int controllerA2 = 2;
const int controllerA3 = 3;
const int controllerA4 = 4;
const int controllerA5 = 5; 

// store previously sent values, to detect changes
int previousA0 = -1;
int previousA1 = -1;
int previousA2 = -1;
int previousA3 = -1;
int previousA4 = -1;
int previousA5 = -1;
elapsedMillis msec = 0;

void setup() {
}

void loop() {
  // only check the analog inputs 50 times per second,
  // to prevent a flood of MIDI messages
  if (msec >= 20) {
    msec = 0;
    int n0 = analogRead(A0) / 8;
    int n1 = analogRead(A1) / 8;
    int n2 = analogRead(A2) / 8;
    int n3 = analogRead(A3) / 8;
    int n4 = analogRead(A4) / 8;
    int n5 = analogRead(A5) / 8;    
    // only transmit MIDI messages if analog input changed
    if (n0 != previousA0) {
      usbMIDI.sendControlChange(controllerA0, n0, channel);
      previousA0 = n0;
    }
    if (n1 != previousA1) {
      usbMIDI.sendControlChange(controllerA1, n1, channel);
      previousA1 = n1;
    }
    if (n2 != previousA2) {
      usbMIDI.sendControlChange(controllerA2, n2, channel);
      previousA2 = n2;
    }
    if (n3 != previousA3) {
      usbMIDI.sendControlChange(controllerA3, n3, channel);
      previousA3 = n3;
    }
    if (n4 != previousA4) {
      usbMIDI.sendControlChange(controllerA4, n4, channel);
      previousA4 = n4;
    }
    if (n5 != previousA5) {
      usbMIDI.sendControlChange(controllerA5, n5, channel);
      previousA5 = n5;
    }
  }

  // MIDI Controllers should discard incoming MIDI messages.
  // http://forum.pjrc.com/threads/24179-Teensy-3-Ableton-Analog-CC-causes-midi-crash
  while (usbMIDI.read()) {
    // ignore incoming messages
  }
}</code>++++