Erstellen eines MIDI-Keyboards aus einem Synthesizer für alte Kinder

Bild

Als ich eines Tages nach Hause zurückkehrte, sah ich in der Nähe der Müllrutsche im Eingang einen alten Kinderspielzeugsynthesizer. Vorbei, da es „sündig“ war, es aus dem Müll zu holen, aber in meinem Herzen wollte ich es da rausziehen. Bereits spät in der Nacht, gegen 2 Uhr, beschloss ich zu sehen, ob sie noch dort stand. Und ja, sie war immer noch da! In ihrem Aussehen war sie völlig ganz und sauber, so dass es keine Zimperlichkeit gab, um sie nicht zu nehmen. Also ja, ich habe sie genommen.

Ich wollte schon lange ein Klavier für mich, ich bin kein professioneller Musiker, sondern nur um mich zu verwöhnen - warum nicht? Etwas zu kaufen "um mich verwöhnen zu lassen" Ich wurde "von einer Kröte erwürgt" und hier - ein kostenloses Spielzeug. Als ich es aus dem Papierkorb nahm, dachte ich nicht einmal daran, es als Kinderspielzeug zu verwenden. Ich dachte sofort: "Ohhhh ... eine gute Basis, um zu versuchen, ein MIDI-Keyboard herzustellen."
Da ich bereits Erfahrung in der Kommunikation mit professionellen Keyboards und MIDI-Keyboards habe, habe ich sofort alle Nachteile meiner Idee verstanden. Das heißt, ein Spielzeug wird tatsächlich ein Spielzeug bleiben. Auf dieser Grundlage wird es unmöglich sein, die Kraft von Tastenanschlägen zu realisieren. Die „leichten“ Plastikschlüssel selbst, die ebenfalls unvollständig sind, werden es nicht ermöglichen, etwas Wertvolles daran auszuführen.

Zunächst wurde der Spielzeugsynthesizer "bis zur Schraube" zerlegt, der gesamte Kunststoff wurde gut mit Seife gewaschen. Die Karten und Kontaktschlüsselgruppen werden ebenfalls gereinigt.

Nach der Demontage wurde verstanden, warum die Leute es wegwarfen. Ein Spielzeug (ich weiß nicht warum: von Zeit zu Zeit, aufgrund der chinesischen Qualität der Komponenten oder der schwierigen Bedienung) Erstens: Die eingebauten Lautsprecher fielen auseinander, und zweitens: Ein defekter Stecker steckte in der Kopfhörerbuchse, sodass es praktisch keine Möglichkeit gab, sie herauszuziehen . Nachdem das Spielzeug aufgehört hatte, mit den eingebauten Lautsprechern zu spielen, benutzten sie es wahrscheinlich mit Kopfhörern, und nachdem sie den Stecker dort gebrochen hatten, warfen sie ihn einfach weg.

Im Inneren bestand der Spielzeugsynthesizer aus drei Platinen, die durch eine Kabelschleife miteinander verbunden waren. Die zentrale Platine, die für die Erzeugung von Ton und anderen Dingen verantwortlich war, wurde sofort von den beiden anderen Platinen abgelötet und beiseite gelegt. Auf den beiden anderen Brettern befanden sich Kontakte für die Tasten auf der Vorderseite des Spielzeugs und die Klaviertasten. Ich habe die PBS-Steckverbinder mit ihnen verlötet, zumal der Lochabstand auf den Platinen nur 2,54 mm betrug.





Danach habe ich ein paar Stunden damit verbracht, Diagramme dieser Tafeln mit Schlüsseln zu erstellen. Wie sich herausstellte, ist das Schema eine einfache Matrixtastatur.



In dem Bild in gelben Kreisen sind die Nummern die Nummern der "horizontalen" Kontakte und die Nummern auf den Tasten die Nummern der "vertikalen" Kontakte im PBS-13-Anschluss auf der Tastaturplatine.







Danach wurde alles in eine Ecke geworfen und ein Jahr lang abgestaubt. Und dann begann die Zeit der Selbstisolation ... Es wurde langweilig und ich wollte etwas mit meinen eigenen Händen tun, zumal es nirgendwo hin geht und es unmöglich ist ...

Am Ende beschloss ich, dieses Spielzeug zumindest ein wenig fertigzustellen. Die Arduino-Karte wurde als Grundlage für die Steuerung verwendet, und da die Anzahl der Schlüsselketten größer ist als die Anzahl der Arduino-UNO-Pins, habe ich mich für die Schieberegister 74HC595 und 74HC165 entschieden. Als Ergebnis haben wir ein solches Schema bekommen.



Die Schaltung wurde ursprünglich auf einem lötfreien Steckbrett montiert. Um die Funktionsfähigkeit der Schaltung zu testen (dass es nirgendwo Fehler in den Verbindungen gibt), wurde ein Testprogramm entwickelt, das zeigte, dass alles zu funktionieren schien. Der Algorithmus des Testprogramms war einfach: Einer der Ausgänge des Shift-Ausgangschips wird eingeschaltet und die Werte werden in einem Zyklus vom Shift-Eingangschip gelesen, während die Tasten gedrückt werden. Auf den ersten Blick deutete nichts auf Probleme hin ... und alles schien gut zu funktionieren ...



In den nächsten Tagen arbeitete ich langsam an „Hausaufgaben“, nämlich dem sorgfältigen Löten aller Komponenten des Boards auf ein Steckbrett. Ich habe alles bei mir gesammelt. Er nahm den Arduino NANO als Kontrollplatine.



Ein solches „Sandwich“ von den Brettern ist darauf zurückzuführen, dass sich die beiden Bretter des Spielzeugs (eines mit Knöpfen und das andere mit der Tastatur) auf verschiedenen Ebenen befinden. Bevor ich alles verlötete, dachte ich: „Ist es möglich, es irgendwie miteinander zu verbinden? die Komponenten, die ich zu Hause habe, um mehr oder weniger gut auszusehen? “ Und so stellte sich heraus, dass zwei Platinen durch Steckverbinder miteinander verbunden waren. Aus meiner Sicht hat es sich für die Heimoption als recht gut herausgestellt, wenn wir in Selbstisolation sitzen. Alles, was ich tun musste, war das Steckbrett zu schneiden und den Spielzeugkörper leicht zu modifizieren, damit Sie das USB-Kabel an das Arduino-Brett anschließen konnten.



Die Erkenntnis, dass das Gerät nicht genau so funktioniert, wie ich es wollte, kam, als ich das Testprogramm fertigstellte. Der Algorithmus war einfach: Schalten Sie jeden Ausgang des 74HC595-Chips unter Berücksichtigung des Status der Eingänge des 74HC165-Chips ein und schreiben Sie das Ergebnis in separate Variablen. Insgesamt sind 5 Ausgänge des 74HC595 mit der Tastatur verbunden, sodass ich nach dieser Abfrage am Ende 40 Bit (5 * 8) Daten erhalten habe. Eine Zeichenfolge von 40 Bit wurde an die Konsole ausgegeben, und Tasten wurden gedrückt, um zu sehen, wie das Gerät gleichzeitig Tastenanschläge mehrerer Tasten verarbeitet.



Hier trat das Problem auf: Wenn Sie eine Taste drücken, war alles in Ordnung, aber wenn Sie versuchen, mehr als zwei Tasten gleichzeitig zu drücken, trat eine Situation auf, in der es unmöglich war, vorherzusagen, was gelesen werden würde. Das Ergebnis könnte bei einer Kombination korrekt und bei einer anderen völlig unvorhersehbar sein. Das Problem war, dass das Merkmal dieses Schemas nicht berücksichtigt wurde. Wenn mehrere Tasten gleichzeitig gedrückt werden, werden nicht nur mehrere Vertikale des Tastaturscans geschlossen (dies ist zulässig), sondern es können auch mehrere horizontale Linien durch die Tasten geschlossen werden (was keinesfalls zulässig ist). Weitere Informationen zu diesem Problem und dessen Lösung finden Sie hier.

Ich habe die „Hauptlösung“ des Problems gewählt, nämlich: Ich habe beschlossen, dass für jede Taste in der Tastatur eine Diode vorhanden ist.

In meinem Kopf begann ich schon mental darüber nachzudenken, wie ich die Spuren auf der Platine abschneiden und die Diode in das SMD-Gehäuse in die Lücke stecken müsste. Ich stieg in meine Lagerräume und sah, dass ich im SMD-Gehäuse einfach nicht so viele Dioden hatte (vergessen Sie nicht, dass wir alle auf Selbstisolierung sitzen und es nicht sehr gut möglich ist, in den Laden für Funkkomponenten zu gehen - da dies definitiv keine wesentlichen Waren sind). Ein wenig verärgert beschloss ich, mir die Platine genauer anzusehen: Es ist möglicherweise möglich, Ausgangsdioden auf einige der Spuren zu setzen (ich hatte auch einige davon). Und dann habe ich gesehen, dass jeder Schlüssel einen Jumper hat (die Platine ist einseitig) und die Schaltung so hergestellt ist, dass Sie anstelle dieses Jumpers eine Diode einsetzen können. Ich dachte sofort - Sie müssen nicht einmal etwas schneiden, Sie müssen nur überall Ausgangsdioden anstelle von Jumpern einsetzen.Ich hatte auch nicht so viele Ausgangsdioden. Ein Gedanke schoss mir durch den Kopf: "Vielleicht LEDs?" Die Schaltung arbeitet mit +5 V und wenn Sie rote LEDs mit einem minimalen Spannungsabfall (zwischen den LEDs) platzieren, sollte am Ende eine logische Ebene für die korrekte Bestimmung vorhanden sein: Die Taste wird gedrückt oder nicht.



In diesem Sinne stieg ich wieder in meine Aktien und griff nach den roten LEDs, wo immer es möglich war. Es gab genau so viele wie die Tasten auf der Tastatur! Dies ist ein Zeichen, dachte ich und löte zum Testen mehrere LEDs anstelle von Jumpern. Testergebnisse zeigten, dass die Lösung funktioniert. Danach habe ich die restlichen LEDs anstelle von Jumpern gelötet. Das Testprogramm hat gezeigt, dass Sie mindestens alle Tasten gleichzeitig drücken können und alle korrekt gelesen werden.



Ich habe beschlossen, keine Dioden auf die zusätzlichen Knöpfe am Spielzeug zu setzen, da es unwahrscheinlich ist, dass sie von mehreren Teilen gleichzeitig gedrückt werden. Außerdem habe ich im Programm noch keine Bearbeitung zum Klicken auf diese Schaltflächen. Nun, ich habe noch nicht entschieden, wie ich sie verwenden soll.

Es ist an der Zeit herauszufinden, wie dieses Gerät als MIDI-Keyboard auf Ihrem Computer angezeigt wird und in welchem ​​Format Sie Daten senden müssen.

Die im Internet gefundenen Informationen sagten mir, dass es möglich ist, ein MIDI-Keyboard aus Arduino sehr einfach und einfach durch Eingießen von Firmware zu erstellen, wodurch der Computer es nicht als COM-Port, sondern als MIDI-Keyboard sieht. Anfangs habe ich mich von dieser Entscheidung leiten lassen und nicht besonders darauf eingegangen, wie sie umgesetzt wird.

Als ich zu ihm kam und es sorgfältig las, wurde mir klar, dass mein Arduino NANO-Board für diese Lösung nicht geeignet sein würde, da es einen COM-Anschluss auf der Basis des CH340-Chips hatte. Um die Firmware über den obigen Link zu verwenden, sind nur Karten geeignet, die bereits einen USB-Anschluss am Controller haben (z. B. AtMega32u4), oder die Kommunikation über den COM-Anschluss erfolgt nicht über FT232RL-Konvertierungschips oder ähnliches, sondern über AtMega-Mikrocontroller. Daher muss die Firmware auf der Karte die Daten im MIDI-Format an den COM-Port senden. Auf dem Computer müssen Sie Software installieren und konfigurieren, die diese Daten abfängt und an den virtuellen MIDI-Port überträgt.
Der Algorithmus zum Lesen von Tasten und Generieren von MIDI-Befehlen war wie folgt:



Das Programm für den Arduino NANO-Controller sieht jetzt so aus.
//    +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];
  }
} 


Es macht keinen Sinn, detailliert zu beschreiben, wie man mit MIDI-Daten arbeitet, da diese hier gelesen werden können.

Ich werde näher auf die Software für den Computer und die Probleme eingehen, auf die ich gestoßen bin. Probleme traten einfach aufgrund des Mangels an normaler Dokumentation für diese Software auf. Damit der Computer MIDI-Daten von einem Gerät wie meinem erfolgreich empfangen kann, benötigen Sie zwei Programme: loopMIDI und Serial-Midi Converter . Für Serial-MIDI Converter müssen Sie auch Java installieren, wenn es nicht auf dem Computer installiert ist.

Wir starten das Programm loopMIDI und erstellen zwei virtuelle Ports. Ich nannte sie Arduino IN und Arduino OUT. Dieses Programm wird ein virtuelles MIDI-Gerät sein.



Führen Sie als Nächstes den Serial-MIDI Converter aus und führen Sie ihn beim Start durch. Leider müssen Sie dies jedes Mal tun, wenn Sie es starten, aber es ist nicht sehr beängstigend, es wird buchstäblich in vier Tastenanschlägen auf der Tastatur ausgeführt. Die COM-Port-Nummer kann unterschiedlich sein. Sie wird auf dem Computer angezeigt, wenn die Arduino NANO-Karte angeschlossen ist. Die Portgeschwindigkeit wird in der Arduino NANO-Firmware eingestellt. Die roten Pfeile zeigen meine Einstellungen an, bei denen alles für mich funktioniert hat.



Tatsächlich ist der Einrichtungsvorgang abgeschlossen und Sie können bereits eine Software verwenden, die Sounds wiedergibt, indem Sie Tastenanschläge vom Gerät akzeptieren. In den Softwareeinstellungen müssen Sie "Arduino_OUT" als Eingabe auswählen. Im Bild unten ein Beispiel für die Konfiguration von Kontakt Player.



Es funktioniert letztendlich so:


Was weiter? Und dann passierte alles genau so, wie ich es erwartet hatte - das Spielzeug bleibt ein Spielzeug mit genau den Mängeln, die ich am Anfang erwähnt habe. Wahrscheinlich wird das Kind dieses Spiel in einem Summen spielen, aber für einen Erwachsenen nach normalen Tasteninstrumenten ... Es ist einfacher, ein gebrauchtes MIDI-Keyboard billig zu kaufen, und es ist viel besser als dieses Spielzeug. Ich habe beschlossen, dieses Spielzeug so zu belassen, wie es ist, aber einige Änderungen daran vorzunehmen:

  1. Lassen Sie den Originaletui.
  2. Stellen Sie funktionierende Lautsprecher auf und stellen Sie einen Verstärker für sie her.
  3. Lassen Sie es im Modus „Kinderspielzeug“ funktionieren, ohne eine Verbindung zu einem Computer herzustellen, damit es selbst Sounds abspielen kann.
  4. Ermöglichen Sie den Anschluss von FootSwitch (dasselbe Pedal am Klavier unten), damit Sie den Ton nach dem Loslassen der Tasten wie bei einem normalen Instrument halten können.
  5. , .
  6. , -, .



Ich kann die meisten Punkte nicht umsetzen, während wir alle "zu Hause" zusammen sind, da ich zu Hause einfach nicht alle erforderlichen Komponenten dafür habe.

Um Absatz 3 im Internet zu implementieren, wurde eine Lösung namens SamplerBox gefunden . Das Wesentliche des Projekts ist, dass Sie jedes MIDI-Keyboard an das Raspberry Pi-Board anschließen können, das MIDI-Befehle vom Keyboard verarbeitet und Sounds spielt oder Instrumente usw. wechselt. Es bleibt nur, die Raspberry Pi-Platine in den Spielzeugkörper zu stecken, ohne die Möglichkeit zu haben, die SD-Karte auszutauschen (ohne das Gehäuse zu zerlegen). Konfigurieren Sie die Tasten am Spielzeugkörper so, dass sie die Werkzeuge wechseln. Dies reicht aus, um dieses Projekt in dieser Form zu belassen.

Aber all dies wird nach dem Ende der Zeit der Selbstisolation geschehen.

Ich hoffe, dass jemand meine Erfahrung nützlich findet.

All Articles