Clavier d'orgue électronique et sa matrice

Maintenant que mon Arduino est capable de converser en langage MIDI, ce serait chouette de lui annexer un clavier.  Il existe des solutions plutôt simples comme le shield MidiVox, qui permet de relier un clavier compatible MIDI à l'Arduino; mais je dispose, dans ma caverne d'Ali Baba, de deux claviers récupérés d'un orgue électronique Yamaha Electone des années 1980 et j'aimerais bien les utiliser.

Les deux claviers sont identiques (sur l'orgue, un d'entre eux servait pour la main droite, l'autre pour la main gauche); ils comportent 37 touches (3 octaves) et dans la mesure du possible, j'aimerais bien utiliser tel quel leur circuit de matrice constitué de 37 interrupteurs et 37 diodes reliés à un connecteur à 20 broches (4 des broches de ce connecteur sont inutilisées).

En observant la platine de circuit intégré et en testant mes hypothèses au moyen d'un multimètre, j'ai pu déterminer que toutes les notes séparées d'un intervalle d'un octave sont reliées entre elles par un conducteur ( par exemple, toutes les touches "ré" sont directement reliées à la première broche du connecteur, en haut à gauche).   L'autre côté de chaque interrupteur est relié à une diode, puis à une autre broche du connecteur.  Ainsi, si j'appuie sur le ré le plus grave, on peut faire circuler un courant entre la première broche à gauche et la dernière à droite.  Pour le ré qui se trouve un octave plus haut, le seul trajet conducteur se trouve entre la première broche à gauche et l'avant-dernière broche à droite, etc.

Les paires de broches qui sont reliées par un trajet conducteur permettent de déterminer quelles touches du clavier sont enfoncées.

Maintenant, il reste à voir comment relier tout ça à l'Arduino (je suppose qu'il faudra multiplexer tout ça, question de diminuer un peu le nombre de sorties nécessaires sur l'Arduino), puis concevoir un sketch qui balaiera les différentes paires de connecteur afin de déterminer quelles touches sont enfoncées.

On va bien s'amuser!

(Pour un peu plus d'info sur les matrices de clavier)

Mise à jour (8 mai 2012):  Cet article a maintenant une suite:  Décodage d'un clavier d'orgue par un Arduino

Communication MIDI OUT avec un Arduino

Cet article a été mis à jour le 13 décembre 2020 

J'ai  exploré la communication entre un Arduino et un clavier musical par l'entremise du protocole MIDI.  J'ai d'abord réalisé le circuit (très simple) proposé ici :  il est constitué de quelques fils, une résistance de 220 Ω et un jack MIDI femelle, aussi appelés DIN5 (j'allais en commander un quand je me suis souvenu de mon antique interface Mac Man qui ne fonctionne plus avec mes ordinateurs actuels:  j'ai donc récupéré ses 4 jacks MIDI).

Le code proposé sur la même page web se contente de jouer toutes les notes en ordre croissant.  En plus d'émettre des message "note on", je voulais utiliser plusieurs canaux MIDI en même temps, chacun produisant le son d'un instrument distinct.  C'est ce que j'ai réalisé avec le sketch ci-dessous.

J'ai assigné un son d'instrument aux canaux MIDI 0, 1 et 2 en me basant sur les spécifications du General MIDI .  Par convention, le canal 10 est réservé aux percussions et n'est pas affecté par les messages "program change".

On joue une note par un message "note on" en spécifiant le canal, le numéro de la note (référence ici) et sa vélocité (son volume sonore, en gros).  On interrompt la note de la même façon, en lui assignant une vélocité de zéro.  Lorsqu'on oublie d'interrompre la note, ça peut être très laid!

Cette première expérimentation pourrait ouvrir la voie à des projets plus ambitieux comme exécuter des fichiers MIDI stockés sur une carte SD, ou construire un contrôleur MIDI...

-

	/*********************************************************************************************
	MIDI OUT DEMO
	Ce sketch permet à l'Arduino de jouer une mélodie sur un clavier MIDI.
	Plus d'infos:
	http://electroniqueamateur.blogspot.com/2011/07/communication-midi-avec-un-arduino.html
	**********************************************************************************************/
	/* On définit quelques notes qu'on va utiliser: ce sera plus pratique que les valeurs hexadécimales!
	Voir http://www.wavosaur.com/download/midi-note-hex.php */
	#define NOTE_G2 0x2B
	#define NOTE_C3 0x30
	#define NOTE_C4 0x3C
	#define NOTE_D4 0x3E
	#define NOTE_E4 0x40
	#define NOTE_F4 0x41
	#define NOTE_G4 0x43
	#define NOTE_A4 0x45
	#define NOTE_B4 0x47
	#define NOTE_C5 0x48
	#define NOTE_D5 0x4A
	#define NOTE_E5 0x4C
	#define NOTE_F5 0x4D
	#define NOTE_G5 0x4F
	#define NOTE_A5 0x51
	#define NOTE_B5 0x53
	// appelé pour jouer une note
	void noteOn(int cmd, int pitch, int velocity) {
	Serial.write(cmd);
	Serial.write(pitch);
	Serial.write(velocity);
	}
	// appelé pour modifier le timbre de l'instrument
	void ProgChange(int channel, int prognumber) {
	Serial.write(0xC0 + channel);
	Serial.write(prognumber);
	}
	void setup() {
	Serial.begin(31250); // réglage du baud rate à la norme MIDI
	}
	void loop() {
	// préparation des instruments:
	ProgChange(0, 34); // Bass guitar sur le canal 0
	ProgChange(1, 16); // orgue sur le canal 1
	ProgChange(2, 80); // synthé sur le canal 2
	// le canal 9 joue toujours des percussions
	// on joue une courte mélodie:
	noteOn(0x99, 42, 0x45); // Closed Hi-Hat
	noteOn(0x99, 36, 0x45); // Bass Drum
	noteOn(0x90, NOTE_C3, 0x45); // Basse
	noteOn(0x92, NOTE_E5, 0x50); // Synthé
	delay(200);
	noteOn(0x99, 42, 0x00); // Closed Hi-Hat fin
	noteOn(0x99, 36, 0x00); // Bass Drum fin
	noteOn(0x92, NOTE_E5, 0x00); // Synthé fin
	noteOn(0x99, 42, 0x45); // Closed Hi-Hat
	noteOn(0x92, NOTE_D5, 0x50); // Synthé
	delay(200);
	noteOn(0x99, 42, 0x00); // Closed Hi-Hat fin
	noteOn(0x90, NOTE_C3, 0x00); // Basse fin
	noteOn(0x92, NOTE_D5, 0x00); // Synthé fin
	noteOn(0x99, 42, 0x45); // Closed Hi-Hat
	noteOn(0x99, 38, 0x45); // Bass Drum
	noteOn(0x91, NOTE_C4, 0x65); // orgue
	noteOn(0x91, NOTE_E4, 0x65); // orgue
	noteOn(0x91, NOTE_G4, 0x65); // orgue
	delay(200);
	noteOn(0x99, 42, 0x00); // Closed Hi-Hat fin
	noteOn(0x99, 38, 0x00); // Bass Drum fin
	noteOn(0x99, 42, 0x45); // Closed Hi-Hat
	delay(200);
	noteOn(0x99, 42, 0x00); // Closed Hi-Hat fin
	noteOn(0x91, NOTE_C4, 0x00); // orgue fin
	noteOn(0x91, NOTE_E4, 0x00); // orgue fin
	noteOn(0x91, NOTE_G4, 0x00); // orgue fin
	noteOn(0x99, 42, 0x45); // Closed Hi-Hat
	noteOn(0x99, 36, 0x45); // Bass Drum
	noteOn(0x90, NOTE_G2, 0x45); // Basse
	noteOn(0x92, NOTE_G5, 0x50); // Synthé
	delay(200);
	noteOn(0x99, 42, 0x00); // Closed Hi-Hat fin
	noteOn(0x99, 36, 0x00); // Bass Drum fin
	noteOn(0x92, NOTE_G5, 0x00); // Synthé fin
	noteOn(0x99, 42, 0x45); // Closed Hi-Hat
	noteOn(0x92, NOTE_E5, 0x50); // Synthé
	delay(200);
	noteOn(0x99, 42, 0x00); // Closed Hi-Hat fin
	noteOn(0x90, NOTE_G2, 0x00); // Basse fin
	noteOn(0x92, NOTE_E5, 0x00); // Synthé fin
	noteOn(0x99, 42, 0x45); // Closed Hi-Hat
	noteOn(0x99, 38, 0x45); // Bass drum
	noteOn(0x91, NOTE_C4, 0x65); // orgue
	noteOn(0x91, NOTE_E4, 0x65); // orgue
	noteOn(0x91, NOTE_G4, 0x65); // orgue
	delay(200);
	noteOn(0x99, 42, 0x00); // Closed Hi-Hat fin
	noteOn(0x99, 38, 0x00); // Bass drum fin
	noteOn(0x99, 42, 0x45); // Closed Hi-Hat
	delay(200);
	noteOn(0x99, 42, 0x00); // Closed Hi-Hat fin
	noteOn(0x91, NOTE_C4, 0x00); // orgue fin
	noteOn(0x91, NOTE_E4, 0x00); // orgue fin
	noteOn(0x91, NOTE_G4, 0x00); // orgue fin
	}

view raw MIDI_OUT_demo.ino hosted with ❤ by GitHub

-

À lire également

Beaucoup d'autres projets MIDI avec l'Arduino:

• Fabrication d'un module MIDI (in et out) pour Arduino
• S'entraîner à lire les notes sur une portée avec Arduino
• Jouer des fichiers MIDI avec Arduino
• Séquenceur MIDI à base d'Arduino
• Arpégiateur MIDI à base d'Arduino
• Identificateur d'accords MIDI
• Clavier MIDI à base d'Arduino
• Pédalier d'orgue MIDI à base d'Arduino
• Flûte à bec MIDI à base d'Arduino
• MIDI par usb avec Arduino Leonardo
• MIDI sans fil avec Arduino

Yves Pelletier (Twitter:  @ElectroAmateur)

Diagramme en bâton sur un afficheur à cristaux liquides

Comme petit exercice d'appropriation de l'Arduino et des afficheurs à cristaux liquide (ACL ou LCD en anglais), j'ai décidé de réaliser ce montage dans lequel la longueur d'une barre horizontale varie selon la valeur d'un voltage appliqué sur une des entrées analogiques.

Je m'attendais à quelque chose de moyennement compliqué, comme par exemple être obligé de créer mes propres polices de caractères en forme de rectangle, mais c'est finalement assez simple:  il s'agit d'afficher des rectangles noirs ou blancs aux endroits appropriés.

Dans le schéma de circuit illustré ci-dessus, R1 est un potentiomètre de 5 kΩ qui permet de faire varier la tension à l'entrée analogique numéro 2 de l'Arduino et, par conséquent, de faire varier la longueur de la barre indicatrice sur l'afficheur.  Bien entendu, dans un projet utile, ce voltage pourrait provenir d'un capteur afin d'afficher une valeur mesurée.  La barre horizontale pourrait également indiquer la valeur d'un paramètre modifiable par l'utilisateur, comme par exemple le volume sonore.

Pour plus de détails sur le reste du circuit, consultez cet article plus complet .   R2 est un potentiomètre de 10 kΩ qui ne sert qu'à modifier le contraste de l'afficheur (vous pouvez le remplacer par une résistance fixe lorsque vous connaissez la valeur qui permet un affichage net).


-

	/******************************************************************************************
	Valeur analogique mesurée sur l'entrée A2 affichée sur un LCD sous la forme d'un bargraphe.
	http://electroniqueamateur.blogspot.ca/2011/07/diagramme-en-baton-sur-un-afficheur.html
	*******************************************************************************************/
	#include <LiquidCrystal.h> // LiquidCrystal Library
	int analogPin = 2; // Voltage mesuré sur la broche 2
	float d = 0;
	float oldit = 0;
	LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //afficher à cristaux liquides
	// branché sur les broches
	// 12, 11, 5, 4, 3 et 2
	void setup() {
	lcd.begin(16, 2);
	lcd.setCursor(0, 0); // curseur dans le coin supérieur droit
	lcd.println("Tension "); // on écrit le mot "Tension"
	}
	void loop() {
	float num = analogRead(analogPin); // on récupère le voltage sur la broche 2
	float it = map(num, 0, 1023, 0, 16); // on sépare la valeur en 16 morceux
	lcd.setCursor(8, 0);
	lcd.print(num/1024*5); // on écrit la valeur numérique du voltage
	if (it > oldit) { // on vérifie si le nombre a augmenté
	for (d = 0; it >= d; d++) {
	lcd.setCursor(d, 1); // curseur dans la deuxième ligne
	lcd.write(1023); // écriture d'un rectangle noir
	}
	}
	if (it <= oldit) { // si le nombre a diminué
	for (d = 15; it <= d; d--) { //compte à rebours
	lcd.setCursor(d, 1); // curseur dans la deuxième ligne
	lcd.write(1022); // écriture d'un rectangle blanc
	}
	}
	oldit = it;
	}

view raw LCD_bargraph.ino hosted with ❤ by GitHub

-

À lire également:

Le guide complet pour utiliser un afficheur LCD 16 X 2 avec une carte Arduino.

Yves Pelletier   (Twitter, Facebook)