home Technologie de fabrication Équipement de fabrication
Fabrication industrielle
Internet des objets industriel | Matériaux industriels | Entretien et réparation d'équipement | Programmation industrielle |
home  MfgRobots >> Fabrication industrielle >  >> Manufacturing Technology >> Processus de fabrication

Intégration MIDI pour Orgues Numériques : Composants et Guide de Configuration

Composants et fournitures

Composant Quantité Notes
Arduino Mega 2560 1 54 E/S numériques, 16 analogiques - idéal pour matrices clavier
Prise DIN MIDI 5 broches 1 Sortie MIDI standard
Résistance 220 Ω 1 Pour sortie MIDI (broche 5 de la DIN)
Câble USB-A vers B 1 Programmation et alimentation Arduino
Câble AWM (multibrins) 1 Câblage clavier vers Arduino (longueur selon installation)
Connecteur mâle 40 broches 1 rangée (pas 2,54 mm) 1 Interface câble/Arduino (ou bornier à vis)
Potentiomètre linéaire 10K (curseur) 1 Pour pédale d'expression
Connecteur IDC (optionnel) 1 Alternative au soudage direct sur headers
Fils mâle/mâle (optionnel) 1 jeu Si utilisation connecteurs IDC

Outils nécessaires

Applications et services en ligne

À propos de ce projet

Ce projet montre comment convertir une console d'orgue ancien pour qu'elle puisse envoyer des messages MIDI matériels depuis les claviers (manuels) et le pédalier en utilisant un unique Arduino Mega.

Le projet a débuté comme une tentative d'envoi de messages MIDI tout en conservant la génération sonore d'origine, mais les circuits originaux se sont révélés difficiles à rétro-ingénier. Après du temps passé sur le code, j'ai développé des versions pour les deux types de claviers : matricés (matrice lignes/colonnes avec diodes) et bussés (bus commun + fils individuels par touche).

⚠ Avertissements importants

  • Modification irréversible : Ce projet modifie l'orgue de sorte que le commutateur de clavier d'origine ne fonctionne plus.
  • Danger électrique : À l'intérieur d'un vieil orgue, des composants peuvent être dangereux. Travaillez toujours avec l'orgue débranché, et assurez-vous d'avoir l'expérience et les compétences pour travailler en sécurité. En cas de doute, consultez un technicien électronique qualifié local.
  • Composants vieillissants : Les composants internes des vieux orgues sont souvent au bord de la défaillance ; toute modification peut endommager l'orgue. Suivre ces instructions se fait à vos propres risques ; l'auteur décline toute responsabilité pour tout dommage à l'orgue, équipement ou personnes.

Étape 1 : Examiner l'orgue

Étape 2 : Fixer l'Arduino

Mon Arduino Mega était fourni avec une petite plaque plastique pour le monter sur le bois de l'orgue. Je l'ai fixé avec de petites vis à bois #4 et vis machine #4 pour l'Arduino sur la plaque. Placez l'Arduino d'abord pour estimer les longueurs de câbles. Prévoyez aussi l'alimentation (USB ou 5V externe).

Étape 3 : Préparer les câbles

Clavier matricé :

Chaque clavier a 61 interrupteurs. Dans l'exemple, 6 rangées (lignes) : un fil relie la première borne de chaque interrupteur à celle de l'interrupteur 6 positions plus loin. La seconde borne va à une diode, puis aux colonnes (11 colonnes pour les manuels, 7 pour le pédalier). Pour chaque manuel et pédalier, coupez deux longueurs de câble AWM atteignant de chaque division à l'Arduino, en suivant un chemin ordonné et en prévoyant de la marge. Pour les colonnes, préférez que le câble parcoure la longueur du clavier avant d'aller à l'Arduino. Mesurez, coupez, séparez les brins aux extrémités, dénudrez.

Clavier bussé :

Le clavier peut être divisé en 6 câbles AWM (10 fils chacun = 60 contacts) + 1 fil ordinaire pour le 61ème contact. Séparez les brins aux extrémités, dénudrez.

Étape 4 : Souder les extrémités des câbles sur connecteurs mâles

Matricé et Bussé : Soudez les fils aux broches du connecteur mâle, ou utilisez un bornier à vis.

Intégration MIDI pour Orgues Numériques : Composants et Guide de Configuration

Étape 5 : Souder l'autre extrémité aux interrupteurs

Clavier matricé :

Si l'orgue a déjà ses contacts câblés, il faut dessouder ou couper les fils d'origine. Pour une matrice 6×11, conservez les fils de rangée (chaque interrupteur au suivant 6 positions plus loin). Retirez les fils de rangée du premier groupe de 6 vers l'ancien ordinateur, soudez vos 6 fils de rangée à leur place. Pour les colonnes : si diodes déjà en place, coupez/dessoudez le fil de l'autre côté des diodes vers l'ancien ordinateur, soudez votre fil de colonne à la place. Organisez les câbles avec des colliers le long du cheminement existant. Pour le pédalier, le panneau avant contenant les contacts à lames a dû être déposé (vis) et les câbles passés par le trou central.

Clavier bussé :

Soudez une diode sur le côté non-bussé de chaque interrupteur (pôle négatif vers l'interrupteur), puis soudez à l'un des 10 fils du câble. Répétez pour les 6 câbles, puis pour le 61ème fil.

Étape 6 : Souder la résistance sur la prise MIDI et connecter à l'Arduino

Intégration MIDI pour Orgues Numériques : Composants et Guide de Configuration

La résistance 220 Ω se soude sur la broche 5 de la prise DIN MIDI (sortie TX). Les autres connexions : broche 4 (VCC) → 5V Arduino, broche 2 (GND) → GND Arduino. La broche 1 et 3 ne sont pas utilisées (standard MIDI OUT uniquement).

Étape 7 : Connecter les connecteurs à l'Arduino

Branchez tous les connecteurs sur l'Arduino selon le schéma.

Alternative : Achetez des connecteurs IDC 10 broches, connectez-les aux bouts des câbles AWM, puis utilisez des fils mâle/mâle vers l'Arduino. Moins permanent que le soudage, mais conseillé si vous prévoyez de modifier le code et potentiellement recâbler.

Étape 8 : Téléverser le logiciel sur l'Arduino

Étape 9 : Tester

Notes importantes

Matériel pour pédale d'expression (potentiomètre)

Intégration MIDI pour Orgues Numériques : Composants et Guide de Configuration

Je détaillerai plus tard, mais voici brièvement le design : La connexion à la pédale d'expression utilise une équerre "L" peu coûteuse (quincaillerie). Elle se connecte à un support existant, ou une seconde équerre fixée directement sur la pédale. Articulation sur une vis machine légèrement desserrée avec contre-écrou et deux rondelles. Tige métallique : œil boulon (eye bolt) collé au JB Weld à une extrémité, vis machine à l'autre pour l'équerre "L".

Support du potentiomètre : feuilles acrylique transparente, découpées au cutter, cassées à l'étau. Pièce acrylique plus petite pour surélever le potentiomètre, surfaces poncées, collées au JB Weld, serrées au petit étau 24h. Trous percés à la perceuse.

Base de la grande pièce acrylique fixée sur petite charnière meuble (vis machine #4), autre bout de la charnière sur le plancher de l'orgue (vis à bois #4 courtes). Équerre acrylique pour décaler la charnière du sol (selon design).

Bloc blanc = bloc PTFE (Téflon) fournisseur pièces robot. Découpé à la scie à métaux, 3 trous percés. Fixé sur l'équerre acrylique par vis machine.

Instructions détaillées pour support pédale d'expression (MàJ 9 déc. 2021)

Matériel :

Outils :

Procédure :

  1. Examinez la pédale actuelle. Si trou libre sur support, utilisez-le ; sinon utilisez un trou existant avec une vis machine plus longue.
  2. Dégagez la base en bois de l'orgue de tout composant/électronique.
  3. Déballer l'acrylique, tracer au cutter + règle un rectangle 3″×4,5″ (recto/verso), casser à l'étau + pinces (lunettes protection !). Couper aussi 3″×0,5″ et 2,4″×0,3″.
  4. Scier le bloc téflon ~2 cm du bout pour créer bloc 3×1,5×2 cm.
  5. Percez 2 trous sur bord bas grande plaque acrylique (alignés charnière), 2 trous sur face 3×1,5 cm du téflon (hors chemin tige alu). 2 trous correspondants sur grande plaque en face du téflon (bord haut). 2 trous sur pièce 2,4×0,3″ alignés autre côté charnière.
  6. Poncez délicatement une face du potentiomètre, zone de collage sur grande plaque, et les deux faces de la pièce 3×0,5″. Essuyez chiffon humide.
  7. Mélangez JB Weld sur carton avec bâtonnet, appliquez sur grande plaque, ajoutez pièce 3×0,5″, plus JB Weld, puis potentiomètre (surface poncée). Serrez petit serre-joint, laissez durcir 24h.
  8. Percez trou légèrement >1/4″ (foret 1/4″ en élargissant) traversant le bloc téflon d'une face 2×3 cm à l'autre. Alignez avec course du potentiomètre.
  9. Coupez tige alu 1/4″ longueur approximative : bas potentiomètre → pédale enfoncée à fond.
  10. Une fois JB Weld durci, fixez charnière et bloc téflon sur grande plaque (vis, rondelles, écrous). Mettez œil boulon sur partie mobile potentiomètre, insérez dans tige alu traversant téflon. Si jeu, coller œil boulon à la tige au JB Weld (alors : œil boulon sur potar → dans téflon → fixer téflon sur plaque).
  11. Tenez œil boulon à la pince, fixez équerre meuble sur l'autre bout de tige alu (vis machine adaptée). Vérifiez orientation œil boulon / équerre avant serrage.
  12. Si trou libre sur support pédale : nouvelle vis machine + rondelle frein téflon, serrez jusqu'à mouvement libre équerre. Si trou occupé : retirez vieille vis, mettez vis plus longue, fixez comme avant, puis sur longueur excédentaire ajoutez équerre + rondelle frein téflon.
  13. Faites coulisser base charnière sur plancher intérieur orgue jusqu'à alignement parfait tige alu, et avec petite plaque acrylique en place, le mouvement pédale ≈ mouvement potentiomètre. Fixez base support au plancher (2 vis à bois #4 courtes), plaque acrylique ENTRE charnière et bois (assure course correcte charnière).

Note finale

L'Arduino Project Hub ne semble pas notifier les posts/questions ici. Pour une réponse plus rapide, postez sur ce forum Arduino qui me notifiera.

Code

Deux versions selon votre type de clavier :

Code pour clavier matricé (Matrixed Keyboard)

// Name: Arduino Mega Midi Controller v21
// Created: Feb 4, 2021
// Author: Larason2
// Acknowledgements: Bald Engineer, Amanda Ghassaei, jeffb42, GrumpyMike

byte keysA[11][6];  // Clavier A (manuel 1) - 11 colonnes x 6 lignes
byte keysB[11][6];  // Clavier B (manuel 2)
byte keysC[7][6];   // Clavier C (pédalier) - 7 colonnes x 6 lignes

byte lastA[11][6];
byte lastB[11][6];
byte lastC[7][6];

// Canaux MIDI : 144=NoteOn Ch1, 128=NoteOff Ch1, etc.
int noteOn1 = 144, noteOff1 = 128;   // Clavier A - Canal 1
int noteOn2 = 145, noteOff2 = 129;   // Clavier B - Canal 2
int noteOn3 = 146, noteOff3 = 130;   // Clavier C - Canal 3
int velocity = 100;

// Canaux contrôleurs pour pédales d'expression
int chan6 = 181;  // Control Change Canal 6
int chan7 = 182;  // Control Change Canal 7
int Exp = 11;     // Controller #11 (Expression)
int LastPot6 = 1, LastPot7 = 1;

void setup() {
  Serial.begin(31250);  // Baudrate MIDI standard
  
  // Initialisation broches Clavier A (lignes = entrées, colonnes = sorties)
  // Lignes : 2, 22, 24, 26, 28, 30
  // Colonnes : 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52
  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);
  
  // Clavier 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(53, INPUT);
  
  // Clavier C (pédalier) - broches analogiques utilisées en digitales
  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() {
  // --- LECTURE CLAVIER A (Matrice 6x11) ---
  // Mise en pull-up des 6 lignes
  pinMode(22, INPUT_PULLUP); pinMode(24, INPUT_PULLUP);
  pinMode(26, INPUT_PULLUP); pinMode(28, INPUT_PULLUP);
  pinMode(30, INPUT_PULLUP); pinMode(2, INPUT_PULLUP);
  
  // Balayage des 11 colonnes (sortie LOW séquentielle)
  pinMode(32, OUTPUT); digitalWrite(32, LOW);
  keysA[0][0] = digitalRead(2);  // Col 0, Ligne 0
  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);
  
  // Remise lignes en entrée simple
  pinMode(22, INPUT); pinMode(24, INPUT); pinMode(26, INPUT);
  pinMode(28, INPUT); pinMode(30, INPUT); pinMode(2, INPUT);
  
  // --- LECTURE CLAVIER B (identique, décalage broches colonnes 33,35,37,39,41,43,45,47,49,51,53) ---
  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);
  
  // --- LECTURE CLAVIER C (Pédalier, matrice 6x7, interrupteurs NF = inversion logique) ---
  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);
  
  // Inversion logique pour interrupteurs NF (Normalement Fermés)
  // 0 (appuyé) devient 1, 1 (relâché) devient 0
  for (int col = 0; col < 7; col++) {
    for (int row = 0; row < 6; row++) {
      if (col == 0 && row > 0) continue;  // Col 0 n'a que ligne 0
      if (col == 6 && row > 0) continue;  // Col 6 n'a que ligne 0
      if (keysC[col][row] == 0) keysC[col][row] = 1;
      else keysC[col][row] = 0;
    }
  }
  // Cas colonnes 0 et 6 (1 seule touche)
  if (keysC[0][0] == 0) keysC[0][0] = 1; else keysC[0][0] = 0;
  if (keysC[6][0] == 0) keysC[6][0] = 1; else keysC[6][0] = 0;
  
  // --- ENVOI MIDI CLAVIER A (Notes 36-96) ---
  // Boucle optimisée pour 61 touches (36 à 96)
  for (int col = 0; col < 11; col++) {
    for (int row = 0; row < 6; row++) {
      int note = 36 + col * 6 + row;
      if (note > 96) continue;
      if (keysA[col][row] == 0 && lastA[col][row] == 0) {
        MidiSend(noteOn1, note, velocity); lastA[col][row] = 7;
      }
      if (keysA[col][row] == 1 && lastA[col][row] == 7) {
        MidiSend(noteOff1, note, velocity); lastA[col][row] = 0;
      }
    }
  }
  
  // --- ENVOI MIDI CLAVIER B (Notes 36-96, Canal 2) ---
  for (int col = 0; col < 11; col++) {
    for (int row = 0; row < 6; row++) {
      int note = 36 + col * 6 + row;
      if (note > 96) continue;
      if (keysB[col][row] == 0 && lastB[col][row] == 0) {
        MidiSend(noteOn2, note, velocity); lastB[col][row] = 7;
      }
      if (keysB[col][row] == 1 && lastB[col][row] == 7) {
        MidiSend(noteOff2, note, velocity); lastB[col][row] = 0;
      }
    }
  }
  
  // --- ENVOI MIDI CLAVIER C / Pédalier (Notes 36-67, Canal 3, logique inversée) ---
  for (int col = 0; col < 7; col++) {
    for (int row = 0; row < 6; row++) {
      int note = 36 + col * 6 + row;
      if (note > 67) continue;  // Pédalier généralement 32 notes (36-67)
      // Logique inversée : keysC==0 = appuyé (NoteOn), keysC==1 = relâché (NoteOff)
      if (keysC[col][row] == 0 && lastC[col][row] == 0) {
        MidiSend(noteOn3, note, velocity); lastC[col][row] = 7;
      }
      if (keysC[col][row] == 1 && lastC[col][row] == 7) {
        MidiSend(noteOff3, note, velocity); lastC[col][row] = 0;
      }
    }
  }
  
  // --- PÉDALES D'EXPRESSION (Entrées analogiques A0, A1) ---
  // Pédale 1 → Canal 6 (CC#11)
  int Cur6 = analogRead(0);
  int Map6 = map(Cur6, 0, 1023, 0, 127);
  if (abs(Cur6 - LastPot6) >= 8) {
    MidiSend(chan6, Exp, Map6);
    LastPot6 = Cur6;
  }
  
  // Pédale 2 → Canal 7 (CC#11)
  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 status, int data1, int data2) {
  Serial.write(status);
  Serial.write(data1);
  Serial.write(data2);
}

Code pour clavier bussé (Bussed Keyboard)

// Name: Arduino Mega Midi Controller 61x4 + 3 potentiometers
// Version 1.0 - Created: April 12, 2021 - Author: Larason2
// Acknowledgements: Bald Engineer, Amanda Ghassaei, jeffb42, GrumpyMike

// 4 claviers bussés x 61 touches = 244 touches max
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];

// MIDI Messages
int noteOn1=144, noteOff1=128;  // Clavier A - Ch1
int noteOn2=145, noteOff2=129;  // Clavier B - Ch2
int noteOn3=146, noteOff3=130;  // Clavier C - Ch3
int noteOn4=147, noteOff4=131;  // Clavier D - Ch4
int velocity = 100;

// Expression pedals (Control Change)
int chan6=181, chan7=182, chan8=183;  // Canaux 6,7,8
int Exp = 11;  // Controller #11 Expression
int LastPot6=1, LastPot7=1, LastPot8=1;

void setup() {
  Serial.begin(31250);
  
  // Initialisation 61 entrées (broches 2-53, A0-A8) + 4 colonnes (A9-A12) + 3 pots (A13-A15)
  for (int i = 2; i <= 53; i++) pinMode(i, 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);
  pinMode(A9, INPUT); pinMode(A10, INPUT); pinMode(A11, INPUT);
  pinMode(A12, INPUT); pinMode(A13, INPUT); pinMode(A14, INPUT);
  pinMode(A15, INPUT);
}

void loop() {
  // Mise en INPUT_PULLUP des 61 entrées
  for (int i = 2; i <= 53; i++) pinMode(i, INPUT_PULLUP);
  pinMode(A0, INPUT_PULLUP); pinMode(A1, INPUT_PULLUP);
  pinMode(A2, INPUT_PULLUP); pinMode(A3, INPUT_PULLUP);
  pinMode(A4, INPUT_PULLUP); pinMode(A5, INPUT_PULLUP);
  pinMode(A6, INPUT_PULLUP); pinMode(A7, INPUT_PULLUP);
  pinMode(A8, INPUT_PULLUP);
  
  // --- LECTURE 4 CLAVIERS (même bus, colonnes séquentielles A9-A12) ---
  
  // Clavier A - Colonne A9
  pinMode(A9, OUTPUT); digitalWrite(A9, LOW);
  readBusKeys(keysA);
  pinMode(A9, INPUT);
  
  // Clavier B - Colonne A10
  pinMode(A10, OUTPUT); digitalWrite(A10, LOW);
  readBusKeys(keysB);
  pinMode(A10, INPUT);
  
  // Clavier C - Colonne A11
  pinMode(A11, OUTPUT); digitalWrite(A11, LOW);
  readBusKeys(keysC);
  pinMode(A11, INPUT);
  
  // Clavier D - Colonne A12
  pinMode(A12, OUTPUT); digitalWrite(A12, LOW);
  readBusKeys(keysD);
  pinMode(A12, INPUT);
  
  // Remise entrées standard
  for (int i = 2; i <= 53; i++) pinMode(i, 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);
  pinMode(A9, INPUT); pinMode(A10, INPUT); pinMode(A11, INPUT);
  pinMode(A12, INPUT); pinMode(A13, INPUT); pinMode(A14, INPUT);
  pinMode(A15, INPUT);
  
  // --- ENVOI MIDI 4 CLAVIERS ---
  sendKeyboardMidi(keysA, lastA, noteOn1, noteOff1);
  sendKeyboardMidi(keysB, lastB, noteOn2, noteOff2);
  sendKeyboardMidi(keysC, lastC, noteOn3, noteOff3);
  sendKeyboardMidi(keysD, lastD, noteOn4, noteOff4);
  
  // --- PÉDALES D'EXPRESSION (A13, A14, A15) ---
  int Cur6 = analogRead(13); int Map6 = map(Cur6, 0, 1023, 0, 127);
  if (abs(Cur6 - LastPot6) >= 8) { MidiSend(chan6, Exp, Map6); LastPot6 = Cur6; }
  
  int Cur7 = analogRead(14); int Map7 = map(Cur7, 0, 1023, 0, 127);
  if (abs(Cur7 - LastPot7) >= 8) { MidiSend(chan7, Exp, Map7); LastPot7 = Cur7; }
  
  int Cur8 = analogRead(15); int Map8 = map(Cur8, 0, 1023, 0, 127);
  if (abs(Cur8 - LastPot8) >= 8) { MidiSend(chan8, Exp, Map8); LastPot8 = Cur8; }
}

// Fonction lecture bus 61 touches → tableau [11][6]
void readBusKeys(byte keys[11][6]) {
  // Mapping broches → notes (61 touches = 11×6 - 5)
  // Ordre : broches 2-53, A0-A8 (61 entrées)
  int pins[61] = {2,3,4,5,6,7,8,9,10,11, 12,13,14,15,16,17,18,19,20,21,
                  22,23,24,25,26,27,28,29,30,31, 32,33,34,35,36,37,38,39,40,41,
                  42,43,44,45,46,47,48,49,50,51, 52,53,A0,A1,A2,A3,A4,A5,A6,A7,A8};
  
  for (int i = 0; i < 61; i++) {
    int col = i / 6;
    int row = i % 6;
    if (col < 11 && row < 6) keys[col][row] = digitalRead(pins[i]);
  }
}

// Fonction envoi MIDI pour un clavier
void sendKeyboardMidi(byte keys[11][6], byte last[11][6], int noteOn, int noteOff) {
  for (int col = 0; col < 11; col++) {
    for (int row = 0; row < 6; row++) {
      int note = 36 + col * 6 + row;
      if (note > 96) continue;
      if (keys[col][row] == 0 && last[col][row] == 0) {
        MidiSend(noteOn, note, velocity); last[col][row] = 7;
      }
      if (keys[col][row] == 1 && last[col][row] == 7) {
        MidiSend(noteOff, note, velocity); last[col][row] = 0;
      }
    }
  }
}

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

Schémas de câblage

Les schémas détaillés montrent le câblage complet : diodes sur interrupteurs, connexion prise MIDI (résistance 220Ω sur TX), brochage Arduino Mega, et montage pédale d'expression.

Résumé des différences Matricé vs Bussé

Caractéristique Matricé (Matrixed) Bussé (Bussed)
Câblage interrupteurs Matrice lignes/colonnes + diodes Bus commun + 1 fil par touche + diodes
Diodes Côté colonne (anode vers switch) Côté non-bussé (cathode vers switch)
Broches Arduino utilisées 6 lignes + 11 colonnes par clavier 61 entrées partagées + 4 colonnes
Nombre claviers supportés 3 (2 manuels 6×11 + 1 pédalier 6×7) 4 claviers 61 touches complets
Complexité câblage Modérée (diodes sur chaque switch) Plus simple par touche, mais 61 fils
Code testé Oui Non (théorique)

Processus de fabrication

  • Processus de fabrication
  • impression en 3D
  • Système de contrôle d'automatisation
  • Technologie industrielle

    1. Obtenir la certification ISO 26262 pour les composants logiciels automobiles
    2. Eclipse Ditto 1.0 — La plateforme Device-as-a-Service pour le développement de Jumeaux Numériques
    3. Mises à jour logicielles cloud robustes pour dispositifs IoT
    4. Solutions de découpe numérique pour l'industrie du tapis – OMNI CNC
    5. Maîtriser la gestion des actifs numériques : une stratégie complète pour l'excellence des actifs pilotée par les données
    6. PET chargé verre avancé pour pièces extérieures automobiles supérieures
    7. Top 3 des tendances de la fabrication numérique façonnant 2020
    8. Plan stratégique pour réussir sa transformation digitale
    9. Composants Invar 36 : matériaux, propriétés et achat de confiance