La Grouve staïcheune est une installation sonore ludique composée de différents éléments mis à disposition d'un public lors d'évènements culturels et/ou festifs. Les différents dispositifs permettent une manipulation intuitive du son, seul ou à plusieurs. Le but de l’installation est de proposer à des publics de tout âge, avertis ou non, de s'amuser, de créer et même d'aprendre. Elle est à but ludique et festive mais peut être également une introduction à la mise en oeuvre technique des différents dispositifs.
Les éléments de la Grouve Staïcheune sont des controlleurs MIDI pensés et conçus pour remplir une fonction particulière, ils controllent donc un ordinateur qui est le cerveau invisible de l'installation. Tout les dispositifs ont été pensés et fabriqués dans une optique de diffusion open source. Ci dessous vous pouvez trouver les différents plans, codes et procédés techniques avec lesquels l'installation fonctionne.
La Grouve Box est un sampler/boite à Rythmes 6 pistes avec un potard de contrôle par pistes et deux effets master. Elle dispose aussi de deux mixers trois voies. Elle reprend le fonctionnement des synthetiseurs modulaires, on peut "patcher" le signal audio en lui faisant prendre la route que l'on souhaite. Par rapport à un controlleur MIDI classique, le signal audio passe dans dans la Grouve Boxe, il y a donc deux circuits distincts : 1 analogique, qui transporte l'audio ; et un numérique, qui communique avec l'ordinateur via un Arduino afin d'envoyer les données MIDI souhaitées.
Dans le rectangle Rouge on trouve le bouton qui lance et stop le sample, un potentiomètre controllant un effet de ce sample et la sortie Audio permettant de router le son du sample ou l'on souhaite.
Il y a donc 6 circuits identiques pour chaque bouton.
En Vert, c'est le mixer passif ; il ya deux mixers ayant trois canaux chacun sur la Grouve Box. Les entrées sont situées au dessus et la somme des signaux resortr dans l'unique sortie dans la partie inferieur du cadre vert.
Les trois potentiomètres controlent respectivement le volume des signaux audio que l'on met dans chaque entrée du mixer.
En noir c'est la section d'effet, la connectique supérieur est l'entré audio et la connectique inférieure la sortie. le potentiomètre quand à lui envoie une commande voulue à cet effet.
Il y a deux sections d'effets sur la Grouve Box.
En bleu, c'est l'entrée audio vers la carte son, si rien n'est envoyé dans cess deux entrées, aucuns sons ne sera émis.
On decide du chemin du son en routant le signal à l'aide de cables jack. On peut ainsi decider si un son passe par un effet ou non, grouper des sons pour les envoyer dans le meme effet, faire des groupes ...
14 x potentiomètres linéaires 10k Ω
6 x boutons type "arcade" avec LED (5V)
20 x Connecteurs jack femelle encastrables 6.3mm Mono
1 x carte Arduino Mega (ou Elegoo mega)
1 x embase femelle MIDI DIN
2 x borniers electriques (possibilité de les "faire" soi-même)
6 x resistances de 10k Ω
6 x resistances de 220 Ω
12 x longueurs de cables audio, taille à définir pour aller jusqu'à la carte son.
12 x connectique jack 6.3mm mono (TS)
Fer à Souder
Etain
Gaine thermoformable
Fils de cuivre
En photo ci-dessus, l'exemple de montage du bouton 1. On a utilisé ici un bouton typer arcade avec une LED intégré.
Il faut bien faire attention de brancher le bouton sur une entrée PMW de la carte. Sur l'arduino mega les entrée 1 à 12 dispose du PWM, mais sur un arduino classique ces entré sont symbolisé par ( ~ ).
La connection de la led sur la carte se fait elle par une entrée digitale. Les valeurs de resistances sont indiquées sur le shéma.
Les rectangles verts et bleus sur le shémas représentent respectivement les borniers GND et +5V. On branchera toutes nos masses et toutes nos alimentations sur ces borniers.
Les potentiomètres connectent également leurs masses et leurs +5V sur les borniers. Il faut choisir une entrée Analogique sur la carte pour pouvoir lire la valeur du potentiomètre. Que ce soit pour les potentiomètres de controle de samples ou les potentiomètres de la section effet, le principe reste le même, on change evidement d'entré sur la carte arduino pour chaque potentiomètre. Tout les potentiomètres présents sur la Grouve Box ont une valeurs de 10K Ω.
Le Mixer est un circuit passif indépendant de l'arduino. Passif signifie qu'il n'est pas alimenté electriquement. Les masses sont uniquement connectées aux embases jack femelles du mixer. Les deux mixer de la Grouve Box sont indépendant l'un de l'autre.
Sur les 5 broches de la connectique MIDI, on utilise seulement la 4, la 2 et la 5. J'ai personellement choisis de ne pas brancher la masse de la connectique midi à mon bornier, mais plutôt à une autre de l'arduino car j'ai constaté une meilleure communication MIDI comme cela. La connection MIDI se connecte à l'arduino via la broche TX->1.
Les entrées et les sorties audio de la Grouve Box sont composées d'un cable audio TS connectés à l'embases jack femelles 6.3mm mono encastré dans la grouve box d'un coté, et de l'autre à une fiche jack 6.3mm TS, qui rentre ou sort de la carte son que l'on utilise.
Sur le schéma présenté en photo ci-dessus, un seul coté de la Grouve Box est présenté, mais il est similaire à l'autre.
Les pastilles Oranges sont des sorties audios : elles sortent de la carte son pour amener de l'audio dans la Grouve Box.
Les pastilles Roses sont des entrées audio vers la carte son, on peut y renvoyer de l'audio pour y appliquer un traitement ou un effet.
La pastille Rouge et la sortie audio MASTER de la Grouve Box, comme les pastilles roses on y envoit de l'audio vers la carte son.
Les pastilles Vertes et jaunes sont respectivement les entrées et la sortie du mixer, l'audio qu'on y met ne repasse pas par la carte son (voir la section MIXER).
Le code s'implémente via l'IDE Arduino disponible en téléchargement gratuit ici (Meme si vous utilisez une carte Elegoo).
Quand on connecte l'arduino à l'ordinateur via USB, il faut bien faire attention de selectionner le bon port et le bon modèle de carte que l'on utilise au risque de ne pas pouvoir téléverser le code sur la carte.
( Outil/Port - Outil/type de carte )
Le code ci dessous est celui que j'ai écris et implémenté dans la Grouve Boxe, il est commenté afin de mieux comprendre les fonctions de chaque lignes. Vous pouvez le copier/coller directement dans votre IDE arduino et le modifier selon vos branchements physiques sur la carte.
#include
MIDI_CREATE_DEFAULT_INSTANCE();
//BOUTON
const int button1 = 11;
const int button2 = 10;
const int button3 = 9;
const int button4 = 6;
const int button5 = 5;
const int button6 = 3;
bool buttonState1 = LOW;
bool buttonPressed1 = HIGH;
bool buttonState2 = LOW;
bool buttonPressed2 = HIGH;
bool buttonState3 = LOW;
bool buttonPressed3 = HIGH;
bool buttonState4 = LOW;
bool buttonPressed4 = HIGH;
bool buttonState5 = LOW;
bool buttonPressed5 = HIGH;
bool buttonState6 = LOW;
bool buttonPressed6 = HIGH;
//LED
const int ledPin1 = 24; // la broche de la LED que vous voulez utiliser
const int ledPin2 = 30;
const int ledPin3 = 34;
const int ledPin4 = 38;
const int ledPin5 = 42;
const int ledPin6 = 46;
bool ledState1 = LOW; // état initial de la LED
bool ledState2 = LOW;
bool ledState3 = LOW;
bool ledState4 = LOW;
bool ledState5 = LOW;
bool ledState6 = LOW;
//Potards de pitch Bend
const int potPin1 = A0;
const int potPin2 = A1;
const int potPin3 = A2;
const int potPin4 = A3;
const int potPin5 = A4;
const int potPin6 = A5;
int potValue1 = 0;
int potValue2 = 0;
int potValue3 = 0;
int potValue4 = 0;
int potValue5 = 0;
int potValue6 = 0;
int previousPotValue1 = 0;
int previousPotValue2 = 0;
int previousPotValue3 = 0;
int previousPotValue4 = 0;
int previousPotValue5 = 0;
int previousPotValue6 = 0;
int pitchBendValue1 = 0;
int pitchBendValue2 = 0;
int pitchBendValue3 = 0;
int pitchBendValue4 = 0;
int pitchBendValue5 = 0;
int pitchBendValue6 = 0;
//Potards de Reverb/delay
const int potPin7 = A7;
const int potPin8 = A6;
int potValue7 = 0;
int potValue8 = 0;
int previousPotValue7 = 0;
int previousPotValue8 = 0;
const int threshold3 = 2;
const int threshold2 = 10;
const int threshold = 10;
void setup() {
MIDI.begin(MIDI_CHANNEL_OMNI);
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
pinMode(ledPin3, OUTPUT);
pinMode(ledPin4, OUTPUT);
pinMode(ledPin5, OUTPUT);
pinMode(ledPin6, OUTPUT);
}
void loop() {
//BUTTON 1 - LED 1
if (digitalRead(11) == LOW) {
delay(10);
if (digitalRead(11) == LOW) {
buttonPressed1 = true;
}
} else {
if (buttonPressed1) {
static bool message2 = true;
if (message2) {
MIDI.sendNoteOn(50, 127, 1); //valeur MIDI envoyé si bouton HIGH - Note 50 - canal 1
digitalWrite(ledPin1, HIGH); // Allumer la LED
} else {
MIDI.sendNoteOn(51, 127, 1); //valeur MIDI envoyé si bouton LOW - Note 51 - canal 1
digitalWrite(ledPin1, LOW); // Éteindre la LED
}
message2 = !message2; // basculer entre les deux messages
buttonPressed1 = false;
}
}
//BUTTON 2 - LED 2
if (digitalRead(10) == LOW) {
delay(10);
if (digitalRead(10) == LOW) {
buttonPressed2 = true;
}
} else {
if (buttonPressed2) {
static bool message2 = true;
if (message2) {
MIDI.sendNoteOn(52, 127, 1);
digitalWrite(ledPin2, HIGH);
} else {
MIDI.sendNoteOn(53, 127, 1);
digitalWrite(ledPin2, LOW);
}
message2 = !message2;
buttonPressed2 = false;
}
}
//BUTTON 3 - LED 3
if (digitalRead(9) == LOW) {
delay(10);
if (digitalRead(9) == LOW) {
buttonPressed3 = true;
}
} else {
if (buttonPressed3) {
static bool message2 = true;
if (message2) {
MIDI.sendNoteOn(54, 127, 1);
digitalWrite(ledPin3, HIGH);
} else {
MIDI.sendNoteOn(55, 127, 1);
digitalWrite(ledPin3, LOW);
}
message2 = !message2;
buttonPressed3 = false;
}
}
//BUTTON 4 - LED 4
if (digitalRead(6) == LOW) {
delay(10);
if (digitalRead(6) == LOW) {
buttonPressed4 = true;
}
} else {
if (buttonPressed4) {
static bool message2 = true;
if (message2) {
MIDI.sendNoteOn(56, 127, 1);
digitalWrite(ledPin4, HIGH);
} else {
MIDI.sendNoteOn(57, 127, 1);
digitalWrite(ledPin4, LOW);
}
message2 = !message2;
buttonPressed4 = false;
}
}
//BUTTON 5 - LED 5
if (digitalRead(5) == LOW) {
delay(10);
if (digitalRead(5) == LOW) {
buttonPressed5 = true;
}
} else {
if (buttonPressed5) {
static bool message2 = true;
if (message2) {
MIDI.sendNoteOn(58, 127, 1);
digitalWrite(ledPin5, HIGH);
} else {
MIDI.sendNoteOn(59, 127, 1);
digitalWrite(ledPin5, LOW);
}
message2 = !message2;
buttonPressed5 = false;
}
}
//BUTTON 6 - LED 6
if (digitalRead(3) == LOW) {
delay(10);
if (digitalRead(3) == LOW) {
buttonPressed6 = true;
}
} else {
if (buttonPressed6) {
static bool message2 = true;
if (message2) {
MIDI.sendNoteOn(60, 127, 1);
digitalWrite(ledPin6, HIGH);
} else {
MIDI.sendNoteOn(61, 127, 1);
digitalWrite(ledPin6, LOW);
}
message2 = !message2;
buttonPressed6 = false;
}
}
// PITCHBEND1 1
potValue1 = analogRead(potPin1);
if (abs(potValue1 - previousPotValue1) >= threshold) { // Si différence entre valeur précédente et valeur actuelle < Threshold : = potard immobile.
pitchBendValue1 = map(potValue1, 0, 1023, -8192, 8191); // mapping des données du potard sur l'echelle de pitch bend
MIDI.sendPitchBend(pitchBendValue1 + 0, 2); // Envoi de la valeur de pitch bend sur le canal 2
previousPotValue1 = potValue1;
}
// PITCHBEND 2
potValue2 = analogRead(potPin2);
if (abs(potValue2 - previousPotValue2) >= threshold) {
pitchBendValue2 = map(potValue2, 0, 1023, -8192, 8191);
MIDI.sendPitchBend(pitchBendValue2 + 0, 3);
previousPotValue2 = potValue2;
}
// PITCHBEND 3
potValue3 = analogRead(potPin3);
if (abs(potValue3 - previousPotValue3) >= threshold) {
pitchBendValue3 = map(potValue3, 0, 1023, -8192, 8191);
MIDI.sendPitchBend(pitchBendValue3 + 0, 4);
previousPotValue3 = potValue3;
}
// PITCHBEND 4
potValue4 = analogRead(potPin4);
if (abs(potValue4 - previousPotValue4) >= threshold) {
pitchBendValue4 = map(potValue4, 0, 1023, -8192, 8191);
MIDI.sendPitchBend(pitchBendValue4 + 0, 5);
previousPotValue4 = potValue4;
}
// PITCHBEND 5
potValue5 = analogRead(potPin5);
if (abs(potValue5 - previousPotValue5) >= threshold) {
pitchBendValue5 = map(potValue5, 0, 1023, -8192, 8191);
MIDI.sendPitchBend(pitchBendValue5 + 0, 6);
previousPotValue5 = potValue5;
}
// PITCHBEND 6
potValue6 = analogRead(potPin6);
if (abs(potValue6 - previousPotValue6) >= threshold) {
pitchBendValue6 = map(potValue6, 0, 1023, -8192, 8191);
MIDI.sendPitchBend(pitchBendValue6 + 0, 7);
previousPotValue6 = potValue6;
}
//Potards de Reverb/delay
//REVERB
int potValue7 = analogRead(potPin7);
// Vérifie si la valeur du potentiomètre a changé de manière significative
if (abs(potValue7 - previousPotValue7) >= threshold) {
// Mappe la valeur du potentiomètre à la plage de valeurs MIDI CC
int ccValue = map(potValue7, 0, 1023, 0, 127);
// Envoie le message MIDI CC avec la valeur du potentiomètre
MIDI.sendControlChange(1, ccValue, 8);
// Met à jour la valeur précédente du potentiomètre
previousPotValue7 = potValue7;
}
//DELAY
int potValue8 = analogRead(potPin8);
// Vérifie si la valeur du potentiomètre a changé de manière significative
if (abs(potValue8 - previousPotValue8) >= threshold) {
// Mappe la valeur du potentiomètre à la plage de valeurs MIDI CC
int ccValue = map(potValue8, 0, 1023, 0, 127);
// Envoie le message MIDI CC avec la valeur du potentiomètre
MIDI.sendControlChange(1, ccValue, 9);
// Met à jour la valeur précédente du potentiomètre
previousPotValue8 = potValue8;
}
}
Contrairement à la Grouve Boxe qui est basée sur des rythmes plus percussifs, le Drone Générator permet lui de lancer et de moduler des nappes sonores. Il est divisé en deux canaux qui comprennent chacun un bouton d'activation et deux potentiomètres de modulation. Un troisième canal composée d'un bouton et d'un potentiomètre permet de controller le BPM général et un effet master type beat repeat. Dans le drone générator il n'y a pas d'audio qui circule, c'est un controlleur MIDI "classique". Pour le dispositif Grouve Staïcheune, mais on peut completement changer les assignations de ce contrôlleur pour en faire autre chose.
5 x potentiomètres linéaires 10k Ω
3 x boutons type "arcade" avec LED (5V)
1 x carte Arduino Uno (ou Elegoo)
1 x embase femelle MIDI DIN
3 x resistances de 220 Ω
3 x resistances de 10K Ω
Fer à Souder
Etain
Gaine thermoformable
Fils de cuivre
Même procédé que pour la Grouve Boxe, avec l'IDE arduino on selectionne son port et son type de carte. A noter qu'il faut bien utiliser des ports MIDI différents de ceux utilisés sur la Grouve Boxe car sinon il pourrait y avoir des confusions entre les signaux à leurs arrivé dans le DAW.
Le code que j'ai utilisé est le suivant :
#include // bibliotheque midi à integrer
MIDI_CREATE_DEFAULT_INSTANCE();
//BOUTTON
const int button1 = 9; //la broche du boutton que vous voulez utiliser
const int button2 = 10;
const int button3 = 11;
bool buttonState1 = LOW; //definis les deux états possible de chaque bouttons
bool buttonPressed1 = HIGH;
bool buttonState2 = LOW;
bool buttonPressed2 = HIGH;
bool buttonState3 = LOW;
bool buttonPressed3 = HIGH;
//LED
const int ledPin1 = 7; // la broche de la LED que vous voulez utiliser
const int ledPin2 = 8;
const int ledPin3 = 12;
bool ledState1 = LOW; // état initial de la LED
bool ledState2 = LOW;
bool ledState3 = LOW;
//POTARD
const int potPin1 = A5; // la broche des potards que vous voulez utiliser
const int potPin2 = A4;
const int potPin3 = A3;
const int potPin4 = A0; //la broche des potards d'effets que vous voulez utiliser
const int potPin5 = A1;
int potValue1 = 0; //constante initiales des potentiomètres
int potValue2 = 0;
int potValue3 = 0;
int potValue4 = 0; //constante initiales des potentiomètres d'effets
int potValue5 = 0;
int previousPotValue1 = 0; //constante initiales des potentiomètres
int previousPotValue2 = 0;
int previousPotValue3 = 0;
int previousPotValue4 = 0; //constante initiales des potentiomètres d'effets
int previousPotValue5 = 0;
int controlValue1 = 0; //valeurs de controle des potentiometres
int controlValue2 = 0;
int controlValue3 = 0;
const int threshold = 10; //temps en milliseconde entre chaque action
void setup() {
MIDI.begin(MIDI_CHANNEL_OMNI); //ouverture des canaux MIDI
pinMode(ledPin1, OUTPUT); //activation des leds
pinMode(ledPin2, OUTPUT);
pinMode(ledPin3, OUTPUT);
}
void loop() {
//BUTTON 1 - LED 1
if (digitalRead(button1) == LOW) {
delay(10);
if (digitalRead(button1) == LOW) {
buttonPressed1 = true;
}
} else {
if (buttonPressed1) {
static bool message2 = true;
if (message2) {
MIDI.sendNoteOn(50, 127, 10); //valeur MIDI envoyé si bouton HIGH - Note 50 - canal 10
digitalWrite(ledPin1, HIGH); // Allumer la LED
} else {
MIDI.sendNoteOn(51, 127, 10); //valeur MIDI envoyé si bouton LOW - Note 51 - canal 10
digitalWrite(ledPin1, LOW); // Éteindre la LED
}
message2 = !message2; // basculer entre les deux messages
buttonPressed1 = false;
}
}
//BUTTON 2 - LED 2 //le bouton deux envoie la même valeur Midi à chaque pression.
if (digitalRead(button2) == LOW) {
delay(10);
if (digitalRead(button2) == LOW) {
buttonPressed2 = true;
}
} else {
if (buttonPressed2) {
static bool message2 = true;
if (message2) {
MIDI.sendNoteOn(52, 127, 10);
digitalWrite(ledPin2, HIGH);
} else {
MIDI.sendNoteOn(52, 127, 10);
digitalWrite(ledPin2, LOW);
}
message2 = !message2;
buttonPressed2 = false;
}
}
//BUTTON 3 - LED 3
if (digitalRead(button3) == LOW) {
delay(10);
if (digitalRead(button3) == LOW) {
buttonPressed3 = true;
}
} else {
if (buttonPressed3) {
static bool message2 = true;
if (message2) {
MIDI.sendNoteOn(54, 127, 10);
digitalWrite(ledPin3, HIGH);
} else {
MIDI.sendNoteOn(55, 127, 10);
digitalWrite(ledPin3, LOW);
}
message2 = !message2;
buttonPressed3 = false;
}
}
// POTARDs
potValue1 = analogRead(potPin1);
if (abs(potValue1 - previousPotValue1) >= threshold) { // Si différence entre valeur précédente et valeur actuelle < Threshold : = potard immobile.
controlValue1 = map(potValue1, 0, 1023, 0, 127); // scale la valeur du potentiometre (initialement de 0 à 1023) de 0 à 127 (midi)
MIDI.sendControlChange(1, controlValue1, 11); //envoie la valeur de controle sur le CC 1 du canal midi 11
previousPotValue1 = potValue1;
}
potValue2 = analogRead(potPin2);
if (abs(potValue2 - previousPotValue2) >= threshold) {
controlValue2 = map(potValue2, 0, 1023, 0, 127);
MIDI.sendControlChange(2, controlValue2, 11);
previousPotValue2 = potValue2;
}
potValue3 = analogRead(potPin3);
if (abs(potValue3 - previousPotValue3) >= threshold) {
controlValue3 = map(potValue3, 0, 1023, 0, 127);
MIDI.sendControlChange(3, controlValue3, 11);
previousPotValue3 = potValue3;
}
int potValue4 = analogRead(potPin4); //Le code pour les potard 4 et 5 est un peu différent mais fonctionne de la meme manière.
if (abs(potValue4 - previousPotValue4) >= threshold) { // j'ai opté pour ce choix afin de decider dans le temps quel code se comporte le mieux
int ccValue = map(potValue4, 0, 1023, 0, 127);
MIDI.sendControlChange(3, ccValue, 12);
previousPotValue4 = potValue4;
}
int potValue5 = analogRead(potPin5);
if (abs(potValue5 - previousPotValue5) >= threshold) {
int ccValue = map(potValue5, 0, 1023, 0, 127);
MIDI.sendControlChange(4, ccValue, 12);
previousPotValue5 = potValue5;
}
}
Le MikroFone est un simple micro à electret, ici un Primo EM264Y Cardioid (DataSheet) monté dans un ancien micro de mégaphone. Un bouton sur le coté permet de l'activer. Les microphones à electrets necessitent une alimentation entre 3 et 5 volts, ce qui est problématique si l'on veut le brancher sur une carte son ne delivrant que du 48v. Selon les electrets différents montages existent pour convertir le 48v en 5V, ici j'ai suivis le montage en photo qui est à la base pour un autre modèle d'electret mais le tout fonctionne bien. Dans la datasheet du primo, un shéma nous indique quel valeur de resistance utiliser. Le montage vient se glissser à l'interieur même de la connectique XLR qui se branche sur la carte son. (Les connectiques Neutrik ont assez d'espace pour pouvoir le faire).
Protokol est un logiciel open source gratuit permettant de verifier les flux MIDI et OSC entrant sur une machine. Il est très utile pour verifier si les montages sont bien fait et si les canaux MIDI sont bien assignés. On peut vite isoler les problèmes, et voir ou le montage et/ou le code pêche. il n'y a rien a configurer, juste à l'ouvrir et à regarder si les données entrent de la bonne manière sur l'ordinateur. Attention certains dispositifs MIDI ne fonctionnent pas lorsque deux logiciels différents tentent de lire les informations qu'ils envoient ! Il faut alors soit utiliser Protokol pour contrôller, soit utiliser directement le logiciel sur lequel on veut envoyer des informations MIDI. Protokol est en libre téléchargement ici