home Tecnologia de manufatura Equipamentos de Fabricação
Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

Integração MIDI para Órgãos Digitais: Guia de Componentes e Configuração

Componentes e Materiais

Ferramentas Necessárias

Software

Sobre o Projeto

Este projeto mostra como converter um console de órgão antigo para que ele possa enviar mensagens MIDI de hardware a partir dos teclados (manuais) e pedalboard usando um único Arduino Mega.

Observações importantes:

Passo a Passo

Passo 1: Examine o Órgão

Passo 2: Fixe o Arduino

O Arduino Mega vem com plaqueta plástica para montagem. Parafuse a plaqueta na madeira do órgão (parafusos #4 para madeira) e o Arduino na plaqueta (parafusos máquina #4). Posicione primeiro para estimar comprimento dos cabos. Planeje também a alimentação do Arduino.

Passo 3: Prepare os Cabos

Teclado Matricial

Cada manual tem 61 chaves. No exemplo: 6 linhas (fio do terminal 1 de cada chave vai ao terminal 1 da chave 6 posições adiante). Terminal 2 vai a diodo, depois às colunas (11 colunas nos manuais, 7 no pedalboard). Para cada manual/pedalboard, corte dois comprimentos de cabo AWM que alcancem da matriz até o Arduino, seguindo roteamento organizado e com folga. Para colunas, o cabo deve percorrer o comprimento do teclado antes de ir ao Arduino. Meça, corte, separe as vias nas pontas e decape.

Teclado Bussed (Barramento)

O teclado divide-se em 6 cabos AWM + 1 fio avulso para a 61ª chave. Separe as vias nas pontas e decape.

Passo 4: Solde as Pontas dos Cabos nos Headers Macho

Solde as pontas dos cabos nos pinos do header macho (ou use bornes de parafuso se preferir).

Integração MIDI para Órgãos Digitais: Guia de Componentes e Configuração

Passo 5: Solde a Outra Ponta nas Chaves

Teclado Matricial

Teclado Bussed

Solde um diodo no lado não-barramento de cada chave (polo negativo voltado para a chave), depois solde este diodo a uma das 10 vias do cabo. Repita para cada uma das 6 vias/cabos, e para o fio extra (#61).

Passo 6: Solde o Resistor no Plug MIDI e Conecte ao Arduino

Conecte o resistor de 220Ω no pino 5 do plug DIN MIDI (saída TX do Arduino). Os outros pinos do MIDI vão para GND e 5V conforme esquemático.

Integração MIDI para Órgãos Digitais: Guia de Componentes e Configuração

Passo 7: Conecte os Headers ao Arduino

Passo 8: Carregue o Software no Arduino

Passo 9: Teste

Notas Adicionais

Hardware do Pedal de Expressão (Potenciômetro)

Integração MIDI para Órgãos Digitais: Guia de Componentes e Configuração

Breve explicação do design (detalhes futuros):

Instruções Detalhadas: Suporte do Pedal de Expressão

(Atualizado em 9 dez 2021)

Materiais

Ferramentas

Instruções

  1. Examine o pedal atual. Se há furo livre no suporte, use-o; caso contrário, use furo existente com parafuso mais longo.
  2. Limpe a base de madeira do órgão, mova componentes/eletrônica se necessário.
  3. Desembale o acrílico. Com régua e estilete, risque (score) ambos os lados num retângulo 3"×4.5", quebre no torno/alicates (use óculos!). Corte também peça 3"×0.5" e 2.4"×0.3".
  4. Corte o bloco Teflon com serra de hobby ~3/4" da ponta → bloco 3"×1.5"×0.75".
  5. Fure: 2 furos na base do acrílico grande (alinhados com um lado da dobradiça); 2 furos no lado 3"×1.5" do Teflon (fora do caminho da haste); 2 furos no acrílico grande opostos aos anteriores, na borda superior, alinhados com furos do Teflon; 2 furos na peça 2.4"×0.3" alinhados com outro lado da dobradiça.
  6. Lixe levemente: uma face do potenciômetro, área no acrílico grande onde será colado, e ambas faces da peça 3"×0.5". Limpe com pano úmido.
  7. Misture JB Weld no papelão com palito. Aplique na área preparada do acrílico grande. Coloque peça 3"×0.5", mais JB Weld, depois o potenciômetro (superfície lixada no JB Weld). Grampeie levemente. Deixe curar 24h.
  8. Fure o bloco Teflon: broca 1/4" movendo-a lateralmente para alargar, de um lado 3/4"×3" ao outro. Alinhe com o movimento do potenciômetro.
  9. Corte a haste 1/4" no comprimento aproximado da base do potenciômetro ao pedal totalmente pressionado.
  10. Após cura do JB Weld (24h): fixe dobradiça e bloco Teflon no acrílico grande com parafusos/arruelas/porcas. Coloque olhal na parte móvel do potenciômetro, passe a haste pelo Teflon e prenda o olhal na haste. Se folga, pode colar olhal+haste com JB Weld em etapa anterior (nesse caso, monte olhal no potenciômetro, passe pelo Teflon, depois parafuse Teflon no acrílico).
  11. Segurando olhal com alicate, fixe a braçadeira na outra ponta da haste com parafuso máquina adequado. Garanta orientação correta.
  12. Se há furo livre no suporte do pedal, passe novo parafuso máquina, coloque arruela Teflon e aperte até a braçadeira mover livre. Se usar furo ocupado, remova parafuso antigo, coloque mais longo, fixe braçadeira + arruela Teflon no comprimento extra.
  13. Mova a base da dobradiça no assoalho do órgão até alinhar a haste reta e o movimento do pedal acompanhar o do potenciômetro (com a plaqueta 2.4"×0.3" no lugar). Parafuse a base da dobradiça no assoalho com 2 parafusos #4 madeira, mantendo a plaqueta de acrílico entre a dobradiça e a madeira (garante curso correto).

Nota Final

O Arduino Project Hub não notifica sobre posts/perguntas aqui. Para resposta mais rápida, poste no fórum do Arduino que me notificará.

Código

Dois códigos disponíveis conforme o tipo de teclado:

Código para Teclado Matricial (Matrixed)

Faça upload deste código se estiver seguindo o esquemático matricial. Suporta 2 manuais (6×11) + pedalboard (6×7) + 2 pedais de expressão (pinos analógicos A0, A1).

Clique para expandir/copiar o código completo 
// Name: Arduino Mega Midi Controller v21
// Created: Feb 4, 2021
// Author: Larason2
// Acknowledgements: Bald Engineer, Amanda Ghassaei, jeffb42, GrumpyMike

byte keysA[11][6];
byte keysB[11][6];
byte keysC[7][6];
byte lastA[11][6];
byte lastB[11][6];
byte lastC[7][6];

int noteOn1 = 144; int noteOff1 = 128; // Canal 1
int noteOn2 = 145; int noteOff2 = 129; // Canal 2
int noteOn3 = 146; int noteOff3 = 130; // Canal 3
int velocity = 100;

int chan6 = 181; // Canal 6 - Expression pedal 1
int chan7 = 182; // Canal 7 - Expression pedal 2
int Exp = 11;    // Controller number for expression
int LastPot6 = 1;
int LastPot7 = 1;

void setup() {
  Serial.begin(31250); // Baud rate MIDI

  // Inicializar pinos Teclado A (pinos 2, 22-52 pares)
  pinMode(2, INPUT);  pinMode(22, INPUT); pinMode(24, INPUT); pinMode(26, INPUT);
  pinMode(28, INPUT); pinMode(30, INPUT); pinMode(32, INPUT); pinMode(34, INPUT);
  pinMode(36, INPUT); pinMode(38, INPUT); pinMode(40, INPUT); pinMode(42, INPUT);
  pinMode(44, INPUT); pinMode(46, INPUT); pinMode(48, INPUT); pinMode(50, INPUT);
  pinMode(52, INPUT);

  // Teclado B (pinos 3, 23-53 ímpares)
  pinMode(3, INPUT);  pinMode(23, INPUT); pinMode(25, INPUT); pinMode(27, INPUT);
  pinMode(29, INPUT); pinMode(31, INPUT); pinMode(33, INPUT); pinMode(35, INPUT);
  pinMode(37, INPUT); pinMode(39, INPUT); pinMode(41, INPUT); pinMode(43, INPUT);
  pinMode(45, INPUT); pinMode(47, INPUT); pinMode(49, INPUT); pinMode(51, INPUT);
  pinMode(53, INPUT);

  // Teclado C / Pedalboard (pinos analógicos A2-A14)
  pinMode(A2, INPUT); pinMode(A3, INPUT); pinMode(A4, INPUT); pinMode(A5, INPUT);
  pinMode(A6, INPUT); pinMode(A7, INPUT); pinMode(A8, INPUT); pinMode(A9, INPUT);
  pinMode(A10, INPUT); pinMode(A11, INPUT); pinMode(A12, INPUT); pinMode(A13, INPUT);
  pinMode(A14, INPUT);
}

void loop() {
  // --- LEITURA TECLADO A (Matriz 6x11) ---
  // Linhas: pinos 22,24,26,28,30,2 (INPUT_PULLUP)
  // Colunas: pinos 32,34,36,38,40,42,44,46,48,50,52 (OUTPUT, LOW ativo)
  pinMode(22, INPUT_PULLUP); pinMode(24, INPUT_PULLUP); pinMode(26, INPUT_PULLUP);
  pinMode(28, INPUT_PULLUP); pinMode(30, INPUT_PULLUP); pinMode(2, INPUT_PULLUP);

  pinMode(32, OUTPUT); digitalWrite(32, LOW); keysA[0][0] = digitalRead(2);
  pinMode(32, INPUT);  pinMode(34, OUTPUT); digitalWrite(34, LOW);
  keysA[1][0]=digitalRead(22); keysA[1][1]=digitalRead(24); keysA[1][2]=digitalRead(26);
  keysA[1][3]=digitalRead(28); keysA[1][4]=digitalRead(30); keysA[1][5]=digitalRead(2);
  pinMode(34, INPUT);  pinMode(36, OUTPUT); digitalWrite(36, LOW);
  keysA[2][0]=digitalRead(22); keysA[2][1]=digitalRead(24); keysA[2][2]=digitalRead(26);
  keysA[2][3]=digitalRead(28); keysA[2][4]=digitalRead(30); keysA[2][5]=digitalRead(2);
  pinMode(36, INPUT);  pinMode(38, OUTPUT); digitalWrite(38, LOW);
  keysA[3][0]=digitalRead(22); keysA[3][1]=digitalRead(24); keysA[3][2]=digitalRead(26);
  keysA[3][3]=digitalRead(28); keysA[3][4]=digitalRead(30); keysA[3][5]=digitalRead(2);
  pinMode(38, INPUT);  pinMode(40, OUTPUT); digitalWrite(40, LOW);
  keysA[4][0]=digitalRead(22); keysA[4][1]=digitalRead(24); keysA[4][2]=digitalRead(26);
  keysA[4][3]=digitalRead(28); keysA[4][4]=digitalRead(30); keysA[4][5]=digitalRead(2);
  pinMode(40, INPUT);  pinMode(42, OUTPUT); digitalWrite(42, LOW);
  keysA[5][0]=digitalRead(22); keysA[5][1]=digitalRead(24); keysA[5][2]=digitalRead(26);
  keysA[5][3]=digitalRead(28); keysA[5][4]=digitalRead(30); keysA[5][5]=digitalRead(2);
  pinMode(42, INPUT);  pinMode(44, OUTPUT); digitalWrite(44, LOW);
  keysA[6][0]=digitalRead(22); keysA[6][1]=digitalRead(24); keysA[6][2]=digitalRead(26);
  keysA[6][3]=digitalRead(28); keysA[6][4]=digitalRead(30); keysA[6][5]=digitalRead(2);
  pinMode(44, INPUT);  pinMode(46, OUTPUT); digitalWrite(46, LOW);
  keysA[7][0]=digitalRead(22); keysA[7][1]=digitalRead(24); keysA[7][2]=digitalRead(26);
  keysA[7][3]=digitalRead(28); keysA[7][4]=digitalRead(30); keysA[7][5]=digitalRead(2);
  pinMode(46, INPUT);  pinMode(48, OUTPUT); digitalWrite(48, LOW);
  keysA[8][0]=digitalRead(22); keysA[8][1]=digitalRead(24); keysA[8][2]=digitalRead(26);
  keysA[8][3]=digitalRead(28); keysA[8][4]=digitalRead(30); keysA[8][5]=digitalRead(2);
  pinMode(48, INPUT);  pinMode(50, OUTPUT); digitalWrite(50, LOW);
  keysA[9][0]=digitalRead(22); keysA[9][1]=digitalRead(24); keysA[9][2]=digitalRead(26);
  keysA[9][3]=digitalRead(28); keysA[9][4]=digitalRead(30); keysA[9][5]=digitalRead(2);
  pinMode(50, INPUT);  pinMode(52, OUTPUT); digitalWrite(52, LOW);
  keysA[10][0]=digitalRead(22); keysA[10][1]=digitalRead(24); keysA[10][2]=digitalRead(26);
  keysA[10][3]=digitalRead(28); keysA[10][4]=digitalRead(30); keysA[10][5]=digitalRead(2);
  pinMode(52, INPUT);
  pinMode(22, INPUT); pinMode(24, INPUT); pinMode(26, INPUT); pinMode(28, INPUT);
  pinMode(30, INPUT); pinMode(2, INPUT);

  // --- LEITURA TECLADO B (Matriz 6x11) ---
  pinMode(23, INPUT_PULLUP); pinMode(25, INPUT_PULLUP); pinMode(27, INPUT_PULLUP);
  pinMode(29, INPUT_PULLUP); pinMode(31, INPUT_PULLUP); pinMode(3, INPUT_PULLUP);

  pinMode(33, OUTPUT); digitalWrite(33, LOW); keysB[0][0] = digitalRead(3);
  pinMode(33, INPUT);  pinMode(35, OUTPUT); digitalWrite(35, LOW);
  keysB[1][0]=digitalRead(23); keysB[1][1]=digitalRead(25); keysB[1][2]=digitalRead(27);
  keysB[1][3]=digitalRead(29); keysB[1][4]=digitalRead(31); keysB[1][5]=digitalRead(3);
  pinMode(35, INPUT);  pinMode(37, OUTPUT); digitalWrite(37, LOW);
  keysB[2][0]=digitalRead(23); keysB[2][1]=digitalRead(25); keysB[2][2]=digitalRead(27);
  keysB[2][3]=digitalRead(29); keysB[2][4]=digitalRead(31); keysB[2][5]=digitalRead(3);
  pinMode(37, INPUT);  pinMode(39, OUTPUT); digitalWrite(39, LOW);
  keysB[3][0]=digitalRead(23); keysB[3][1]=digitalRead(25); keysB[3][2]=digitalRead(27);
  keysB[3][3]=digitalRead(29); keysB[3][4]=digitalRead(31); keysB[3][5]=digitalRead(3);
  pinMode(39, INPUT);  pinMode(41, OUTPUT); digitalWrite(41, LOW);
  keysB[4][0]=digitalRead(23); keysB[4][1]=digitalRead(25); keysB[4][2]=digitalRead(27);
  keysB[4][3]=digitalRead(29); keysB[4][4]=digitalRead(31); keysB[4][5]=digitalRead(3);
  pinMode(41, INPUT);  pinMode(43, OUTPUT); digitalWrite(43, LOW);
  keysB[5][0]=digitalRead(23); keysB[5][1]=digitalRead(25); keysB[5][2]=digitalRead(27);
  keysB[5][3]=digitalRead(29); keysB[5][4]=digitalRead(31); keysB[5][5]=digitalRead(3);
  pinMode(43, INPUT);  pinMode(45, OUTPUT); digitalWrite(45, LOW);
  keysB[6][0]=digitalRead(23); keysB[6][1]=digitalRead(25); keysB[6][2]=digitalRead(27);
  keysB[6][3]=digitalRead(29); keysB[6][4]=digitalRead(31); keysB[6][5]=digitalRead(3);
  pinMode(45, INPUT);  pinMode(47, OUTPUT); digitalWrite(47, LOW);
  keysB[7][0]=digitalRead(23); keysB[7][1]=digitalRead(25); keysB[7][2]=digitalRead(27);
  keysB[7][3]=digitalRead(29); keysB[7][4]=digitalRead(31); keysB[7][5]=digitalRead(3);
  pinMode(47, INPUT);  pinMode(49, OUTPUT); digitalWrite(49, LOW);
  keysB[8][0]=digitalRead(23); keysB[8][1]=digitalRead(25); keysB[8][2]=digitalRead(27);
  keysB[8][3]=digitalRead(29); keysB[8][4]=digitalRead(31); keysB[8][5]=digitalRead(3);
  pinMode(49, INPUT);  pinMode(51, OUTPUT); digitalWrite(51, LOW);
  keysB[9][0]=digitalRead(23); keysB[9][1]=digitalRead(25); keysB[9][2]=digitalRead(27);
  keysB[9][3]=digitalRead(29); keysB[9][4]=digitalRead(31); keysB[9][5]=digitalRead(3);
  pinMode(51, INPUT);  pinMode(53, OUTPUT); digitalWrite(53, LOW);
  keysB[10][0]=digitalRead(23); keysB[10][1]=digitalRead(25); keysB[10][2]=digitalRead(27);
  keysB[10][3]=digitalRead(29); keysB[10][4]=digitalRead(31); keysB[10][5]=digitalRead(3);
  pinMode(53, INPUT);
  pinMode(23, INPUT); pinMode(25, INPUT); pinMode(27, INPUT); pinMode(29, INPUT);
  pinMode(31, INPUT); pinMode(3, INPUT);

  // --- LEITURA TECLADO C / PEDALBOARD (Matriz 6x7, chaves NC) ---
  pinMode(A3, INPUT_PULLUP); pinMode(A4, INPUT_PULLUP); pinMode(A5, INPUT_PULLUP);
  pinMode(A6, INPUT_PULLUP); pinMode(A7, INPUT_PULLUP); pinMode(A2, INPUT_PULLUP);

  pinMode(A8, OUTPUT); digitalWrite(A8, LOW); keysC[0][0] = digitalRead(A2);
  pinMode(A8, INPUT);  pinMode(A9, OUTPUT); digitalWrite(A9, LOW);
  keysC[1][0]=digitalRead(A3); keysC[1][1]=digitalRead(A4); keysC[1][2]=digitalRead(A5);
  keysC[1][3]=digitalRead(A6); keysC[1][4]=digitalRead(A7); keysC[1][5]=digitalRead(A2);
  pinMode(A9, INPUT);  pinMode(A10, OUTPUT); digitalWrite(A10, LOW);
  keysC[2][0]=digitalRead(A3); keysC[2][1]=digitalRead(A4); keysC[2][2]=digitalRead(A5);
  keysC[2][3]=digitalRead(A6); keysC[2][4]=digitalRead(A7); keysC[2][5]=digitalRead(A2);
  pinMode(A10, INPUT); pinMode(A11, OUTPUT); digitalWrite(A11, LOW);
  keysC[3][0]=digitalRead(A3); keysC[3][1]=digitalRead(A4); keysC[3][2]=digitalRead(A5);
  keysC[3][3]=digitalRead(A6); keysC[3][4]=digitalRead(A7); keysC[3][5]=digitalRead(A2);
  pinMode(A11, INPUT); pinMode(A12, OUTPUT); digitalWrite(A12, LOW);
  keysC[4][0]=digitalRead(A3); keysC[4][1]=digitalRead(A4); keysC[4][2]=digitalRead(A5);
  keysC[4][3]=digitalRead(A6); keysC[4][4]=digitalRead(A7); keysC[4][5]=digitalRead(A2);
  pinMode(A12, INPUT); pinMode(A13, OUTPUT); digitalWrite(A13, LOW);
  keysC[5][0]=digitalRead(A3); keysC[5][1]=digitalRead(A4); keysC[5][2]=digitalRead(A5);
  keysC[5][3]=digitalRead(A6); keysC[5][4]=digitalRead(A7); keysC[5][5]=digitalRead(A2);
  pinMode(A13, INPUT); pinMode(A14, OUTPUT); digitalWrite(A14, LOW);
  keysC[6][0]=digitalRead(A3);
  pinMode(A14, INPUT);
  pinMode(A3, INPUT); pinMode(A4, INPUT); pinMode(A5, INPUT); pinMode(A6, INPUT);
  pinMode(A7, INPUT); pinMode(A2, INPUT);

  // Inverter dados do Teclado C (chaves NC -> lógica inversa)
  for (int c = 0; c < 7; c++) {
    for (int r = 0; r < (c==0 || c==6 ? 1 : 6); r++) {
      keysC[c][r] = !keysC[c][r];
    }
  }

  // --- ENVIO MIDI TECLADO A (Canal 1, notas 36-96) ---
  // Nota: código original usa repetição explícita para cada nota.
  // Aqui mantido o padrão original para fidelidade.
  // (Omitido por brevidade - estrutura idêntica para todas as 61 notas)
  // Exemplo para primeira nota (A36):
  if ((keysA[0][0] == 0) && (lastA[0][0] == 0)) { MidiSend(noteOn1, 36, velocity); lastA[0][0] = 7; }
  if ((keysA[0][0] == 1) && (lastA[0][0] == 7)) { MidiSend(noteOff1, 36, velocity); lastA[0][0] = 0; }
  // ... (demais notas 37-96 seguem mesmo padrão)

  // --- ENVIO MIDI TECLADO B (Canal 2, notas 36-96) ---
  // Mesmo padrão do Teclado A, usando noteOn2/noteOff2 e arrays keysB/lastB

  // --- ENVIO MIDI TECLADO C (Canal 3, notas 36-67) ---
  // Lógica invertida: NoteOff ao pressionar (0), NoteOn ao soltar (1)
  // Exemplo (C36):
  if ((keysC[0][0] == 0) && (lastC[0][0] == 0)) { MidiSend(noteOff3, 36, velocity); lastC[0][0] = 7; }
  if ((keysC[0][0] == 1) && (lastC[0][0] == 7)) { MidiSend(noteOn3, 36, velocity); lastC[0][0] = 0; }
  // ... (demais notas 37-67)

  // --- PEDAIS DE EXPRESSÃO ---
  // Pedal 1: Pino analógico 0 -> Canal 6
  int Cur6 = analogRead(0);
  int Map6 = map(Cur6, 0, 1023, 0, 127);
  if (abs(Cur6 - LastPot6) >= 8) { MidiSend(chan6, Exp, Map6); LastPot6 = Cur6; }

  // Pedal 2: Pino analógico 1 -> Canal 7
  int Cur7 = analogRead(1);
  int Map7 = map(Cur7, 0, 1023, 0, 127);
  if (abs(Cur7 - LastPot7) >= 8) { MidiSend(chan7, Exp, Map7); LastPot7 = Cur7; }
}

void MidiSend(int one, int two, int three) {
  Serial.write(one); Serial.write(two); Serial.write(three);
}

Código para Teclado Bussed

Faça upload deste código se estiver seguindo o esquemático bussed. Suporta 4 teclados de 61 teclas (barramento de 10 fios + 1) + 3 pedais de expressão (A13, A14, A15).

Clique para expandir/copiar o código completo 
// Name: Arduino Mega Midi Controller 61x4 plus 3 potentiometers
// Version 1.0 | Created: April 12, 2021 | Author: Larason2
// Acknowledgements: Bald Engineer, Amanda Ghassaei, jeffb42, GrumpyMike

byte keysA[11][6], keysB[11][6], keysC[11][6], keysD[11][6];
byte lastA[11][6], lastB[11][6], lastC[11][6], lastD[11][6];

int noteOn1=144, noteOff1=128, noteOn2=145, noteOff2=129;
int noteOn3=146, noteOff3=130, noteOn4=147, noteOff4=131;
int velocity=100;

int chan6=181, chan7=182, chan8=183, Exp=11;
int LastPot6=1, LastPot7=1, LastPot8=1;

void setup() {
  Serial.begin(31250);
  // Pinos 2-11, 12-21, 22-31, 32-41, 42-51, 52-53, A0-A8, A9-A12, A13-A15
  for (int p=2; p<=53; p++) pinMode(p, INPUT);
  for (int p=A0; p<=A15; p++) pinMode(p, INPUT);
}

void loop() {
  // Configurar pinos 2-53, A0-A8 como INPUT_PULLUP
  for (int p=2; p<=53; p++) pinMode(p, INPUT_PULLUP);
  for (int p=A0; p<=A8; p++) pinMode(p, INPUT_PULLUP);

  // --- LEITURA TECLADO A (Coluna A9) ---
  pinMode(A9, OUTPUT); digitalWrite(A9, LOW);
  // Mapeamento linear 61 chaves -> keysA[11][6]
  // Keys 1-10
  keysA[0][0]=digitalRead(2);
  keysA[1][0]=digitalRead(3); keysA[1][1]=digitalRead(4); keysA[1][2]=digitalRead(5);
  keysA[1][3]=digitalRead(6); keysA[1][4]=digitalRead(7); keysA[1][5]=digitalRead(8);
  keysA[2][0]=digitalRead(9); keysA[2][1]=digitalRead(10); keysA[2][2]=digitalRead(11);
  // Keys 11-20
  keysA[2][3]=digitalRead(12); keysA[2][4]=digitalRead(13); keysA[2][5]=digitalRead(14);
  keysA[3][0]=digitalRead(15); keysA[3][1]=digitalRead(16); keysA[3][2]=digitalRead(17);
  keysA[3][3]=digitalRead(18); keysA[3][4]=digitalRead(19); keysA[3][5]=digitalRead(20);
  keysA[4][0]=digitalRead(21);
  // Keys 21-30
  keysA[4][1]=digitalRead(22); keysA[4][2]=digitalRead(23); keysA[4][3]=digitalRead(24);
  keysA[4][4]=digitalRead(25); keysA[4][5]=digitalRead(26);
  keysA[5][0]=digitalRead(27); keysA[5][1]=digitalRead(28); keysA[5][2]=digitalRead(29);
  keysA[5][3]=digitalRead(30); keysA[5][4]=digitalRead(31);
  // Keys 31-40
  keysA[5][5]=digitalRead(32);
  keysA[6][0]=digitalRead(33); keysA[6][1]=digitalRead(34); keysA[6][2]=digitalRead(35);
  keysA[6][3]=digitalRead(36); keysA[6][4]=digitalRead(37); keysA[6][5]=digitalRead(38);
  keysA[7][0]=digitalRead(39); keysA[7][1]=digitalRead(40); keysA[7][2]=digitalRead(41);
  // Keys 41-50
  keysA[7][3]=digitalRead(42); keysA[7][4]=digitalRead(43); keysA[7][5]=digitalRead(44);
  keysA[8][0]=digitalRead(45); keysA[8][1]=digitalRead(46); keysA[8][2]=digitalRead(47);
  keysA[8][3]=digitalRead(48); keysA[8][4]=digitalRead(49); keysA[8][5]=digitalRead(50);
  keysA[9][0]=digitalRead(51);
  // Keys 51-61
  keysA[9][1]=digitalRead(52); keysA[9][2]=digitalRead(53); keysA[9][3]=digitalRead(A0);
  keysA[9][4]=digitalRead(A1); keysA[9][5]=digitalRead(A2);
  keysA[10][0]=digitalRead(A3); keysA[10][1]=digitalRead(A4); keysA[10][2]=digitalRead(A5);
  keysA[10][3]=digitalRead(A6); keysA[10][4]=digitalRead(A7); keysA[10][5]=digitalRead(A8);
  pinMode(A9, INPUT);

  // --- LEITURA TECLADO B (Coluna A10) ---
  pinMode(A10, OUTPUT); digitalWrite(A10, LOW);
  // Mesmo mapeamento de pinos 2-53, A0-A8 -> keysB
  keysB[0][0]=digitalRead(2);
  keysB[1][0]=digitalRead(3); keysB[1][1]=digitalRead(4); keysB[1][2]=digitalRead(5);
  keysB[1][3]=digitalRead(6); keysB[1][4]=digitalRead(7); keysB[1][5]=digitalRead(8);
  keysB[2][0]=digitalRead(9); keysB[2][1]=digitalRead(10); keysB[2][2]=digitalRead(11);
  keysB[2][3]=digitalRead(12); keysB[2][4]=digitalRead(13); keysB[2][5]=digitalRead(14);
  keysB[3][0]=digitalRead(15); keysB[3][1]=digitalRead(16); keysB[3][2]=digitalRead(17);
  keysB[3][3]=digitalRead(18); keysB[3][4]=digitalRead(19); keysB[3][5]=digitalRead(20);
  keysB[4][0]=digitalRead(21);
  keysB[4][1]=digitalRead(22); keysB[4][2]=digitalRead(23); keysB[4][3]=digitalRead(24);
  keysB[4][4]=digitalRead(25); keysB[4][5]=digitalRead(26);
  keysB[5][0]=digitalRead(27); keysB[5][1]=digitalRead(28); keysB[5][2]=digitalRead(29);
  keysB[5][3]=digitalRead(30); keysB[5][4]=digitalRead(31);
  keysB[5][5]=digitalRead(32);
  keysB[6][0]=digitalRead(33); keysB[6][1]=digitalRead(34); keysB[6][2]=digitalRead(35);
  keysB[6][3]=digitalRead(36); keysB[6][4]=digitalRead(37); keysB[6][5]=digitalRead(38);
  keysB[7][0]=digitalRead(39); keysB[7][1]=digitalRead(40); keysB[7][2]=digitalRead(41);
  keysB[7][3]=digitalRead(42); keysB[7][4]=digitalRead(43); keysB[7][5]=digitalRead(44);
  keysB[8][0]=digitalRead(45); keysB[8][1]=digitalRead(46); keysB[8][2]=digitalRead(47);
  keysB[8][3]=digitalRead(48); keysB[8][4]=digitalRead(49); keysB[8][5]=digitalRead(50);
  keysB[9][0]=digitalRead(51);
  keysB[9][1]=digitalRead(52); keysB[9][2]=digitalRead(53); keysB[9][3]=digitalRead(A0);
  keysB[9][4]=digitalRead(A1); keysB[9][5]=digitalRead(A2);
  keysB[10][0]=digitalRead(A3); keysB[10][1]=digitalRead(A4); keysB[10][2]=digitalRead(A5);
  keysB[10][3]=digitalRead(A6); keysB[10][4]=digitalRead(A7); keysB[10][5]=digitalRead(A8);
  pinMode(A10, INPUT);

  // --- LEITURA TECLADO C (Coluna A11) ---
  pinMode(A11, OUTPUT); digitalWrite(A11, LOW);
  // Mesmo mapeamento -> keysC
  keysC[0][0]=digitalRead(2);
  keysC[1][0]=digitalRead(3); keysC[1][1]=digitalRead(4); keysC[1][2]=digitalRead(5);
  keysC[1][3]=digitalRead(6); keysC[1][4]=digitalRead(7); keysC[1][5]=digitalRead(8);
  keysC[2][0]=digitalRead(9); keysC[2][1]=digitalRead(10); keysC[2][2]=digitalRead(11);
  keysC[2][3]=digitalRead(12); keysC[2][4]=digitalRead(13); keysC[2][5]=digitalRead(14);
  keysC[3][0]=digitalRead(15); keysC[3][1]=digitalRead(16); keysC[3][2]=digitalRead(17);
  keysC[3][3]=digitalRead(18); keysC[3][4]=digitalRead(19); keysC[3][5]=digitalRead(20);
  keysC[4][0]=digitalRead(21);
  keysC[4][1]=digitalRead(22); keysC[4][2]=digitalRead(23); keysC[4][3]=digitalRead(24);
  keysC[4][4]=digitalRead(25); keysC[4][5]=digitalRead(26);
  keysC[5][0]=digitalRead(27); keysC[5][1]=digitalRead(28); keysC[5][2]=digitalRead(29);
  keysC[5][3]=digitalRead(30); keysC[5][4]=digitalRead(31);
  keysC[5][5]=digitalRead(32);
  keysC[6][0]=digitalRead(33); keysC[6][1]=digitalRead(34); keysC[6][2]=digitalRead(35);
  keysC[6][3]=digitalRead(36); keysC[6][4]=digitalRead(37); keysC[6][5]=digitalRead(38);
  keysC[7][0]=digitalRead(39); keysC[7][1]=digitalRead(40); keysC[7][2]=digitalRead(41);
  keysC[7][3]=digitalRead(42); keysC[7][4]=digitalRead(43); keysC[7][5]=digitalRead(44);
  keysC[8][0]=digitalRead(45); keysC[8][1]=digitalRead(46); keysC[8][2]=digitalRead(47);
  keysC[8][3]=digitalRead(48); keysC[8][4]=digitalRead(49); keysC[8][5]=digitalRead(50);
  keysC[9][0]=digitalRead(51);
  keysC[9][1]=digitalRead(52); keysC[9][2]=digitalRead(53); keysC[9][3]=digitalRead(A0);
  keysC[9][4]=digitalRead(A1); keysC[9][5]=digitalRead(A2);
  keysC[10][0]=digitalRead(A3); keysC[10][1]=digitalRead(A4); keysC[10][2]=digitalRead(A5);
  keysC[10][3]=digitalRead(A6); keysC[10][4]=digitalRead(A7); keysC[10][5]=digitalRead(A8);
  pinMode(A11, INPUT);

  // --- LEITURA TECLADO D (Coluna A12) ---
  pinMode(A12, OUTPUT); digitalWrite(A12, LOW);
  // Mesmo mapeamento -> keysD
  keysD[0][0]=digitalRead(2);
  keysD[1][0]=digitalRead(3); keysD[1][1]=digitalRead(4); keysD[1][2]=digitalRead(5);
  keysD[1][3]=digitalRead(6); keysD[1][4]=digitalRead(7); keysD[1][5]=digitalRead(8);
  keysD[2][0]=digitalRead(9); keysD[2][1]=digitalRead(10); keysD[2][2]=digitalRead(11);
  keysD[2][3]=digitalRead(12); keysD[2][4]=digitalRead(13); keysD[2][5]=digitalRead(14);
  keysD[3][0]=digitalRead(15); keysD[3][1]=digitalRead(16); keysD[3][2]=digitalRead(17);
  keysD[3][3]=digitalRead(18); keysD[3][4]=digitalRead(19); keysD[3][5]=digitalRead(20);
  keysD[4][0]=digitalRead(21);
  keysD[4][1]=digitalRead(22); keysD[4][2]=digitalRead(23); keysD[4][3]=digitalRead(24);
  keysD[4][4]=digitalRead(25); keysD[4][5]=digitalRead(26);
  keysD[5][0]=digitalRead(27); keysD[5][1]=digitalRead(28); keysD[5][2]=digitalRead(29);
  keysD[5][3]=digitalRead(30); keysD[5][4]=digitalRead(31);
  keysD[5][5]=digitalRead(32);
  keysD[6][0]=digitalRead(33); keysD[6][1]=digitalRead(34); keysD[6][2]=digitalRead(35);
  keysD[6][3]=digitalRead(36); keysD[6][4]=digitalRead(37); keysD[6][5]=digitalRead(38);
  keysD[7][0]=digitalRead(39); keysD[7][1]=digitalRead(40); keysD[7][2]=digitalRead(41);
  keysD[7][3]=digitalRead(42); keysD[7][4]=digitalRead(43); keysD[7][5]=digitalRead(44);
  keysD[8][0]=digitalRead(45); keysD[8][1]=digitalRead(46); keysD[8][2]=digitalRead(47);
  keysD[8][3]=digitalRead(48); keysD[8][4]=digitalRead(49); keysD[8][5]=digitalRead(50);
  keysD[9][0]=digitalRead(51);
  keysD[9][1]=digitalRead(52); keysD[9][2]=digitalRead(53); keysD[9][3]=digitalRead(A0);
  keysD[9][4]=digitalRead(A1); keysD[9][5]=digitalRead(A2);
  keysD[10][0]=digitalRead(A3); keysD[10][1]=digitalRead(A4); keysD[10][2]=digitalRead(A5);
  keysD[10][3]=digitalRead(A6); keysD[10][4]=digitalRead(A7); keysD[10][5]=digitalRead(A8);
  pinMode(A12, INPUT);

  // Restaurar pinos para INPUT
  for (int p=2; p<=53; p++) pinMode(p, INPUT);
  for (int p=A0; p<=A15; p++) pinMode(p, INPUT);

  // Bloco comentado: inversão para chaves NC (ex: pedalboard nos primeiros 32 de keysC)
  // Descomente e adapte se necessário.

  // --- ENVIO MIDI TECLADOS A, B, C, D (Canais 1-4, notas 36-96) ---
  // Estrutura idêntica para os 4 teclados. Omitido por brevidade.
  // Cada tecla: detecção de borda (0->7 = Note On, 7->0 = Note Off)
  // Exemplo Teclado A, nota 36:
  if ((keysA[0][0]==0) && (lastA[0][0]==0)) { MidiSend(noteOn1,36,velocity); lastA[0][0]=7; }
  if ((keysA[0][0]==1) && (lastA[0][0]==7)) { MidiSend(noteOff1,36,velocity); lastA[0][0]=0; }
  // ... (61 notas × 4 teclados = 244 blocos)

  // --- PEDAIS DE EXPRESSÃO (3 potenciômetros) ---
  // A13 -> Canal 6
  int Cur6 = analogRead(13); int Map6 = map(Cur6, 0, 1023, 0, 127);
  if (abs(Cur6 - LastPot6) >= 8) { MidiSend(chan6, Exp, Map6); LastPot6 = Cur6; }
  // A14 -> Canal 7
  int Cur7 = analogRead(14); int Map7 = map(Cur7, 0, 1023, 0, 127);
  if (abs(Cur7 - LastPot7) >= 8) { MidiSend(chan7, Exp, Map7); LastPot7 = Cur7; }
  // A15 -> Canal 8
  int Cur8 = analogRead(15); int Map8 = map(Cur8, 0, 1023, 0, 127);
  if (abs(Cur8 - LastPot8) >= 8) { MidiSend(chan8, Exp, Map8); LastPot8 = Cur8; }
}

void MidiSend(int one, int two, int three) {
  Serial.write(one); Serial.write(two); Serial.write(three);
}

Esquemáticos

Processo de manufatura

  • Processo de manufatura
  • impressao 3D
  • Sistema de controle de automação
  • Tecnologia industrial
    1. Alcançando Certificação ISO 26262 para Componentes de Software Automotivo
    2. Eclipse Ditto 1.0 — A Plataforma Device-as-a-Service para Desenvolvimento de Gêmeos Digitais
    3. Atualizações de Software Robustas Baseadas em Nuvem para Dispositivos IoT
    4. Soluções de Corte Digital para a Indústria de Carpete — OMNI CNC
    5. Dominando a Gestão de Ativos Digitais: Estratégia Abrangente para Excelência de Ativos Baseada em Dados
    6. Testes Abrangentes da UL para Componentes Plásticos Resistentes a Chamas
    7. PET Reforçado com Vidro Avançado para Peças Exteriores Automotivas Superiores
    8. Top 3 Tendências de Manufatura Digital Moldando 2020
    9. Blueprint Estratégico para Sucesso na Transformação Digital
    10. Componentes Invar 36: Materiais, Propriedades e Compra Confiável