MIDI

Si quelqu'un pourrait nous aider. Nous avons un clavier pour un orgue et devons faire du midi pour que les touches soit enregistrées et qu'il puisse se jouer seule par la suite :)

matériel :
_arduino mega 2560
_grove mega shield (http://www.seeedstudio.com/wiki/Grove_-_Mega_Shield)
_shield midi
_shield SD
_carte SD (pour enregistrer les morceaux)
_un écran LCD (pour visualiser l’état de la musique (enregistrement en cour/lecture))
_Des boutons poussoirs (lecture/enregistrement)

Demande

Peu tu être plus précis sur ta demande ?

Il existe une très bonne bibliothèque traitant des fonctions MIDI de réception et d'émission de notes et de contrôles.
En revanche, elle ne prend pas en charge enregistrement et lecture de fichiers MIDI.
Si tu recherches des exemples de programmes, ils sont le plus souvent basés sur l'enregistrement et la lecture de notes de durée égales :roll:, ce qui se rencontre peu dans une mélodie.
Il va donc te falloir écrire toi-même cette partie du programme.
L'algorithme est assez simple :

Boucle d'enregistrement :

Lire la note jouée sur l'entrée MIDI
Compter le temps pendant lequel elle est maintenue
Quand elle est arrêtée, enregistrer la note et sa durée dans le fichier
(Considérer le silence comme une note ;)
Boucle de lecture :

Lire la note et sa durée dans le fichier
Jouer la note pendant le temps attendu sur la sortie MIDI

_ netcien :
Nous avons un clavier de 42 touches relié en midi à un arduino.
1)Toutes les touches tapées doivent être enregistrées
a) bouton start : commence l’enregistrent
b) bouton stop : fin de l'enregistrement
c) bouton lecture, nous devrons pouvoir lire les notes enregistrées au préalable sur la carte SD

Et pour nous qui débutons le C sur Arduino, nous n'avons jamais vu à quoi ressemble un code MIDI, même notre professeur ne connait pas très bien l'agencement de ce code.

_ al1_24 :
Grace à ton "code", je vois un peu mieux à quoi va ressembler le programme. Le problème c'est que nous ne savons vraiment pas par où commencer n'en ayant jamais vu :/

Je voudrais juste signaler un point important : j'ai vu que tu utilisais 1 carte Arduino et plusieurs shields. Fais bien attention, il arrive que des shields ne soient pas compatibles entre eux car ils utilisent les mêmes broches. Par ailleurs, autant de shields va nécessiter une alimentation externe, je ne suis pas sûr que l'arduino soit capable de fournir toute la puissance demandée.

Si vous utilisez le shield MIDI de Sparkfun il y a une documentation et des exemples fournis :
https://www.sparkfun.com/products/9595

Tutoriel MIDI :
http://arduino.cc/en/Tutorial/Midi
Visiblement ils prennent en compte les durées.

Merci Auteur pour ton aide, je vais regarder bien attentivement tout ceci. J'ai une alimentation externe pour l'afficheur LCD, je pense qu'elle devrait suffire pour alimenter les shields :) je te redirais quoi ;)

Est ce qu'il faudrait apporter des modifications à ce programme ? :)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
 
/****************************************************
* Arpégiateur MIDI
* Entrée: des accords joués sur un clavier MIDI
* Sortie: ces mêmes accords joués sous la forme d'arpèges
* http://electroniqueamateur.blogspot.com/2014/01/fabrication-dun-arpegiateur-midi-base.html
*****************************************************/
 
#include <MIDI.h> // nous utilisons la MIDI library 
#define nombreMaxDeNotes 42 // nombre de maximal de notes différentes dans l'arpège
// (peut être augmenté si vous avez beaucoup, beaucoup de doigts)
#define tempoPot A0 //potentiomètre qui contrôle la vitesse d'exécution
#define programPot A1 // potentiomètre qui contrôle le timbre du clavier
#define boutonOnOff 7 // bouton on/off
#define ledOnOff 9 // Led indicatrice on/off
 
int touchesActives[nombreMaxDeNotes]; // array contenant le numéro des touches enfoncées sur le clavier
int combienDeTouches = 0; // combien de touches du clavier sont enfoncées
int notesActives[nombreMaxDeNotes]; // array contenant le numéro des notes à jouer en arpège
int combienDeNotes = 0; // combien de notes à jouer dans l'arpège
int delaiEntreLesNotes; // en millisecondes
unsigned long previousNoteTime = 0; // moment où la dernière note a été jouée (en millisecondes)
unsigned long previousTouchTime = 0; // dernière fois où une touche a été pressée ou relâchée
int playIndex = 0; // numéro de la note à jouer dans l'arpège
int program; // numéro de l'instrument utilisé pour jouer les notes
int arpegiateurOn = 0; // devient 1 lorsque l'arpégiateur est en fonction
int previousArpegiateurOn = 0; // 1 si l'arpégiateur était en fonction à l'itération précédente
int derniereNoteJouee = 0; // numéro de la dernière note jouée
int mettreAJour = 0; // 1 si une mise à jour des notes est requise
 
void setup() {
MIDI.begin(MIDI_CHANNEL_OMNI);
MIDI.turnThruOff (); // pour ce sketch, on ne veut pas retourner le message au clavier
 
// initialisation de la LED indicatrice
pinMode(ledOnOff, OUTPUT);
 
// initialisation du bouton
pinMode(boutonOnOff, INPUT);
digitalWrite(boutonOnOff, HIGH); // on active la résistance pullup interne
 
}
 
void loop() {
int type, channel, number, holder, index;
 
// lecture du bouton on/off
arpegiateurOn = !digitalRead(boutonOnOff);
 
// la LED s'allume si l'arpégiateur est actif
digitalWrite(ledOnOff, arpegiateurOn);
 
if (!arpegiateurOn && previousArpegiateurOn){ // on vient tout juste d'éteindre
 
MIDI.sendNoteOn(derniereNoteJouee,0,1);
combienDeNotes = 0;
previousArpegiateurOn = 0;
}
 
 
if (arpegiateurOn) {
previousArpegiateurOn = 1;
 
if (MIDI.read()) { // réception d'un message MIDI
byte type = MIDI.getType();
switch (type) {
case NoteOn: // attention, ça peut être un noteOff si velocity est zéro
previousTouchTime = millis();
mettreAJour = 1;
number = MIDI.getData1(); // quelle touche a été enfoncée?
 
if (MIDI.getData2()){ // vélocité non-nulle: c'est un vrai noteOn
 
if (combienDeTouches <= nombreMaxDeNotes - 1){
touchesActives[combienDeTouches] = number; // mise à jour de la liste des notes actives
combienDeTouches = combienDeTouches + 1; //nombre de notes jouées
}
 
}
 
else{ // vélocité nulle: c'est un NoteOff, finalement
 
if (combienDeTouches > 0){
 
for (int i=0; i < combienDeTouches; i++){
if (touchesActives[i] == number){
touchesActives[i] = 0;
index = i; // position de la note effacée
}
}
 
// on repousse ce zéro à la fin de l'Array
for (int i=index; i < combienDeTouches-1; i++){
touchesActives[i] = touchesActives[i+1];
}
touchesActives[combienDeTouches-1] = 0;
 
combienDeTouches = combienDeTouches - 1; //nombre de notes jouées
}
 
 
}
 
 
// on fait un tri de l'array, puisqu'elle a changé
 
for(int x = 0; x <combienDeNotes; x++)
for(int y = 0; y < combienDeNotes-1; y++)
if(notesActives[y] > notesActives[y+1]) {
holder = notesActives[y+1];
notesActives[y+1] = notesActives[y];
notesActives[y] = holder;
}
 
break;
case NoteOff:
// ça n'arrive jamais avec mon clavier
channel = MIDI.getChannel();
break;
}
 
} // fin de réception du if (MIDI.read())
 
 
// une mise à jour des notes de l'arpège est-elle requise?
// (si au moins une touche est enfoncée sans modification depuis au moins 50 ms)
 
if(combienDeTouches && ((millis()-previousTouchTime)>50) && mettreAJour){
 
combienDeNotes = combienDeTouches;
 
for (int i=0; i < combienDeTouches; i++){
notesActives[i] = touchesActives[i];
}
mettreAJour = 0;
 
}
 
 
// et maintenant, on joue les arpèges:
 
if (combienDeNotes){ // il y a des notes à jouer
 
// lecture du potentiomètre de tempo
delaiEntreLesNotes = 30 + analogRead(tempoPot);
 
// lecture du potentiomètre de Programme
// on peut diviser par un nombre plus grand que 8 pour avoir moins de programmes possibles,
// mais meilleure stabilité
if (program != analogRead(programPot)/8){ // le programme doit changer
program = analogRead(programPot)/8;
MIDI.sendProgramChange(program,1); // numéro de programme, canal
}
 
if ((millis() - previousNoteTime) >= delaiEntreLesNotes){ // c'est le temps de jouer une note
previousNoteTime = millis();
 
MIDI.sendNoteOn(derniereNoteJouee,0,1); // on arrête la note précédente
MIDI.sendNoteOn(notesActives[playIndex],127,1);
derniereNoteJouee = notesActives[playIndex];
playIndex = playIndex + 1;
if (playIndex >= combienDeNotes){ // on retourne au début de la mélodie
playIndex = 0;
}
} // if ((millis() - previousNoteTime) >= delaiEntreLesNotes)
} // if combienDeNotes
} // if arpegiateur on
}