Pédalier d'orgue MIDI (Arduino)

Ce projet consiste à transformer un vieux pédalier d'orgue électronique en contrôleur MIDI.  De cette façon, on obtiendra quelque chose d'assez similaire au mythique pédalier Taurus de la compagnie Moog, sauf que notre instrument, plutôt que synthétiser ses propres sons, enverra des messages MIDI vers un autre instrument (ou vers un ordinateur exécutant un logiciel compatible MIDI).   Et tout ça ne nous coûtera vraiment pas cher (contrairement aux instruments professionnels du même genre, qui sont généralement hors de prix).


Le pédalier, avant transformation

Mon pédalier a été récupéré d'un vieil orgue Yamaha Elektone manufacturé à la fin des années 1970.  Dans ce genre d'instrument, l'organiste utilise son pied gauche pour jouer les notes de basse.  Une fois modifié, il pourra jouer n'importe quel timbre supporté par l'instrument hôte:  contrebasse, trompette, violon, banjo...

Le pédalier comporte 13 pédales formant un octave complet, de do jusqu'au do suivant.  Chaque pédale active un interrupteur:  circuit ouvert en temps normal, circuit fermé lorsque la pédale est enfoncée.

En cherchant un peu, vous pouvez probablement dénicher un orgue électronique de ce genre, en état de marche ou non, pour vraiment pas cher.  J'en ai même déjà vu un abandonné sur le trottoir, dans l'attente des éboueurs.  La principale difficulté, souvent, est de le transporter jusqu'à votre domicile (c'est beaucoup moins lourd qu'un piano, mais ça demeure assez volumineux).

Si vous n'avez pas accès à un vieux pédalier d'orgue, vous pouvez aussi en fabriquer un vous-mêmes en utilisant 13 gros interrupteur (par exemple, le genre d'interrupteurs utilisés dans les pédales d'effet pour guitare).  Ça pourrait donner quelque chose similaire à ce qui est illustré ci-contre.


Le circuit

Il s'agit d'un projet très similaire au clavier MIDI Arduino que j'avais réalisé auparavant:  l'Arduino est le cerveau de l'instrument.  Sa tâche consiste à détecter si une pédale a été enfoncée (ou relâcher), et à envoyer un message MIDI lorsqu'un tel événement a lieu.  Bien entendu, n'importe quel autre microcontrôleur pourrait faire l'affaire, mais l'Arduino est particulièrement facile d'utilisation, et il fonctionne déjà avec un niveau logique de 5 V, qui est la norme en MIDI.

Alors que mon clavier MIDI comportait 37 touches, mon pédalier n'en comporte que 13.  Plutôt que câbler mes 13 interrupteurs sous forme de matrice comme je l'avais fait pour le clavier (ce qui complique sensiblement le programme à exécuter par l'Arduino), j'ai choisi de câbler mes 13 interrupteurs de façon très classique, avec une résistance de tirage vers le haut.  Chaque pédale génère donc un signal de 5 V lorsqu'elle n'est pas enfoncée, et de 0 V lorsqu'elle est enfoncée.

Chaque pédale est reliée à sa propre résistance.  La valeur de la résistance n'a pas une très grande importance:  10 kΩ ou plus pour éviter une trop grande consommation. 

Pour ne pas accaparer 13 entrées de l'Arduino, j'ai utilisé deux registre à décalage hc165 (dont j'avais déjà exploré le fonctionnement dans cet article).  Chaque hc165 comporte 8 entrées, donc l'Arduino pourra vérifier l'état de mes 13 pédales au moyen de 3 de ses pins seulement (2, 3 et 4).

L'envoi des messages MIDI s'effectue par la pin 1 (TX) de l'Arduino.  Pour plus de détail, vous pouvez vous référer à cet article sur la transmission MIDI par l'Arduino.

J'ai aussi ajouté une paire de boutons poussoirs permettant de monter ou descendre d'un octave ou deux ("octave up", "octave down") et une paire de boutons poussoirs permettant de changer le timbre ("program up" et "program down").  J'ai utilisé un CD40106 (bascules de Schmitt) pour éviter les rebonds.

Sur mon prototype, il s'agit de petit boutons poussoirs mais pour un modèle plus professionnel, il serait logique d'utiliser des gros boutons sur lesquels on appuierait avec le pied.

De plus, le volume sonore (vélocité) est contrôlé  par un potentiomètre.

Finalement, toutes ces caractéristiques (numéro de programme, d'octave et volume sonore) s'affichent sur un LCD.

Le sketch Arduino

À chaque passage dans la boucle principale, l'Arduino vérifie l'état des pédales et, s'il y a eu un changement, il envoie un message MIDI de type "NoteOn" ou "NoteOff".




Il vérifie également si on a appuyé sur les boutons de contrôle, ou si le potentiomètre à changé de position, et il met à jour les données affichées par le LCD.

	/****************************************************************
	* MIDI Pedal Board
	*
	* Sketch pour un pédalier d'orgue (13 pédales) connecté a deux
	* 74HC165 en cascade. L'Arduino émet des messages MIDI quand
	* une pédale est enfoncée ou relachée.
	*
	* http://electroniqueamateur.blogspot.com/2015/12/pedalier-dorgue-midi-arduino.html
	*
	*****************************************************************/
	#include <LiquidCrystal.h>
	// les pins de l'Arduino branchée a l'afficheur LCD
	LiquidCrystal lcd(13, 12, 11, 10, 9, 8);
	// Ces pins de l'Arduino sont reliées aux hc165
	#define ParallelLoadPin 3
	#define ClockPin 2
	#define DataPin 4
	// ces pins de l'Arduino sont reliées aux 4 boutons-poussoir
	// (apres passage par un cd40106, pour éviter les rebonds)
	#define pinOctaveUp 5
	#define pinOctaveDown 6
	#define pinProgrammeUp 7
	#define pinProgrammeDown A1
	int octave = 0; //valeur initiale par défaut de l'octave
	int octaveDownReady = 1; //vrai quand le bouton n'est pas enfoncé
	int octaveUpReady = 1; // vrai quand le bouton n'est pas enfoncé
	int programme = 0; // numéro du programme (instrument)
	int programmeDownReady = 1; //vrai quand le bouton n'est pas enfoncé
	int programmeUpReady = 1; //vrai quand le bouton n'est pas enfoncé
	unsigned long debutProgrammeDown; // moment auquel on a appuyé sur le bouton
	unsigned long debutProgrammeUp; // moment auquel on a appuyé sur le bouton
	int velocite; // volume sonore, controlé par pententiometre
	byte valeurs1, valeurs2, valeurs1avant, valeurs2avant; // état des pédales
	void setup()
	{
	pinMode(ParallelLoadPin, OUTPUT);
	digitalWrite(ParallelLoadPin, HIGH);
	pinMode(ClockPin, OUTPUT);
	digitalWrite(ClockPin, HIGH);
	pinMode(DataPin, INPUT);
	// initialisation de l'afficheur
	lcd.begin(16, 2);
	Serial.begin(31250); //pour transmission MIDI
	valeurs1avant = B11111111; // valeurs normales si aucune pédale n'est enfoncée,
	// pour les 8 premieres pédales: do-do#-ré-ré#-mi-fa-fa#-sol
	valeurs2avant = B11111; // valeurs normales si aucune pédale n'est enfoncée,
	// pour les 5 dernieres pédales: sol#-la-la#-si-do
	ProgChange(0,programme); // par défaut, programme #0
	}
	void loop()
	{
	velocite = analogRead(A0)/8; // mesure du potentiometre de volume
	// faut-il changer de programme?
	if (digitalRead(pinProgrammeDown)) // bouton programme down enfoncé
	{
	if ((programmeDownReady) && (programme > 0))
	{
	programmeDownReady = 0;
	programme = programme - 1;
	ProgChange(0x00,programme);
	debutProgrammeDown = millis();
	}
	if (((millis()-debutProgrammeDown) > 1000) && (programme > 0)) //bouton enfoncé depuis 1 second: avance rapide
	{
	programme--;
	ProgChange(0x00,programme);
	delay(50);
	}
	}
	else // bouton programme down n'est pas enfoncé
	{
	programmeDownReady = 1;
	}
	if (digitalRead(pinProgrammeUp)) // bouton programme up enfoncé
	{
	if ((programmeUpReady) && (programme < 127))
	{
	programmeUpReady = 0;
	programme = programme + 1;
	ProgChange(0x00,programme);
	debutProgrammeUp = millis();
	}
	if (((millis()-debutProgrammeUp) > 1000) && (programme < 127))
	{
	programme++;
	ProgChange(0x00,programme);
	delay(50);
	}
	}
	else // bouton octave up n'est pas enfoncé
	{
	programmeUpReady = 1;
	}
	// faut-il changer d'octave?
	if (digitalRead(pinOctaveDown)) // bouton octave down enfoncé
	{
	if ((octaveDownReady) && (octave > -2))
	{
	octaveDownReady = 0;
	octave = octave - 1;
	}
	}
	else // bouton octave down n'est pas enfoncé
	{
	octaveDownReady = 1;
	}
	if (digitalRead(pinOctaveUp)) // bouton octave up enfoncé
	{
	if ((octaveUpReady) && (octave < 2))
	{
	octaveUpReady = 0;
	octave = octave + 1;
	}
	}
	else // bouton octave up n'est pas enfoncé
	{
	octaveUpReady = 1;
	}
	// lecture des hc165 (état des pédales)
	digitalWrite(ParallelLoadPin, LOW);
	delayMicroseconds(5);
	digitalWrite(ParallelLoadPin, HIGH);
	delayMicroseconds(5);
	valeurs1 = shiftIn(DataPin, ClockPin, MSBFIRST);
	valeurs2 = shiftIn(DataPin, ClockPin, MSBFIRST);
	digitalWrite(ClockPin, HIGH);
	// l'état des pédales a-t-il changé?
	if (valeurs1 != valeurs1avant)
	{
	for(byte i=0; i<=7; i++)
	{
	if ((valeurs1 >> i & 1) != (valeurs1avant >> i & 1))
	{
	if (valeurs1 >> i & 1){
	noteOn(0x90, 0x29+i+12*octave, 0x00); // vélocité nulle = note off
	}
	else
	{
	noteOn(0x90, 0x29+i+12*octave, velocite);
	}
	}
	}
	}
	if (valeurs2 != valeurs2avant)
	{
	for(byte i=0; i<=7; i++)
	{
	if ((valeurs2 >> i & 1) != (valeurs2avant >> i & 1))
	{
	if (valeurs2 >> i & 1){
	noteOn(0x90, 0x29+8+i+12*octave, 0x00); // vélocité nulle = note off
	}
	else
	{
	noteOn(0x90, 0x29+8+i+12*octave, velocite);
	}
	}
	}
	}
	valeurs1avant = valeurs1;
	valeurs2avant = valeurs2;
	// mise a jour du LCD
	affichage();
	}
	/* Routine qui affiche les parametres actuels sur le LCD */
	void affichage (void){
	lcd.clear();
	lcd.setCursor(0, 0);
	lcd.print("Prog:");
	lcd.print(programme);
	lcd.setCursor(8,0);
	lcd.print("Vel:");
	lcd.print(velocite);
	lcd.setCursor(0,1); //deuxieme ligne
	lcd.print("Oct:");
	lcd.print(octave);
	}
	void noteOn(int cmd, int pitch, int velocity) {
	Serial.write(cmd);
	Serial.write(pitch);
	Serial.write(velocity);
	}
	void ProgChange(int channel, int prognumber) {
	Serial.write(0xC0+channel);
	Serial.write(prognumber);
	}

view raw MIDIPedalBoard.ino hosted with ❤ by GitHub

Yves Pelletier   (Twitter, Facebook)