Partant en vacances prochainement, j’ai décidé de me faire un mini contrôleur MIDI au cas où le mauvais temps serait de la partie. En fouillant à droite, à gauche on trouve pas mal de chose sur la toile… Mais au final, je n’ai rien trouvé de réellement satisfaisant (Je ne suis pas très bon non plus en recherche Gougle)… Ce qui ressort le plus souvent:

Utilisation de la lib MIDI arduino, le problème pour moi c’est que l’utilisation de cette dernière oblige à utiliser une sortie midi (DIN 5) standard et donc du coup de devoir alimenter le contrôleur par une alimentation externe (usb ou secteur voir pile 9V)…Bref, je cherchais un truc pratique, qui ne m’oblige pas à brancher une interface midi physique. En gros je souhaite utiliser le port USB de l’arduino pour alimenter le contrôleur et pour faire les transferts de données midi. Il y a un HIC, la connectique USB de l’arduino est un leurre!!! En fait ce n’est qu’un port série camouflé dans une connectique USB pour schématiser… Alors là plusieurs solutions s’offrent à nous. Sous Windows il semblerait qu’il existe un pilote série FTDI hacké pour utiliser l’arduino en périph MIDI via USB, mais je n’ai pas de Windows…Il y a ensuite tout un tas de patch MaxMsp pour s’occuper de la conversion Serial -> Midi. Maxuino, Arduino2Max, … Mais encore une fois après plusieurs tests je n’ai pas réussi à obten ir ce que je souhaitais, un truc stable avec pas trop de latence. Ces patch peuvent être pas mal mais ils manquait à chaque fois:

- Un filtre incorporé, permettant de se jouer de l’instabilité « analogique»  des potards low price, en effet branché sur une entrée analogiue d’une arduino un potard est censé vous donner des valeurs entre 0 et 1023, mais vous vous apercevrez rapidement que cette valeur n’est pas stable, et bouge régulièrement sans pour autant bouger le potentiomètre. Pour vous en rendre compte c’est très simple allez, premier petit exercice de ce poste:

Faites le montage suivant, peut importe la valeur de résistance du potentiomètre:

Puis saisissez le code suivant:

void setup()

{

Serial.begin(9600); // init de la communication série

}

void loop()

{

Serial.println(analogRead(0)); // écrit sur le port série la valeur lue sur l’entrée analogique 0

delay(100); // un petit delay histoire de pouvoir lire ce qui s’inscrit dans la console

}

Uploader ce code sur votre carte Arduino, et lancez le moniteur série de l’IDE Arduino:

En lançant le moniteur série vous pourrez vous rendre compte de cela:

Pour remédier à cela j’ai trouvé des méthodes ou autres patchs MAx normalement permettant de lisser tout cela, mais toutes les solutions trouvées ne m’allaient pas en ce sens que soit cela ajoutait une latence importante soit un lissage non effectif… Bref j’ai adopté une méthode très simple permettant le filtrage ainsi qu’un non engorgement du port série/midi…Car je ne l’ai pas dit pour l’instant mais toutes les solutions que j’ai trouvées sur la toile envoient des données en permanence même si les valeurs des potards ne bougent pas!!!
Donc une petite boucle très simple avec une condition du genre « si valeur potard ancien – valeur potard actuel >=2 alors balancer la valeur sur le port série et valeur potard ancien = valeur potard actuel…»  on filtre et on envoie que ce qui est intéressant…
Reste un truc important à régler, comment je transforme mon signal série en signal midi lisible par mes séquenceurs? Eh bien à cette question je répondrai par un lien:

Spikenzielabs.com

C’est un petit soft développé sous Processing qui transforme directement les infos provenant de vos ports série en données midi:

Un petit bout de code Arduino est donné avec vous expliquant comment vous en servir.

Ces explications étant terminées, je vous livre brut de pomme ce dont je me sers aujourd’hui pour un mini contrôleur envoyant 4 Control Change pour faire mumuse sous Live:

Code arduino (sachant que je ne suis pas un développeur, il reste pleins de choses à faire, du genre créer des fonctions passer certaines valeurs en tant que variable, ce qui simpliefirait et rendrait plus souple ce code):

//Analog pin ZERO
int valuePinZero=0;
int valuePinZero2=0;

//Analog pin ONE
int valuePinOne=0;
int valuePinOne2=0;

//Analog pin TWO
int valuePinTwo=0;
int valuePinTwo2=0;

//Analog pin THREE
int valuePinThree=0;
int valuePinThree2=0;

void setup()
{
Serial.begin(57600);
}

void loop()
{
//controller ZERO
//————————
valuePinZero = (analogRead(0)/8);
if (valuePinZero – valuePinZero2 >=2 || valuePinZero2 – valuePinZero >=2)
{

valuePinZero2 = valuePinZero;

MIDI_TX(176,75, valuePinZero);
//delay(100);
}

//controller ONE
//————————
valuePinOne = (analogRead(1)/8);
if (valuePinOne – valuePinOne2 >=2 || valuePinOne2 – valuePinOne >=2)
{

valuePinOne2 = valuePinOne;

MIDI_TX(176,76, valuePinOne);
//delay(100);
}

//controller TWO
//————————
valuePinTwo = (analogRead(2)/8);
if (valuePinTwo – valuePinTwo2 >=2 || valuePinTwo2 – valuePinTwo >=2)
{

valuePinTwo2 = valuePinTwo;

MIDI_TX(176,77, valuePinTwo);
//delay(100);
}

//controller THREE
//————————
valuePinThree = (analogRead(3)/8);
if (valuePinThree – valuePinThree2 >=2 || valuePinThree2 – valuePinThree >=2)
{

valuePinThree2 = valuePinThree;

MIDI_TX(176,78, valuePinThree);
//delay(100);
}

}

void MIDI_TX(unsigned char MESSAGE, unsigned char CONTROLNUM, unsigned char VALUE)
{
Serial.print(MESSAGE);
Serial.print(CONTROLNUM);
Serial.print(VALUE);
}

Schémas Arduino:

Ne vous reste plus qu’à trouver une petite boite pour mettre tout cela dedans et hop, pour 25 euros un petit contrôleur midi fait maison pour vous accompagner en voyage.

J’ai récupéré une boite de cellules Ortofon pour m’en faire un petit:

Comme vous le constaterez mes 4 potards sont serrés sur la gauche… Dans les jours à venir je vais y greffer très certainement:

- Deux FSR histoire de me faire un mini drum pad

- Un LCD un encodeur et deux boutons, pour rendre la « chose»  plus modulable et choisir les CC que l’on souhaite utiliser et non les fixer en dur dans le code…

En espérant que cela puisse vous être utile.

EATYone