Un looper pour guitare électrique
Introduction
Voici comment réaliser un petit pédalier pour guitare électrique. L'idée est de connecter des pédales au Arduino, et de les utiliser pour contrôler un logiciel de traitement du son, que l'on fait nous même avec Pure Data. Ici je vous montre l'exemple d'un looper, mais on peut aussi se faire un rack d'effets sans problème.
Si vous ne savez pas ce que c'est qu'un looper, cliquez ici !
http://www.youtube.com/watch?v=C5Pd2MAwsBI
Edit 2014: le code source ré-écrit from scratch est dispo sur gitorious:
https://gitorious.org/elboulangero/looper
Tout d'abord, il y a un truc important à comprendre : notre pédalier se décompose en deux parties : la partie contrôle et la partie son. La partie contrôle se compose :
- de plusieurs pédales ( footswitch, pédales d'expression ).
- de l'Arduino pour les relier au PC.
- d'un driver : ici il s'agit d'un patch Pure Data, qui nous permet d'utiliser facilement ce que nous envoie l'Arduino.
La partie son :
- une guitare électrique.
- une carte son sur laquelle on la branche.
- le logiciel qui traite le son : ici, il s'agit donc d'un patch Pure Data.
Les pédales servent donc uniquement à contrôler un logiciel de traitement sonore.
Partie électronique
Vue d'ensemble
Comme on le voit là, mon pédalier se compose de ( de gauche à droite ) :
- une pédale d'expression : elle se connecte sur une prise RCA.
- une footswitch avec 2 interrupteurs : elle, elle se connecte sur une prise jack stereo
- enfin, 2 switches qui sortent en jack mono.
Le montage est simple : on commence par se procurer les fiches femelles qui correspondent aux pédales. Puis on les connecte sur un petit circuit qu'on se fabrique soi même. L'idée, c'est que chaque switch va être traversé par un courant 5 volts, fourni par le Arduino. Ensuite, dépendant si on appuie la pédale ou pas, le courant passe (ou pas ). Quand à la pédale d'expression, c'est juste un potard, qui va moduler le courant envoyé par le Arduino.
Chaque pédale doit donc être reliée à l'alim 5V fournie par le Arduino d'une part, et à la masse de l'autre. On place une résistance entre la pédale et la masse : il s'agit d'une résistance de tirage ( enfin je crois ). Et c'est par là qu'on connecte les pins digitales ( ou analogique pour la pédale d'expression ) du Arduino, pour connaître la tensoin et donc savoir si la pédale a été actionnée.
Gros plan sur le circuit
Un gros plan pour voir le circuit, mais qui montre pas grand chose.
Schéma électrique
Petit schéma qui montre que c'est très simple.
Partie informatique
Code embarqué sur le Arduino
Maintenant qu'on a le montage qui est fait, il faut écrire le petit bout de code qu'on va embarquer sur le Arduino pour gérer tout ça.
Ici aussi c'est très simple : le seule rôle de l'Arduino est de connaitre les valeurs sur chaque switch ( ouvert/fermé, 0/1 ) et sur le potar ( valeur entre 0 et 1 ), et de remonter ces données à l'ordi.
Ce code, on l'écrit avec le kit de développement fourni avec le Arduino. Pour la communication entre la carte et l'ordi, on utilise la lib Firmata, fournie avec le SDK.
Voilà donc le code correspondant au montage.
/*
* Firmware for my guitar pedals.
* by elboulangero
* https://playground.arduino.cc/Projets/LooperPourGuitare
*/
#include "WProgram.h"
#include <Firmata.h>
void setup();
void loop();
/* Choose the pin for the LED */
int ledPin = 13;
/* Previous digital values */
byte prev_digital_mask = B00000011;
/* Previous analog values */
int prev_analog_val[6] = { 0, 0, 0, 0, 0, 0 };
/* Global functions */
void setup() {
/* Declare LED as output */
pinMode(ledPin, OUTPUT);
/* Firmata init */
Firmata.setFirmwareVersion(FIRMATA_MAJOR_VERSION, FIRMATA_MINOR_VERSION);
Firmata.begin();
}
void loop(){
int i;
byte mask = B00000011;
/* Digital pins ( only 4 pins are connected ) */
for ( i=2; i<6; i++ ) {
mask |= digitalRead(i) << i;
}
if ( mask != prev_digital_mask ) {
prev_digital_mask = mask;
Firmata.sendDigitalPort(0, mask);
/* Toggle led, helpfull when something doesn't work */
digitalWrite(ledPin, !digitalRead(ledPin));
}
/* Analog Pins ( only one connected ) */
for ( i=0; i<1; i++ ) {
int val = analogRead( i );
if ( abs(val - prev_analog_val[i]) > 2 ) {
prev_analog_val[i] = val;
Firmata.sendAnalog(i, val);
}
}
/* Don't go too fast ( maybe this is useless ) */
delay(10);
}
Remarques sur ce code
Donc bien entendu, ce code correspond précisement au montage que j'ai réalisé. Mais il est très facile à adapter à tout montage du même style.
L'utilisation des variables ''prev_...' permet de ne remonter des données que lorsqu'une des valeurs change. Tant qu'on ne touche à aucune pédale, la carte ne fait rien. Ça évite de flooder sur le port USB et de fatiguer la carte inutilement.
Partie Pure Data
Driver Pure Data
Bien. Toute la partie avec le Arduino est faite. Il faut maintenant faire communiquer notre carte avec Pure Data. Pour ça, j'ai utilisé Pduino. C'est un objet Pure Data qui s'interface avec le Arduino. Il nécessite d'avoir utilisé la lib Firmata sur le code embarqué.
Dispo à cette adresse :
http://at.or.at/hans/pd/objects.html
Une fois qu'on arrive à faire communiquer notre Arduino avec Pure Data, on peut commencer à se programmer un petit driver. Celui ci fait juste des taches simples :
- établir la communication avec le Arduino.
- ré-étalonner ce que nous donne la pédale d'expression pour obtenir une valeur entre 0 et 1.
- s'assurer que les switches donnent bien ce qu'on attend
- envoyer les valeurs voulues grâce à des objets send, pour pouvoir les utiliser dans d'autres patches.
Le driver Pure Data pour le pédalier se trouve dans l'archive ( voir section suivante ), sous le nom arduino-driver-0-0-5.pd.
Le looper
A partir de là, on a fait toute la partie contrôle du pédalier. Reste la partie son. Je ne vais pas trop m'étendre sur cette partie, qui ne concerne plus vraiment le Arduino.
Je file juste les 2 patches Pure Data qui vont bien:
- looper-0-0-3.pd Il s'agit d'un objet qui réalise une boucle du signal en entrée. On le contrôle par des messages :
- start : démarre l'enregistrement d'une boucle.
- stop : arrête l'enregistrement de la boucle.
- toggle : commence à jouer la boucle, ou bien lui demande de s'arrêter dès qu'elle arrive au bout.
- kill : stoppe immédiatement la boucle, et reset le looper. C'est-à-dire qu'on ne plus rappeler la boucle avec toggle.
- float : on peut aussi envoyer un float. Cela sert à contraindre la taille de la boucle à un multiple de cette valeur. Si X est envoyé, la boucle que l'on fera sera contrainte à l'une des tailles suivantes : X/4, X/2, X, 2X, 4X. A quoi ca sert ?? Ça sert lorsque l'on a plusieurs loopers en parallèles, à ce que les boucles restent synchronisées.
- looper-test-3.pd Ce patch utilise le précédent. Il permet d'utiliser 4 boucles en parallèles. La pédale d'expression permet de contrôler le volume des boucles. Un des switches est dédié à changer de boucle. Les 3 autres servent à contrôler le looper.
Les 3 patches PureData sont là :
Attach::guitarlooper-pd-objects
Remarques : je suis un utilisateur très occasionnel de Pure Data ( la dernière fois que je m'en suis servi c'etait y'a bien 2 ans ), alors si y'a des gens qui connaissent bien et jettent un oeil à mes patches, ca va peut être leur faire bizarre. Je tenais juste à prévenir. Y'a des trucs bien moches, mais je savais pas comment les faire autrement.
Conclusion
Et voilà, le looper marche ! On peut le voir en action ici :
http://www.youtube.com/watch?v=C5Pd2MAwsBI
L'intérêt de la démarche est multiple :
- le prix : mon pédalier m'a couté a peu près 100 euros en comptant les frais de port.
- la flexibilité : si demain j'ai besoin d'ajouter une pédale quelconque, bein je la rajoute sur mon montage et c'est bon.
- une infinité d'applications : à partir du moment ou on maitrise Pure Data, on peut bidouiller son son de guitare comme on veut, et le contrôler comme on veut puisqu'on choisit soit même ce que font les pédales. Donc les possibilités sont énormes pour peu qu'on soit un peu passionné.