Integración MIDI para Órganos Digitales: Componentes y Guía de Configuración

Componentes y materiales

Arduino Mega 2560	×	1
Conector DIN MIDI	×	1
Resistencia 220 Ω	×	1
Cable USB-A a B	×	1
Cable AWM	×	1
Header macho 40 posiciones 1 fila (0.1")	×	1
Potenciómetro deslizante 10K lineal	×	1
Socket IDC (opcional)	×	1
Cables jumper macho/macho (opcional)	×	1

Herramientas y máquinas necesarias

• Soldador (genérico)
• Estaño para soldar, libre de plomo
• Flux para soldar
• Pelacables, alicate de punta serrada
• Alicate de corte lateral
• Alicate de punta plana

Aplicaciones y servicios online

• Arduino IDE

Sobre este proyecto

Este proyecto muestra cómo convertir una consola de órgano antigua para que pueda enviar mensajes MIDI de hardware desde los teclados (manuales) y pedalera usando un solo Arduino Mega.

El proyecto comenzó como un intento de enviar mensajes MIDI manteniendo la generación de sonido original intacta, pero los circuitos originales resultaron difíciles de ingeniería inversa. Tras dedicar tiempo al código, desarrollé código para ambos tipos de manuales: tipo bus y tipo matriz.

Paso 1: Examinar el órgano

• Mi primer código asumía que el órgano a modificar ya tiene teclado matricial con interruptores discretos y diodos ya instalados. Desde entonces, también desarrollé código para diseños de teclado tipo bus. Sigue las instrucciones y usa el código para la versión que aplique (Matriz vs. Bus). Para ambos diseños necesitarás diodos en cada interruptor, que se consiguen baratos. Sin embargo, el código subido al Arduino Mega es diferente para matriz vs. bus.
• El órgano modificado en este ejemplo tiene interruptores normalmente abiertos (NO) para teclados y normalmente cerrados (NC) para la pedalera. Con un multímetro, puedes verificar qué tipo de interruptores tiene tu órgano. Si el tipo difiere, deberás modificar el código (ejemplos en el código).
• Averigua cómo abrir el órgano para acceder a contactos de teclados y pedalera, y busca un lugar adecuado para montar el Arduino dentro. Puede que necesites taladrar agujeros o instalar conectores para alimentar el Arduino y montar el conector MIDI. En este ejemplo, se cableó un enchufe de 3 patas a una pequeña caja de alimentación dentro del órgano para alimentar el Arduino, y se taladró un agujero para montar el conector DIN MIDI.
• El órgano de ejemplo tenía dos teclados con matrices 6x11 y una pedalera con matriz 6x7. Si vas por la ruta matricial y tu órgano ya tiene matriz 8x8, o bien se modifica código y cableado para 8x8, o se recablea la matriz original para soportar 6x11.

Paso 2: Montar el Arduino

Mi Arduino Mega venía con una pequeña placa plástica para montarlo en la madera del órgano. Lo fijé con tornillos de madera #4 y tornillos máquina #4 para unir el Arduino a la placa. Es buena idea colocar primero el Arduino para estimar la longitud de cada cable. En este punto, también busca cómo alimentar el Arduino.

Paso 3: Preparar cables

Teclado matricial:

Cada teclado tiene 61 interruptores. En el ejemplo, cada teclado tenía 6 filas, con un cable yendo del primer terminal de cada interruptor al primer terminal de cada otro interruptor a 6 de distancia. El segundo terminal del interruptor iba a un diodo, luego a las columnas, divididas en 11 columnas para manuales y 7 para pedalera. Para cada manual y pedalera, se necesitan dos longitudes de cable AWM que lleguen de cada división al Arduino, siguiendo un camino ordenado y dejando siempre más margen del necesario. Para las columnas, es preferible que el cable recorra la longitud del teclado o pedalera antes de ir al Arduino. Mide cada longitud, corta a medida. Con alicates pequeños, separa los hilos individuales en los extremos, y pela el aislamiento con pelacables.

Teclado tipo bus:

El teclado puede dividirse en 6 cables AWM, con un cable ordinario para el interruptor 61. Separa los hilos individuales en los extremos, luego pela el aislamiento con pelacables.

Paso 4: Soldar extremos de cables a headers macho

Tanto teclados matriciales como tipo bus: Solda los extremos de cable apropiados a los pines del header macho, o si usas la placa de terminales de tornillo, conecta los cables apropiados a los bornes de tornillo.

Paso 5: Soldar el otro extremo del cable a los interruptores

Teclado matricial:

Si el órgano ya tiene cada contacto cableado, tendrás que desoldar o cortar los cables originales para que este proyecto funcione. Si el órgano tiene matriz 6x11, tiene sentido conservar los cables de fila que van de cada interruptor al siguiente a 6 arriba. Así, retira los cables de fila que van del primer grupo de seis al ordenador original, y suelda los 6 cables de fila a la posición donde estaban los otros 6. Para las columnas, si ya tienen diodos, corta o desuelda el cable que va del otro extremo de los diodos al ordenador original, luego suelda el cable de columna que va a tu Arduino en su lugar. Con bridas plásticas, organiza los cables para que corran ordenadamente junto a los otros cables del órgano. Para la pedalera del órgano de la foto, el panel frontal con los interruptores reed hubo de quitarse retirando los tornillos, y los cables se pasaron por el pequeño agujero central del panel frontal.

Teclado tipo bus:

En el código para teclado bus, es necesario soldar un diodo al lado no bus de cada interruptor, luego soldar esto a uno de los 10 hilos del cable, y repetir para cada uno de los 6 cables, y repetir para el último hilo (#61).

Paso 6: Soldar la resistencia al conector MIDI, y los otros cables al Arduino

Paso 7: Conectar headers al Arduino

• Conecta todos los headers al Arduino como se muestra en el esquemático.
• Una alternativa a soldar cables a headers macho es comprar sockets IDC de 10 pines, conectarlos a los extremos de cables AWM, y usar jumpers macho/macho para conectar al Arduino. Esta solución no es tan permanente como soldar, pero es aconsejable si piensas modificar el código publicado, por si hay que recablear.

Paso 8: Subir software al Arduino

• Conecta cable USB del Arduino al ordenador, asegúrate de tener Arduino IDE instalado. Selecciona la versión de código que aplique (Matriz vs. Bus). Ejecuta Arduino IDE, copia y pega el código proporcionado en un nuevo sketch en blanco. Asegúrate que el Arduino está conectado vía USB serial, y clic en "Subir" en la parte superior del sketch.

Paso 9: Probar

• Si no está hecho, conecta tu adaptador MIDI al ordenador, y conecta la salida MIDI del órgano al adaptador MIDI.
• Usa software para monitorizar señales MIDI, verifica que cada tecla y pedal envía el mensaje MIDI apropiado al presionar y soltar cada tecla.
• Si planeas usarlo sin estar conectado al ordenador, puedes conectar una pequeña fuente 5V al puerto de alimentación del Arduino, o un enchufe USB de pared al final del cable USB usado, y enchufarlo a la pared para alimentar el Arduino.

Notas adicionales

• El código para teclados bus no ha sido probado aún, pero se espera que funcione. Por favor, comenta si has probado el código bus y encontraste algún problema.
• Para la versión bus, los diodos son necesarios. Al soldar diodos en los interruptores, es importante soldar el diodo con el polo negativo hacia el interruptor. Para diseño matricial, el polo negativo del diodo debe estar lejos del interruptor.
• Además de añadir el diseño bus, también actualicé el diseño y código original para incluir potenciómetros, como los usados en pedales de expresión.
• Para que el diseño bus funcione correctamente en el pin 13, es necesario deshabilitar el LED integrado del Arduino. Para ello, o bien lo quitas con dos soldadores, o usas alicates de punta fina para aplastarlo cuidadosamente.
• Aunque el diseño bus funciona para muchos órganos con teclado bus, puede no ser fiable si el bus es de material "bronce fosforoso". Cablear todos los buses de un manual juntos, y todos los contactos de una tecla juntos ayuda a prevenir contactos intermitentes, pero para barras de bus de bronce fosforoso, se recomienda usar keying de 12V (lo que este proyecto no puede hacer).

Hardware para pedal de expresión con potenciómetros

En el futuro espero añadir más detalles, pero explicaré brevemente el diseño visto arriba. La conexión al pedal de expresión es un soporte en "L" barato de ferretería. Se conecta a un soporte existente aquí, pero un segundo soporte en "L" unido directamente al pedal también sirve. Articula sobre un tornillo máquina mantenido ligeramente suelto con contratuerca y dos arandelas. En la foto usé un tornillo muy largo, pero no es necesario, era lo que tenía. Para la varilla metálica, usé "JB Weld" para unir un tornillo de ojo a un extremo, y un tornillo máquina apropiado para unirlo al soporte en "L" en el otro extremo.

Para el soporte del potenciómetro, compré láminas de acrílico transparente, las marqué con cúter, luego las rompí a lo largo de la línea con alicates y tornillos de banco. Para fijar el potenciómetro, hice una pieza pequeña de acrílico para elevarlo de la grande, lijé la superficie de la pieza pequeña, la del potenciómetro a montar, y la de la pieza grande a la que todo se uniría, apliqué JB Weld, y usé una pequeña abrazadera para mantener todo junto hasta que el JB Weld secó. Los agujeros en las piezas de acrílico se taladraron con taladro eléctrico y brocas estándar.

La base de la pieza grande de acrílico se fija a una pequeña bisagra de mueble con tornillos máquina #4, y el otro extremo de la bisagra se une a la base del órgano con tornillos de madera #4 cortos. Hice un soporte de acrílico para separar la bisagra del suelo, pero según el diseño de la bisagra, puede no ser necesario.

El bloque blanco por donde desliza la varilla es un bloque PFTE comprado a un proveedor de piezas de robots. La pieza se cortó de la mayor con sierra de calar, y los tres agujeros se taladraron con taladro eléctrico y brocas de diferentes tamaños. El bloque PFTE se fijó al soporte de acrílico con tornillos máquina.

Instrucciones detalladas para soporte de pedal de expresión (Actualizado 9 Dic 2021)

Materiales:

• Lámina acrílico 8x10 pulgadas
• Bloque Teflon
• Varilla aluminio (1/4 pulgada, ferretería local)
• JB Weld
• Potenciómetro lineal
• Bisagra pequeña de mueble
• Escuadra pequeña de mueble
• Tornillo de ojo pequeño
• Tornillos madera #4 cortos
• Herrajes surtidos: arandela de seguridad x1 (preferible teflón) y tornillo máquina a juego para fijar al pedal (diámetro y longitud según pedal actual); tornillos máquina x2, arandelas x4 y tuercas x2 para fijar teflón a acrílico; tornillo máquina para fijar escuadra a varilla 1/4 aluminio; tornillos máquina x2, arandelas x4 y tuercas x2 para fijar bisagra a base de acrílico.

Herramientas:

• Cúter
• Regla
• Destornillador joyero/normal
• Llave inglesa ajustable
• Alicates
• Taladro eléctrico y brocas
• Sierra de calar
• Tornillo de banco
• Abrazadera pequeña de madera
• Papel de lija grano fino
• Palitos de helado y cartón reciclado
• Paño húmedo

Instrucciones:

1. Examina pedal actual. Si hay agujero libre en soporte de montaje, úsalo; si no, usa uno existente y consigue tornillo máquina más largo que el actual pero que quepa.
2. Asegúrate que la base de madera del órgano está libre de componentes/electrónica, muévelos si es necesario.
3. Desenvuelve lámina acrílico, y con regla y cúter, marca por ambos lados un rectángulo 3"x4.5", luego rompe a lo largo de las marcas con tornillo de banco y alicates (¡usa protección ocular!). También corta pieza 3"x0.5" y 2.4"x0.3".
4. Corta bloque teflón con sierra de calar aprox 3/4" del extremo para crear bloque 3'x1.5'x3/4 pulgadas.
5. Taladra 2 agujeros en borde inferior de lámina acrílica grande coincidiendo con un lado de la bisagra, y 2 agujeros en lado 3x1.5 pulgadas del bloque teflón para no estorbar el paso de la varilla. Taladra 2 agujeros coincidentes con los del bloque teflón si se posiciona en la parte superior de la lámina grande, opuesto a los agujeros previos, con el borde del bloque al borde del acrílico. Taladra 2 agujeros en pieza 2.4"x0.3" coincidiendo con el otro lado de la bisagra.
6. Lija suavemente una superficie del potenciómetro, el área en la lámina grande a pegar, y ambas superficies de la pieza 3x0.5". Limpia con paño húmedo.
7. Mezcla JB Weld en cartón reciclado con palito de helado, aplica en superficie preparada de lámina grande. Añade pieza 3x0.5", más JB Weld, luego el potenciómetro, asegurando JB Weld en superficie lijada. Sujeta suavemente con abrazadera pequeña, deja 24 horas curar.
8. Taladra agujero ligeramente mayor que 1/4 pulgada con broca 1/4" moviéndola mientras está en el bloque de un lado 3/4x3 pulgadas al otro del bloque teflón. Taladra para que la línea de la varilla coincida con la línea de movimiento del potenciómetro.
9. Corta varilla aluminio 1/4" aprox a la longitud correcta desde base del potenciómetro al pedal de expresión cuando se empuja totalmente abajo.
10. Una vez curado el JB Weld, fija la bisagra y el bloque teflón al lado de la lámina acrílica grande con tornillos máquina, arandelas y tuercas. Pon el tornillo de ojo en la parte móvil del potenciómetro, y únelo a la varilla 1/4" que pasa por el bloque teflón. Si el ajuste está suelto, también puedes soldar con JB Weld el tornillo de ojo a la varilla al aplicar JB Weld en paso anterior. En ese caso, pon el tornillo de ojo en el potenciómetro, pásalo por el bloque teflón, luego fija el bloque al acrílico con tornillos máquina después.
11. Sujetando el tornillo de ojo en posición correcta con alicates, fija la escuadra al otro extremo de la varilla 1/4" con tornillo máquina del tamaño correcto. Asegura que el tornillo de ojo está en la orientación correcta respecto a la escuadra al apretar.
12. Si hay agujero libre en el soporte del potenciómetro, pon tornillo máquina nuevo, luego arandela de seguridad teflón y aprieta hasta que la escuadra mueva libre. Si usas agujero existente ocupado por tornillo previo, quita el viejo, pon uno nuevo más largo, fíjalo como antes, luego en la longitud extra añade la escuadra y arandela de seguridad teflón.
13. Mueve la base de la bisagra adelante-atrás en el interior inferior del órgano hasta que esté en posición donde la varilla 1/4" está alineada recta, y con la pieza acrílica pequeña en su lugar, el movimiento del pedal aproxima el movimiento del potenciómetro lo mejor posible. Fija la base del soporte del potenciómetro a la base del órgano con los 2 tornillos madera pequeños, asegurando que la lámina acrílica queda entre la bisagra y la madera (esto asegura el recorrido correcto de la bisagra).

Nota final

Arduino Project Hub no parece tener notificaciones para publicaciones y preguntas aquí. Si quieres respuesta más rápida, puedes publicar en esta página del foro, que me notificará.

Código

Código para teclado matricial (Arduino)

Código para subir al Arduino cuando sigues el esquemático de teclado matricial.

// 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;
int noteOn2 = 145;
int noteOff2 = 129;
int noteOn3 = 146;
int noteOff3 = 130;
int velocity = 100;
int chan6 = 181;
int chan7 = 182;
int Exp = 11;
int LastPot6 = 1;
int LastPot7 = 1;

void setup() {
  Serial.begin(31250);
  //Initialize Keyboard A
  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);
  //Initialize Keyboard B
  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(52, INPUT);
  //Initialize Keyboard C
  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() {
  // Read Keyboard A
  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);

  // Read Keyboard B
  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);

  // Read Keyboard C
  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);

  //Invert Keyboard C data (For Normally Closed switches)
  //Column 1
  if (keysC[0][0] == 0) { keysC[0][0] = 1; } else if (keysC[0][0] == 1) { keysC[0][0] = 0; }
  //Column 2
  if (keysC[1][0] == 0) { keysC[1][0] = 1; } else if (keysC[1][0] == 1) { keysC[1][0] = 0; }
  if (keysC[1][1] == 0) { keysC[1][1] = 1; } else if (keysC[1][1] == 1) { keysC[1][1] = 0; }
  if (keysC[1][2] == 0) { keysC[1][2] = 1; } else if (keysC[1][2] == 1) { keysC[1][2] = 0; }
  if (keysC[1][3] == 0) { keysC[1][3] = 1; } else if (keysC[1][3] == 1) { keysC[1][3] = 0; }
  if (keysC[1][4] == 0) { keysC[1][4] = 1; } else if (keysC[1][4] == 1) { keysC[1][4] = 0; }
  if (keysC[1][5] == 0) { keysC[1][5] = 1; } else if (keysC[1][5] == 1) { keysC[1][5] = 0; }
  //Column 3
  if (keysC[2][0] == 0) { keysC[2][0] = 1; } else if (keysC[2][0] == 1) { keysC[2][0] = 0; }
  if (keysC[2][1] == 0) { keysC[2][1] = 1; } else if (keysC[2][1] == 1) { keysC[2][1] = 0; }
  if (keysC[2][2] == 0) { keysC[2][2] = 1; } else if (keysC[2][2] == 1) { keysC[2][2] = 0; }
  if (keysC[2][3] == 0) { keysC[2][3] = 1; } else if (keysC[2][3] == 1) { keysC[2][3] = 0; }
  if (keysC[2][4] == 0) { keysC[2][4] = 1; } else if (keysC[2][4] == 1) { keysC[2][4] = 0; }
  if (keysC[2][5] == 0) { keysC[2][5] = 1; } else if (keysC[2][5] == 1) { keysC[2][5] = 0; }
  //Column 4
  if (keysC[3][0] == 0) { keysC[3][0] = 1; } else if (keysC[3][0] == 1) { keysC[3][0] = 0; }
  if (keysC[3][1] == 0) { keysC[3][1] = 1; } else if (keysC[3][1] == 1) { keysC[3][1] = 0; }
  if (keysC[3][2] == 0) { keysC[3][2] = 1; } else if (keysC[3][2] == 1) { keysC[3][2] = 0; }
  if (keysC[3][3] == 0) { keysC[3][3] = 1; } else if (keysC[3][3] == 1) { keysC[3][3] = 0; }
  if (keysC[3][4] == 0) { keysC[3][4] = 1; } else if (keysC[3][4] == 1) { keysC[3][4] = 0; }
  if (keysC[3][5] == 0) { keysC[3][5] = 1; } else if (keysC[3][5] == 1) { keysC[3][5] = 0; }
  //Column 5
  if (keysC[4][0] == 0) { keysC[4][0] = 1; } else if (keysC[4][0] == 1) { keysC[4][0] = 0; }
  if (keysC[4][1] == 0) { keysC[4][1] = 1; } else if (keysC[4][1] == 1) { keysC[4][1] = 0; }
  if (keysC[4][2] == 0) { keysC[4][2] = 1; } else if (keysC[4][2] == 1) { keysC[4][2] = 0; }
  if (keysC[4][3] == 0) { keysC[4][3] = 1; } else if (keysC[4][3] == 1) { keysC[4][3] = 0; }
  if (keysC[4][4] == 0) { keysC[4][4] = 1; } else if (keysC[4][4] == 1) { keysC[4][4] = 0; }
  if (keysC[4][5] == 0) { keysC[4][5] = 1; } else if (keysC[4][5] == 1) { keysC[4][5] = 0; }
  //Column 6
  if (keysC[5][0] == 0) { keysC[5][0] = 1; } else if (keysC[5][0] == 1) { keysC[5][0] = 0; }
  if (keysC[5][1] == 0) { keysC[5][1] = 1; } else if (keysC[5][1] == 1) { keysC[5][1] = 0; }
  if (keysC[5][2] == 0) { keysC[5][2] = 1; } else if (keysC[5][2] == 1) { keysC[5][2] = 0; }
  if (keysC[5][3] == 0) { keysC[5][3] = 1; } else if (keysC[5][3] == 1) { keysC[5][3] = 0; }
  if (keysC[5][4] == 0) { keysC[5][4] = 1; } else if (keysC[5][4] == 1) { keysC[5][4] = 0; }
  if (keysC[5][5] == 0) { keysC[5][5] = 1; } else if (keysC[5][5] == 1) { keysC[5][5] = 0; }
  //Column 7
  if (keysC[6][0] == 0) { keysC[6][0] = 1; } else if (keysC[6][0] == 1) { keysC[6][0] = 0; }

  //Write Keyboard A (61 keys, notes 36-96)
  // ... [Código abreviado por espacio - lógica idéntica para cada nota] ...
  // El código completo envía Note On/Off para cada tecla detectando cambios de estado

  //Write Keyboard B (61 keys, notes 36-96)
  // ... [Lógica idéntica al teclado A, canales MIDI diferentes] ...

  //Write Keyboard C (Pedalera, 32 notas, lógica invertida)
  // ... [Lógica para pedalera con interruptores NC] ...

  //Expression pedal on analog pin 0 to Channel 6
  int Cur6 = analogRead(0);
  int Map6 = map(Cur6, 0, 1023, 0, 127);
  if (abs(Cur6 - LastPot6) >= 8) {
    MidiSend(chan6,Exp,Map6);
    LastPot6 = Cur6;
  }
  //Expression pedal on analog pin 1 to Channel 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 tipo bus (Arduino)

Código para subir al Arduino si sigues el esquemático de teclado tipo bus.

// 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

//Note Data
byte keysA[11][6];
byte keysB[11][6];
byte keysC[11][6];
byte keysD[11][6];
//Last Key State
byte lastA[11][6];
byte lastB[11][6];
byte lastC[11][6];
byte lastD[11][6];
//Midi Messages Sent
int noteOn1 = 144; int noteOff1 = 128;
int noteOn2 = 145; int noteOff2 = 129;
int noteOn3 = 146; int noteOff3 = 130;
int noteOn4 = 147; int noteOff4 = 131;
int velocity = 100;
int chan6 = 181; int chan7 = 182; int chan8 = 183;
int Exp = 11;
//Last Potentiometer State
int LastPot6 = 1; int LastPot7 = 1; int LastPot8 = 1;

void setup() {
  Serial.begin(31250);
  //Initialize Pins 1-10
  pinMode(2, INPUT); pinMode(3, INPUT); pinMode(4, INPUT); pinMode(5, INPUT);
  pinMode(6, INPUT); pinMode(7, INPUT); pinMode(8, INPUT); pinMode(9, INPUT);
  pinMode(10, INPUT); pinMode(11, INPUT);
  //Pins 11-20
  pinMode(12, INPUT); pinMode(13, INPUT); pinMode(14, INPUT); pinMode(15, INPUT);
  pinMode(16, INPUT); pinMode(17, INPUT); pinMode(18, INPUT); pinMode(19, INPUT);
  pinMode(20, INPUT); pinMode(21, INPUT);
  //Pins 21-30
  pinMode(22, INPUT); pinMode(23, INPUT); pinMode(24, INPUT); pinMode(25, INPUT);
  pinMode(26, INPUT); pinMode(27, INPUT); pinMode(28, INPUT); pinMode(29, INPUT);
  pinMode(30, INPUT); pinMode(31, INPUT);
  //Pins 31-40
  pinMode(32, INPUT); pinMode(33, INPUT); pinMode(34, INPUT); pinMode(35, INPUT);
  pinMode(36, INPUT); pinMode(37, INPUT); pinMode(38, INPUT); pinMode(39, INPUT);
  pinMode(40, INPUT); pinMode(41, INPUT);
  //Pins 41-50
  pinMode(42, INPUT); pinMode(43, INPUT); pinMode(44, INPUT); pinMode(45, INPUT);
  pinMode(46, INPUT); pinMode(47, INPUT); pinMode(48, INPUT); pinMode(49, INPUT);
  pinMode(50, INPUT); pinMode(51, INPUT);
  //Pins 51-61
  pinMode(52, INPUT); pinMode(53, INPUT); pinMode(A0, INPUT); pinMode(A1, INPUT);
  pinMode(A2, INPUT); pinMode(A3, INPUT); pinMode(A4, INPUT); pinMode(A5, INPUT);
  pinMode(A6, INPUT); pinMode(A7, INPUT); pinMode(A8, INPUT);
  //Column Pins
  pinMode(A9, INPUT); pinMode(A10, INPUT); pinMode(A11, INPUT); pinMode(A12, INPUT);
  //Pot Pins
  pinMode(A13, INPUT); pinMode(A14, INPUT); pinMode(A15, INPUT);
}

void loop() {
  // Setup pins for keyboards - set all to INPUT_PULLUP
  // ... [Configuración de todos los pines como INPUT_PULLUP] ...

  //Read Keyboard A
  pinMode(A9, OUTPUT); digitalWrite(A9, LOW);
  //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);

  // Read Keyboard B, C, D (similar pattern with columns A10, A11, A12)
  // ... [Código abreviado - misma lógica para 4 teclados] ...

  //Return pins to Initialized state
  // ... [Restaurar todos los pines a INPUT] ...

  //Write Keyboard A, B, C, D (Note On/Off para 61 teclas cada uno)
  // ... [Lógica completa de envío MIDI para 244 teclas totales] ...

  //Expression Pedal controls
  //Expression pedal on analog pin A13 to Channel 6
  int Cur6 = analogRead(13);
  int Map6 = map(Cur6, 0, 1023, 0, 127);
  if (abs(Cur6 - LastPot6) >= 8) {
    MidiSend(chan6,Exp,Map6);
    LastPot6 = Cur6;
  }
  //Expression pedal on analog pin A14 to Channel 7
  int Cur7 = analogRead(14);
  int Map7 = map(Cur7, 0, 1023, 0, 127);
  if (abs(Cur7 - LastPot7) >= 8) {
    MidiSend(chan7,Exp,Map7);
    LastPot7 = Cur7;
  }
  //Expression pedal on analog pin A15 to Channel 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

• Diagrama de cableado para teclados matriz 6x11 y pedalera con entradas potenciómetro
• Diagrama de cableado para teclados tipo bus con entradas potenciómetro