Unopad - Contrôleur MIDI Arduino avec Ableton

Outils et machines nécessaires

Fer à souder (générique) Facultatif

Applications et services en ligne

À propos de ce projet

Résumé

La plupart des tutoriels et projets pour les contrôleurs Midi sont basés uniquement sur une explication du travail d'Arduino, mais pas tellement sur son utilisation dans la DAW elle-même. Je veux créer un tutoriel avec toutes les choses nécessaires en un seul endroit. Avec ce projet, je voulais aider les débutants à mieux comprendre le processus de création et d'utilisation d'un contrôleur, et j'espère qu'il sera utile à quelqu'un.

Je voulais faire un contrôleur midi depuis longtemps et je l'ai finalement fait et maintenant je vais partager le projet avec vous. J'ai utilisé un Arduino Uno qui n'a pas la possibilité d'envoyer des messages MIDI via USB, donc des programmes spéciaux ont dû être utilisés pour cela (sera expliqué plus loin dans le texte).

Les sections suivantes décriront le circuit électrique, le code Arduino, ainsi que la façon de se connecter à un ordinateur et à un DAW, dans ce cas Ableton.

Circuit

C'est un circuit très simple. J'ai utilisé 9 boutons-poussoirs, mais pas dans la matrice, car je voulais pouvoir appuyer sur plusieurs boutons (c'est plus facile et j'ai des broches numériques inutilisées - j'utilise 9, dans la matrice, ce serait 6).

Bouton 3 ==> D2 Bouton 2 ==> D3 Bouton 1 ==> D4 Bouton 6 ==> D5 Bouton 5 ==> D6 Bouton 4 ==> D7 Bouton 9 ==> D8 Bouton 8 ==> D9 Bouton 7 ==> D10  

Mappages MIDI

J'ai défini 9 notes MIDI, de 36 à 45, et NOTE_ON et NOTE_OFF.

Ce didacticiel MIDI vous aidera à comprendre comment vous pouvez utiliser le langage MIDI pour contrôler tout appareil utilisant le protocole MIDI.

#define NOTE_ONE 36#define NOTE_TWO 37// Définissez toutes les notes ici.#define NOTE_ON_CMD 0x90#define NOTE_OFF_CMD 0x80#define MAX_MIDI_VELOCITY 127  

MIDI sur USB

Parce qu'Arduino Uno ne peut pas envoyer de notes MIDI à DAW par lui-même, nous devons utiliser deux programmes supplémentaires - LoopMidi et Hairless MIDI<->Serial Bridge.

Avec LoopMidi, nous créons un port MIDI virtuel que nous pouvons utiliser dans Hairless Midi pour nous connecter au port Arduino.

Explication du code

J'ai créé la classe Button et je l'utilise comme ceci :

int NUMBER_BUTTONS =9;Bouton Bouton1(4, NOTE_ONE);Bouton Bouton2(3, NOTE_TWO);Bouton Bouton3(2, NOTE_THREE);Bouton Bouton4(7, NOTE_FOUR);Bouton Bouton5(6, NOTE_FIVE);Bouton Bouton6(5, NOTE_SIX);Bouton Bouton7(10, NOTE_SEVEN);Bouton Bouton8(9, NOTE_EIGHT);Bouton Bouton9(8, NOTE_NINE);Bouton *Boutons[] {&Bouton1,&Bouton2,&Bouton3,&Bouton4,&Bouton5,&Bouton6 ,&Button7,&Button8,&Button9} ;  

Pour en savoir plus sur la mise en œuvre des boutons, consultez Buttons.cpp.

Parce que nous n'utilisons aucune résistance mais connectons uniquement le bouton à la broche numérique et à la terre, nous utilisons INPUT_PULLUP au lieu de INPUT.

//Buttons.cpppinMode(_pin, INPUT_PULLUP);  

La seule partie délicate avec ceci est que vous ne recherchez pas un HIGH signal comme vous pourriez le supposer - votre bouton émettra LOW (0) lorsqu'il est enfoncé.

 // Le bouton est enfoncé if (state ==0) { midiNoteOn(Buttons[i]->Note,127); } // Le bouton n'est pas enfoncé si (état ==1) { } 

Cela signifie également que l'état initial du bouton est 1, pas 0.

//Buttons.cpp _state =1; 

Chaque message NOTE ON requiert son message NOTE OFF correspondant. Lorsque le bouton est enfoncé, il envoie un message NOTE_ON. Lorsque le bouton est relâché, il envoie un message NOTE_OFF, donc en plus de l'état initial, j'ai ajouté le dernier état mémorisé au code.

//Buttons.cpp _lastState =1; 

Nous n'envoyons des messages MIDI que si l'état actuel est différent du dernier état.

//Buttons.cppif(state!=_lastState){//....} 

Utilisez ces deux fonctions pour envoyer des messages MIDI. Les paramètres des fonctions sont note et midiVelocity (J'ai utilisé la vitesse maximale).

void midiNoteOn(byte note, byte midiVelocity){ Serial.write(NOTE_ON_CMD); Serial.write(note); Serial.write(midiVelocity);}void midiNoteOff(byte note, byte midiVelocity){ Serial.write(NOTE_OFF_CMD); Serial.write(note); Serial.write(midiVelocity);} 

J'ai mis la logique du programme dans la fonction updateButtons fonction.

void updateButtons() { for (int i =0; i getButtonState(); // Le bouton est enfoncé if (state ==0) { midiNoteOn(Buttons[i]->Note,127); } // Le bouton n'est pas enfoncé si (état ==1) midiNoteOff(Buttons[i]->Note,0) ; } } 

La fonction est appelée à l'intérieur de la méthode de boucle.

void loop() { if (NUMBER_BUTTONS !=0) updateButtons();} 

Utilisez votre contrôleur avec DAW (Ableton Live)

En tant que débutant dans l'utilisation des DAW, je ne savais pas comment y connecter quoi que ce soit. Lorsque j'ai connecté mon Korg Nanokey, Ableton l'a reconnu lui-même et j'ai pu utiliser le contrôleur tout de suite. Ce n'était (bien sûr) pas le cas avec le contrôleur Arduino, car ce n'est pas un périphérique HID et le PC le reconnaît toujours comme un Arduino.

Je vais vous montrer ici comment connecter et utiliser votre contrôleur MIDI Arduino dans Ableton Live 10.

• Connectez-vous à Ableton

Ouvrir boucleMIDI et créez un nouveau port MIDI virtuel comme sur les images suivantes.

Ouvrez hairless-midiserial et assignez le port série, la sortie MIDI et l'entrée MIDI comme sur les images suivantes. Pour le port série, nous choisissons le port Arduino Uno, et pour l'entrée et la sortie MIDI, nous utilisons le port MIDI virtuel que nous avons créé à l'étape précédente.

Réglez la vitesse de transmission sur la même vitesse dans votre sketch Arduino. Accédez à Fichier>Préférences , et là, vous devez définir le débit en bauds.

Si tout est bien fait, vous pouvez déboguer le message MIDI envoyé par le contrôleur. Appuyez sur le bouton du contrôleur et vérifiez les messages MIDI entrants dans Hairless MIDI.

Ne fermez pas le MIDI sans poils !

Ouvrez Ableton Live et accédez à l'onglet Options, puis Préférences. L'onglet Link MIDI devrait ressembler à cet exemple.

Pour vérifier que tout est bien connecté et qu'Ableton lit les messages MIDI, nous allons regarder dans le coin supérieur droit d'Ableton. La case supérieure doit clignoter lorsque le bouton du contrôleur est enfoncé, comme indiqué dans l'exemple suivant.

Le contrôleur est prêt à l'emploi !

• Utiliser le contrôleur comme Drum Rack ou Clavier

Sélectionnez la piste MIDI. Dans Moniteur section choisissez Dans , au lieu de Auto , et en MIDI vers choisissez votre sortie haut-parleur. Vous devriez entendre votre clavier maintenant. La même chose devrait être faite pour le rack de batterie.

Mon projet terminé

J'ai utilisé une vieille boîte de haut-parleur pour ce projet et du plastique que j'ai trouvé à la maison. J'ai découpé les deux plaques en plastique aux dimensions du boîtier et percé des trous pour les boutons et une LED que j'ajouterai plus tard.

J'ai aussi un autre vieux haut-parleur avec le même boîtier que j'utiliserai pour un autre contrôleur MIDI, cette fois avec des boutons et des joysticks.

A faire

- Appuyez longuement sur le bouton pour passer en mode CC.

Code

• MidiDrumPad.ino
• Boutons.cpp
• Boutons.h

MidiDrumPad.inoArduino

#include "Buttons.h"//------Notes-------------#define NOTE_ONE 36#define NOTE_TWO 37#define NOTE_THREE 38#define NOTE_FOUR 39#define NOTE_FIVE 40#define NOTE_SIX 41#define NOTE_SEVEN 42#define NOTE_EIGHT 43#define NOTE_NINE 44#define NOTE_ON_CMD 0x90#define NOTE_OFF_CMD 0x80#define MAX_MIDI_VELOCITY 127//----------------- ------int NUMBER_BUTTONS =9;Bouton Bouton1(4, NOTE_ONE);Bouton Bouton2(3, NOTE_TWO);Bouton Bouton3(2, NOTE_THREE);Bouton Bouton4(7, NOTE_FOUR);Bouton Bouton5(6, NOTE_FIVE);Bouton Bouton6(5, NOTE_SIX);Bouton Bouton7(10, NOTE_SEVEN);Bouton Bouton8(9, NOTE_EIGHT);Bouton Bouton9(8, NOTE_NINE);Bouton *Boutons[] {&Bouton1,&Bouton2,&Bouton3,&Bouton4,&Bouton5,&Bouton6 ,&Button7,&Button8,&Button9};int red_light_pin=11;int green_light_pin =12;int blue_light_pin =13;void setup() { Serial.begin(9600);}void loop() { if (NUMBER_BUTTONS !=0) updateButtons( );}void updateButtons() { for (int i =0; i getButtonState(); // Le bouton est enfoncé if (state ==0) { midiNoteOn(Buttons[i]->Note,127); } // Le bouton n'est pas enfoncé if (state ==1) { midiNoteOff(Buttons[i]->Note,0); } }}void RGB_color(int red_light_value, int green_light_value, int blue_light_value) { analogWrite(red_light_pin, red_light_value); analogWrite(green_light_pin, green_light_value); analogWrite(blue_light_pin, blue_light_value);}// Envoyer une note MIDI ONvoid midiNoteOn(byte note, byte midiVelocity){ Serial.write(NOTE_ON_CMD); Serial.write(note); Serial.write(midiVelocity);}//Envoyer une note MIDI OFFvoid midiNoteOff(byte note, byte midiVelocity){ Serial.write(NOTE_OFF_CMD); Serial.write(note); Serial.write(midiVelocity);}

Buttons.cppArduino

#include "Buttons.h"Button::Button(int pin, note courte){ _pin =pin; pinMode(_pin, INPUT_PULLUP); _état =1 ; _lastState =1; Note =note;}int Button::getButtonState(){ int returnValue =-1; int état =digitalRead(_pin); if(state ==_lastState) renvoie 5 ; if(state!=_lastState) { if(state ==0) { returnValue =0; } else { returnValue =1; } } _lastState =état ; return returnValue;}

Boutons.hArduino

#ifndef Buttons_h#define Buttons_h#include //Button (Pin Number, Note Number)class Button{ public:Button(int pin, short note); int getButtonState(); int Remarque; privé :int _pin ; note courte; int _état; int _lastState;};#endif

Vous pouvez télécharger le code depuis mon Github

Schémas