Fazendo um teclado MIDI a partir de um sintetizador de crianças velhas

imagem

Um dia, voltando para casa, perto da calha de lixo na entrada, vi um sintetizador de brinquedos para crianças velhas. Passei, já que era "pecaminoso" tirar do lixo, mas no meu coração eu queria arrastá-la para fora de lá. Já tarde da noite, por volta das duas horas, decidi ver se ela ainda estava lá. E sim, ela ainda estava lá! Na aparência, ela era completamente íntegra e limpa, então não havia melindrosas para não tomá-la. Então sim, eu a peguei.

Há muito tempo que eu queria um piano para mim, não sou músico profissional, mas apenas para me entregar - por que não? Comprando algo "por mimos" eu fui "estrangulado por um sapo", e aqui - um brinquedo grátis. Quando o tirei do lixo, nem pensei em usá-lo como um brinquedo de criança, pensei imediatamente: "Ohhhh ... uma boa base para tentar criar um teclado MIDI".
Como já tenho alguma experiência em comunicação com teclados profissionais e teclados MIDI, entendi imediatamente todas as desvantagens da minha ideia. Ou seja, um brinquedo continuará sendo um brinquedo. Com base nisso, será impossível perceber o poder das teclas. As próprias teclas de plástico "leves", que também são incompletas, não permitirão executar algo digno.

Primeiro, o sintetizador de brinquedos foi desmontado "ao parafuso", todo o plástico foi bem lavado com sabão. As placas e os grupos de chaves de contato também são limpos.

Após a desmontagem, surgiu um entendimento do porquê as pessoas a jogaram fora. Um brinquedo (não sei por quê: de tempos em tempos, da qualidade dos componentes em chinês ou operação difícil) primeiro: os alto-falantes embutidos desmoronavam e, em segundo lugar: um conector quebrado deles preso no conector do fone de ouvido; portanto, praticamente não havia como retirá-lo . Provavelmente, depois que o brinquedo parou de brincar com os alto-falantes embutidos, eles o usaram com fones de ouvido e, depois que quebraram o conector, simplesmente o jogaram fora.

No interior, o sintetizador de brinquedo consistia em três placas interconectadas por um laço de cabo. A diretoria central, responsável por gerar som e outras coisas, foi imediatamente desoldada das outras duas diretorias e deixada de lado. Nas outras duas placas, havia contatos para os botões no painel frontal do brinquedo e as próprias teclas do piano. Soldamos os conectores PBS a eles, principalmente porque a distância do furo nas placas era de apenas 2,54 mm.





Depois disso, passei algumas horas desenhando diagramas dessas placas com chaves. Como se viu, o esquema é um teclado matricial simples.



Na figura em círculos amarelos, os números são os números dos contatos "horizontais" e os números nas teclas são os números dos contatos "verticais" no conector PBS-13 na placa do teclado.







Depois disso, tudo isso foi jogado em um canto e polvilhado por um ano. E então o período de auto-isolamento começou ... Tornou-se chato e eu queria fazer algo com minhas próprias mãos, especialmente porque não há para onde ir, e é impossível ...

No final, decidi tentar terminar este brinquedo pelo menos um pouco. A placa Arduino foi tomada como base para o controlador e, como o número de chaveiros é maior que o número de pinos UNO do Arduino, decidi usar os registros de deslocamento 74HC595 e 74HC165. Como resultado, conseguimos esse esquema.



O circuito foi originalmente montado em uma tábua de pão sem solda. Para testar a operacionalidade do circuito (que não há erros nas conexões em qualquer lugar), foi desenvolvido um programa de teste que mostrava que tudo parecia funcionar. O algoritmo do programa de teste era simples: uma das saídas do chip de saída shift é ativada e os valores são lidos em um ciclo a partir do chip de entrada shift, enquanto pressiona as teclas. À primeira vista, nada prenunciava problemas ... e tudo parecia funcionar bem ...



Nos próximos dias, trabalhei lentamente em "lição de casa", ou seja, soldando cuidadosamente todos os componentes da placa em uma tábua de pão. Eu coletei tudo do que estava na minha casa. Ele pegou o Arduino NANO como placa de controle.



Esse “sanduíche” das pranchas se deve ao fato de as duas pranchas do brinquedo (uma com botões e a segunda com o teclado) estarem localizadas em níveis diferentes e, antes de soldar tudo, pensei: “É possível conectá-lo de alguma forma usando os componentes que tenho em casa para parecerem mais ou menos bons? ” E assim resultou o design de duas placas interconectadas por conectores. Do meu ponto de vista, para a opção de casa, quando nos sentimos em auto-isolamento, tudo saiu muito bem. Tudo o que eu precisava fazer era cortar a tábua de pão e modificar levemente o corpo do brinquedo para que você pudesse conectar o cabo USB à placa do Arduino.



A constatação de que o dispositivo não funciona exatamente como eu queria veio quando finalizei o programa de teste. O algoritmo era simples: ligue cada saída do chip 74HC595, levando em consideração o estado das entradas do chip 74HC165 e escreva o resultado em variáveis ​​separadas. No total, 5 saídas do 74HC595 estão conectadas ao teclado, então, no final, recebi 40 bits (5 * 8) de dados após esta pesquisa. Uma sequência de 40 bits foi enviada ao console e as teclas foram pressionadas para ver como o dispositivo lida com pressionamentos simultâneos de várias teclas.



Foi aqui que surgiu o problema: se você pressionar uma tecla, tudo estava bem, mas quando você tenta pressionar mais de duas teclas ao mesmo tempo, surgiu uma situação em que era impossível prever o que seria lido. O resultado pode estar correto com uma combinação e, com outra, pode ser completamente imprevisível. O problema era que o recurso desse esquema não foi levado em consideração. Quando várias teclas são pressionadas ao mesmo tempo, não apenas várias verticais da varredura do teclado são bloqueadas (isso é aceitável), mas várias linhas horizontais podem ser fechadas através das teclas (o que não é de forma alguma aceitável). Você pode ler mais sobre este problema e como resolvê-lo aqui.

Eu escolhi a “solução principal” do problema, a saber: decidi que para cada tecla do teclado haverá um diodo.

Na minha cabeça, eu já comecei a pensar mentalmente como teria que cortar os trilhos no quadro e colocar o diodo no gabinete SMD na brecha. Entrei em minhas salas de armazenamento e vi que simplesmente não tinha tantos diodos no caso SMD (não se esqueça de que todos nós sentamos no auto-isolamento e ir à loja para componentes de rádio não é muito possível - já que esses definitivamente não são bens essenciais). Um pouco chateado, decidi olhar mais de perto para o quadro: pode ser possível colocar diodos de saída em algumas das faixas (eu também tinha algumas). E então vi que cada tecla possui um jumper (a placa é unilateral) e o circuito é feito para que, em vez desse jumper, você possa colocar um diodo. Imediatamente pensei: você nem precisa cortar nada, basta colocar diodos de saída em vez de jumpers em todos os lugares.Eu também não tinha esse número de diodos de saída. Um pensamento passou pela minha cabeça: "talvez LEDs?" O circuito opera em + 5V e, se você colocar LEDs vermelhos com queda de tensão mínima (entre os LEDs), no final deve haver um nível lógico para a determinação correta: a tecla está pressionada ou não.



Com isso em mente, subi novamente em minhas ações e peguei os LEDs vermelhos de onde quer que fosse possível. Havia exatamente quantas teclas no teclado! Isso é um sinal, pensei, e soldou vários LEDs em vez de jumpers para teste. Os resultados dos testes mostraram que a solução está funcionando. Depois disso, soldados os LEDs restantes em vez dos jumpers. O programa de teste mostrou que você pode pressionar pelo menos todas as teclas ao mesmo tempo, e todas são lidas corretamente.



Decidi não colocar diodos nos botões adicionais que estão no brinquedo, porque é improvável que eles sejam pressionados por várias peças ao mesmo tempo. Além disso, no programa ainda não tenho processamento para clicar nesses botões. Ainda não decidi como usá-los.

Chegou a hora de descobrir como fazer com que este dispositivo apareça no seu computador como um teclado MIDI e em que formato você precisa enviar dados.

As informações encontradas na Internet me disseram que é possível criar um teclado MIDI a partir do Arduino com muita facilidade e simplicidade, despejando firmware nele, o que fará o computador vê-lo não como uma porta COM, mas como um teclado MIDI. Inicialmente, fui guiado por esta decisão , não particularmente entrando em como ela é implementada.

Agora, quando cheguei a ele e o li com atenção, percebi que minha placa Nano do Arduino não seria adequada para esta solução, pois possuía uma porta COM baseada no chip CH340. Para usar o firmware no link acima, apenas as placas que já possuem uma porta USB no controlador (por exemplo: AtMega32u4) são adequadas ou a comunicação via porta COM não é feita em chips de conversão do tipo FT232RL ou similares, mas nos microcontroladores AtMega. Portanto, o firmware na placa deve enviar os dados no formato MIDI para a porta COM e no computador você precisará instalar e configurar o software que interceptará esses dados e os transmitirá para a porta virtual MIDI.
O algoritmo para ler chaves e gerar comandos MIDI foi o seguinte:



O programa para o controlador NANO do Arduino agora se parece com isso.
//    +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];
  }
} 


Não faz sentido pintar em detalhes como trabalhar com dados MIDI, porque eles podem ser lidos aqui.

Vou abordar mais detalhadamente o software do computador e os problemas que encontrei. Surgiram problemas, simplesmente devido à falta de documentação normal para este software. Portanto, para que o computador possa receber com êxito dados MIDI de um dispositivo como o meu, você precisará de dois programas: loopMIDI e Serial-Midi Converter . Para o Serial-MIDI Converter, você também precisa instalar o Java, se não estiver instalado no computador.

Iniciamos o programa loopMIDI e criamos duas portas virtuais. Eu os chamei de Arduino IN e Arduino OUT. Este programa será um dispositivo MIDI virtual.



Em seguida, execute o Serial-MIDI Converter e, na inicialização, passamos pelo processo de configuração. Infelizmente, você precisa fazer isso toda vez que o inicia, mas não é muito assustador, é feito literalmente com quatro pressionamentos de tecla no teclado. O número da porta COM pode ser diferente; aparece no computador quando a placa Nano do Arduino está conectada. A velocidade da porta é definida no firmware do Arduino NANO. As setas vermelhas indicam minhas configurações, nas quais tudo funcionou para mim.



Na verdade, o processo de instalação foi concluído e você já pode usar algum software que reproduza sons aceitando as teclas do dispositivo. Nas configurações do software, você deve selecionar "Arduino_OUT" como entrada. Na figura abaixo, um exemplo de configuração do Kontakt Player.



Em última análise, funciona assim:


Qual é o próximo? E então tudo aconteceu exatamente como eu esperava - o brinquedo continua sendo um brinquedo com exatamente todas as deficiências que mencionei no início. Provavelmente, a criança tocará este em um momento, mas para um adulto, depois de instrumentos de teclado normais ... É mais fácil comprar qualquer teclado MIDI usado mais barato e será muito melhor que este brinquedo. Decidi deixar esse brinquedo como está, mas faça algumas modificações:

  1. Deixe o estojo original.
  2. Coloque os alto-falantes em funcionamento e faça um amplificador para eles.
  3. Faça com que ele funcione no modo “brinquedo infantil” sem conectar a um computador, ou seja, para que ele possa reproduzir os sons.
  4. Torne possível conectar o FootSwitch (o mesmo pedal no piano abaixo) para que você possa segurar o som depois de soltar as teclas, como em um instrumento normal.
  5. , .
  6. , -, .



Não posso implementar a maioria dos pontos, enquanto todos estamos juntos "em casa", já que não tenho todos os componentes necessários para isso em casa.

Para implementar o parágrafo 3 na Internet, foi encontrada uma solução chamada SamplerBox . A essência do projeto é que você pode conectar qualquer teclado MIDI à placa Raspberry Pi, que processa comandos MIDI do teclado e reproduz sons ou alterna instrumentos, etc. Resta apenas colocar a placa Raspberry Pi dentro do corpo do brinquedo, sem a possibilidade de substituir o cartão SD (sem desmontar o estojo), configurar os botões no corpo do brinquedo para que eles troquem de ferramenta e isso será suficiente para deixar este projeto neste formulário.

Mas tudo isso acontecerá após o término do período de auto-isolamento.

Espero que alguém ache minha experiência útil.

All Articles