Faire un clavier MIDI à partir d'un vieux synthétiseur pour enfants

image

Un jour, en rentrant chez moi, près de la chute à ordures à l'entrée, j'ai vu un vieux synthétiseur de jouets pour enfants. Passé, car il était «coupable» de le retirer de la poubelle, mais dans mon cœur, je voulais le sortir de là. Déjà tard dans la nuit, vers 14 heures, j'ai décidé de voir si elle était toujours là. Et oui, elle était toujours là! En apparence, elle était complètement entière et propre, donc il n'y avait pas de délicatesse pour ne pas la prendre. Alors oui, je l'ai prise.

Je veux depuis longtemps un piano pour moi, je ne suis pas un musicien professionnel, mais juste pour me faire plaisir - pourquoi pas? Acheter quelque chose "pour se faire dorloter" J'ai été "étranglé par un crapaud", et ici - un jouet gratuit. Quand je l'ai pris dans la poubelle, je ne pensais même pas à l'utiliser comme un jouet pour enfant, j'ai tout de suite pensé: "Ohhhh ..., une bonne base pour essayer de faire un clavier MIDI."
Comme j'ai déjà une certaine expérience de la communication avec les claviers professionnels et les claviers MIDI, j'ai immédiatement compris tous les inconvénients de mon idée. Autrement dit, un jouet restera en fait un jouet. Sur cette base, il sera impossible de réaliser la puissance des frappes. Les clés en plastique «légères» elles-mêmes, qui sont également incomplètes, ne permettront pas d'y réaliser quelque chose de digne.

Tout d'abord, le synthétiseur jouet a été démonté "à la vis", tout le plastique a été bien lavé au savon. Les tableaux et les groupes de contacts des clés sont également nettoyés.

Après le démontage, on a compris pourquoi les gens l'avaient jeté. Un jouet (je ne sais pas pourquoi: de temps en temps, de la qualité chinoise des composants ou d'un fonctionnement difficile) d'une part: les haut-parleurs intégrés se sont désagrégés, et d'autre part: un connecteur cassé d'eux coincé dans la prise casque, donc il n'y avait pratiquement aucun moyen de le retirer . Probablement, après que le jouet a cessé de jouer avec les haut-parleurs intégrés, ils l'ont utilisé avec des écouteurs, puis après avoir cassé le connecteur, ils l'ont simplement jeté.

À l'intérieur, le synthétiseur jouet se composait de trois cartes qui étaient interconnectées par une boucle de câble. La carte centrale, qui était responsable de la génération du son et d'autres choses, a été immédiatement dessoudée des deux autres cartes et mise de côté. Sur les deux autres planches, il y avait des contacts pour les boutons sur le panneau avant du jouet et les touches du piano elles-mêmes. Je leur ai soudé les connecteurs PBS, d'autant plus que le pas des trous sur les cartes n'était que de 2,54 mm.





Après cela, j'ai passé quelques heures à dessiner des schémas de ces tableaux avec des clés. Il s'est avéré que le schéma est un simple clavier matriciel.



Dans l'image en cercles jaunes, les chiffres sont les numéros des contacts «horizontaux» et les chiffres sur les touches sont les numéros des contacts «verticaux» du connecteur PBS-13 sur la carte du clavier.







Après cela, tout cela a été jeté dans un coin et épousseté pendant un an. Et puis la période d'isolement a commencé ... C'est devenu ennuyeux et je voulais faire quelque chose de mes propres mains, d'autant plus qu'il n'y a nulle part où aller, et c'est impossible ...

Au final, j'ai décidé d'essayer de finir ce jouet au moins un peu. La carte Arduino a été prise comme base pour le contrôleur, et comme le nombre de porte-clés est supérieur au nombre de broches Arduino UNO, j'ai décidé d'utiliser les registres à décalage 74HC595 et 74HC165. En conséquence, nous avons obtenu un tel régime.



Le circuit était à l'origine assemblé sur une planche à pain sans soudure. Pour tester l'opérabilité du circuit (qu'il n'y a aucune erreur dans les connexions n'importe où), un programme de test a été développé qui a montré que tout semblait fonctionner. L'algorithme du programme de test était simple: l'une des sorties de la puce de sortie de décalage est activée et les valeurs sont lues dans un cycle à partir de la puce d'entrée de décalage, tout en appuyant sur les touches. À première vue, rien n'annonçait le problème ... et tout semblait bien fonctionner ...



Les jours suivants, j'ai lentement travaillé sur les "devoirs", à savoir, soudant soigneusement tous les composants de la planche sur une planche à pain. J'ai tout récupéré de ce qui était chez moi. Il a pris l'Arduino NANO comme carte de contrôle.



Un tel "sandwich" des planches est dû au fait que les deux planches du jouet (l'une avec des boutons et l'autre avec le clavier) sont situées à des niveaux différents, et avant de les souder, je pensais: "Est-il possible de les connecter ensemble en utilisant les composants que j'ai chez moi pour être plus ou moins beaux? » Et il s'est avéré que cette conception de deux cartes interconnectées par des connecteurs. De mon point de vue, pour l'option maison, lorsque nous nous asseyons dans l'isolement, cela s'est plutôt bien passé. Tout ce que j'avais à faire était de couper la planche à pain et de modifier légèrement le corps du jouet afin que vous puissiez connecter le câble USB à la carte Arduino.



La réalisation que l'appareil ne fonctionne pas exactement comme je le souhaitais est venue lorsque j'ai finalisé le programme de test. L'algorithme était simple: allumez chaque sortie de la puce 74HC595, en tenant compte de l'état des entrées de la puce 74HC165, et écrivez le résultat dans des variables distinctes. Au total, 5 sorties du 74HC595 sont connectées au clavier, donc au final j'ai obtenu 40 bits (5 * 8) de données après ce sondage. Une chaîne de 40 bits a été émise vers la console, et des touches ont été enfoncées pour voir comment l'appareil gère les frappes simultanées de plusieurs touches.



C'est là que le problème est apparu: si vous appuyez sur une touche, tout allait bien, mais lorsque vous essayez d'appuyer sur plus de 2 touches en même temps, une situation survient lorsqu'il est impossible de prédire ce qui sera lu. Le résultat pourrait être correct avec une combinaison et avec une autre, il pourrait être complètement imprévisible. Le problème était que la caractéristique de ce régime n'était pas prise en compte. Lorsque plusieurs touches sont enfoncées en même temps, non seulement plusieurs verticales du balayage du clavier sont fermées (cela est autorisé), mais plusieurs lignes horizontales peuvent être fermées via les touches (ce qui n'est en aucun cas autorisé). Vous pouvez en savoir plus sur ce problème et comment le résoudre ici.

J'ai choisi la «solution cardinale» du problème, à savoir: j'ai décidé que pour chaque touche du clavier il y aurait une diode.

Dans ma tête, j'ai déjà mentalement commencé à penser comment je devrais couper les pistes sur la carte et mettre la diode dans le boîtier SMD dans l'espace. Je suis monté dans mes salles de stockage et j'ai vu que je n'avais tout simplement pas autant de diodes dans le boîtier SMD (n'oubliez pas que nous nous asseyons tous sur l'auto-isolation et qu'il n'est pas très possible d'aller au magasin pour les composants radio - car ce ne sont certainement pas des biens essentiels). Un peu contrarié, j'ai décidé de regarder de plus près la carte: il peut être possible de mettre des diodes de sortie sur certaines pistes (j'en avais aussi certaines). Et puis j'ai vu que chaque touche a un cavalier (la carte est unilatérale) et le circuit est fait de sorte qu'au lieu de ce cavalier, vous pouvez mettre une diode. Immédiatement, j'ai pensé - vous n'avez même pas besoin de couper quoi que ce soit, il vous suffit de mettre des diodes de sortie au lieu de cavaliers partout.Je n'avais pas non plus autant de diodes de sortie. Une pensée m'a traversé la tête: "peut-être des LED?" Le circuit fonctionne à + 5V et si vous mettez des LED rouges qui ont une chute de tension minimale (parmi les LED), alors à la fin il devrait y avoir un niveau logique pour la détermination correcte: la touche est enfoncée ou non.



Dans cet esprit, je suis remonté dans mes stocks et j'ai attrapé les LED rouges de partout où c'était possible. Il y en avait exactement autant que les touches du clavier! C'est un signe, je pensais, et j'ai soudé plusieurs LED au lieu de cavaliers pour les tests. Les résultats des tests ont montré que la solution fonctionne. Après cela, j'ai soudé les LED restantes au lieu des cavaliers. Le programme de test a montré que vous pouvez appuyer sur au moins toutes les touches en même temps et qu'elles sont toutes lues correctement.



J'ai décidé de ne pas mettre de diodes sur les boutons supplémentaires qui se trouvent sur le jouet, car il est peu probable qu'ils soient pressés par plusieurs pièces à la fois. De plus, dans le programme, je n'ai pas encore de traitement pour cliquer sur ces boutons. Eh bien, je n'ai pas encore décidé comment les utiliser.

Le moment est venu de comprendre comment faire apparaître cet appareil sur votre ordinateur comme un clavier MIDI et dans quel format vous devez envoyer des données.

Les informations trouvées sur Internet me disent qu'il est possible de créer un clavier MIDI à partir d'Arduino très facilement et simplement en y versant un firmware, ce qui fera que l'ordinateur ne le verra pas comme un port COM, mais comme un clavier MIDI. Au départ, j'ai été guidé par cette décision , pas particulièrement sur la façon dont elle est mise en œuvre.

Maintenant, quand je suis arrivé à lui et l'ai lu attentivement, j'ai réalisé que ma carte Arduino NANO ne serait pas adaptée à cette solution, car elle avait un port COM basé sur la puce CH340. Pour utiliser le firmware du lien ci-dessus, seules les cartes qui ont déjà un port USB sur le contrôleur (par exemple: AtMega32u4) conviennent ou la communication via le port COM ne se fait pas sur des puces de conversion de type FT232RL ou similaires, mais sur des microcontrôleurs AtMega. Par conséquent, le firmware de la carte doit envoyer les données au format MIDI au port COM, et sur l'ordinateur, vous devrez installer et configurer un logiciel qui interceptera ces données et les transmettra au port MIDI virtuel.
L'algorithme de lecture des clés et de génération des commandes MIDI était le suivant:



Le programme du contrôleur Arduino NANO ressemble maintenant à ceci.
//    +5V
//   ST_CP  74HC595
#define latchPin      11
//   SH_CP  74HC595
#define clockPin      13
//   DS  74HC595
#define dataPin       12

//     +5V
#define latchPin_IN   9
#define clockPin_IN   10
#define dataPin_IN    8

// ,       1-16    
#define BUT_OUT0      7
#define BUT_OUT1      6
#define BUT_OUT2      5
#define BUT_OUT3      4

byte but_out[4] = {BUT_OUT0, BUT_OUT1, BUT_OUT2, BUT_OUT3};
//       
byte kbd_in[5] = {0, 0, 0, 0, 0};
byte kbd_in_new[5] = {0, 0, 0, 0, 0};

//       
byte btn_in[4] = {0, 0, 0, 0};
byte btn_in_new[4] = {0, 0, 0, 0};

//  3  -   (1 - , 0 - )
byte kbd_out = 0b11100000;

//  
void init_electronics() {
  //  ,   +5V
  //  OUTPUT
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);

  //  ,   +5V
  pinMode(latchPin_IN, OUTPUT);
  pinMode(clockPin_IN, OUTPUT);
  pinMode(dataPin_IN, INPUT);

  //          
  for (byte i = 0; i < 4; i++) pinMode(but_out[i], OUTPUT);
}

//      74HC595
void write_5V(byte a) {
    digitalWrite(latchPin, LOW);
    //    dataPin
    shiftOut(dataPin, clockPin, MSBFIRST, a); 
     //"" ,      
    digitalWrite(latchPin, HIGH); 
}

void read_5V(byte *btn, byte *kbd) {
  digitalWrite(clockPin_IN, HIGH);
  digitalWrite(latchPin_IN, LOW);
  digitalWrite(latchPin_IN, HIGH);
  
  //    -    
  *btn = shiftIn(dataPin_IN, clockPin_IN, LSBFIRST);
  
  //    -    
  *kbd = shiftIn(dataPin_IN, clockPin_IN, LSBFIRST);
}

void setup() {
  init_electronics();
  write_5V(kbd_out);
  Serial.begin(115200);
}

//       ,   
void read_kbd_and_btn_state(byte *btn, byte *kbd) {
 byte tmp;
  for (byte i = 0; i < 5; i++) {
    write_5V(kbd_out | (1 << i));
    read_5V(&tmp, &kbd[i]);
  }
}

void noteOn(int cmd, int pitch, int velocity) {
  Serial.write(cmd);
  Serial.write(pitch);
  Serial.write(velocity);
}

//     num  ,   
// 0 -  0,  0
// 1 -  0,  1
// 2 -  1,  1
// 3 -  1,  0
byte compare_bit(byte old_state, byte new_state, byte num) {
  byte tmp_old, tmp_new;
  tmp_old = (old_state >> num) & 1;
  tmp_new = (new_state >> num) & 1;
  if ((tmp_old == 0) && (tmp_new == 0)) return 0;
  if ((tmp_old == 0) && (tmp_new == 1)) return 1;
  if ((tmp_old == 1) && (tmp_new == 1)) return 2; 
  if ((tmp_old == 1) && (tmp_new == 0)) return 3;  
}

void loop() {
  read_kbd_and_btn_state(btn_in_new, kbd_in_new);
  for (byte i = 0; i < 5; i++) {
    for (byte j = 0; j < 8; j++) {
      switch (compare_bit(kbd_in[i], kbd_in_new[i], 7 - j)) {
        //  
        case 1: noteOn(0x90, 0x1D + (8 * i + j), 0x7F);
                break;
        //  
        case 2: //noteOn(0x00, 0x1D + (8 * i + j), 0x7F);
                break;
        //  
        case 3: noteOn(0x90, 0x1D + (8 * i + j), 0x00);
                break;
      }
    }
    kbd_in[i] = kbd_in_new[i];
  }
} 


Cela n'a aucun sens de peindre en détail comment travailler avec des données MIDI, car elles peuvent être lues ici.

Je m'attarderai plus en détail sur le logiciel pour l'ordinateur et les problèmes que j'ai rencontrés. Des problèmes sont survenus, simplement en raison du manque de documentation normale pour ce logiciel. Donc, pour que l'ordinateur puisse recevoir avec succès les données MIDI d'un appareil comme le mien, vous aurez besoin de deux programmes: loopMIDI et Serial-Midi Converter . Pour Serial-MIDI Converter, vous devez également installer Java, s'il n'est pas installé sur l'ordinateur.

Nous démarrons le programme loopMIDI et créons deux ports virtuels. Je les ai appelés Arduino IN et Arduino OUT. Ce programme sera un périphérique MIDI virtuel.



Ensuite, exécutez Serial-MIDI Converter et au démarrage, nous passons par le processus de configuration. Malheureusement, vous devez le faire chaque fois que vous le démarrez, mais ce n'est pas très effrayant, cela se fait littéralement en quatre frappes sur le clavier. Le numéro de port COM peut être différent; il apparaît sur l'ordinateur lorsque la carte Arduino NANO est connectée. La vitesse du port est définie dans le firmware Arduino NANO. Les flèches rouges indiquent mes paramètres, où tout a fonctionné pour moi.



En fait, le processus de configuration est terminé et vous pouvez déjà utiliser un logiciel qui jouera des sons en acceptant les touches de l'appareil. Dans les paramètres du logiciel, vous devez sélectionner "Arduino_OUT" comme entrée. Dans l'image ci-dessous, un exemple de configuration de Kontakt Player.



Cela fonctionne finalement comme ceci:


Et après? Et puis tout s'est passé exactement comme je m'y attendais - le jouet reste un jouet avec exactement toutes les lacunes que j'ai mentionnées au tout début. Probablement, l'enfant jouera celui-ci dans un bourdonnement, mais pour un adulte, après les instruments à clavier normaux ... Il est plus facile d'acheter n'importe quel clavier MIDI utilisé à moindre coût et ce sera beaucoup mieux que ce jouet. J'ai décidé de laisser ce jouet tel quel, mais y apporter quelques modifications:

  1. Laissez le boîtier d'origine.
  2. Mettez des haut-parleurs qui fonctionnent et faites un amplificateur pour eux.
  3. Faites-le fonctionner en mode «jouet pour enfants» sans vous connecter à un ordinateur, c'est-à-dire pour qu'il puisse jouer des sons lui-même.
  4. Permet de connecter FootSwitch (la même pédale sur le piano ci-dessous) afin que vous puissiez maintenir le son après avoir relâché les touches, comme sur un instrument normal.
  5. , .
  6. , -, .



Je ne peux pas faire la mise en œuvre de la plupart des points, alors que nous sommes tous ensemble «à la maison», car je n'ai tout simplement pas tous les composants requis pour cela à la maison.

Pour implémenter le paragraphe 3 sur Internet, une solution a été trouvée appelée SamplerBox . L'essence du projet est que vous pouvez connecter n'importe quel clavier MIDI à la carte Raspberry Pi, qui traite les commandes MIDI du clavier et joue des sons ou change d'instruments, etc. Il ne reste plus qu'à mettre la carte Raspberry Pi à l'intérieur du corps du jouet, sans possibilité de remplacer la carte SD (sans démonter le boîtier), configurer les boutons sur le corps du jouet pour qu'ils changent d'outils et ce sera suffisant pour laisser ce projet sous cette forme.

Mais tout cela se produira après la fin de la période d'auto-isolement.

J'espère que quelqu'un trouvera mon expérience utile.

All Articles