Midiface 4×4 Thru/Merge button hack for merge mode

Le Miditech MIDIface 4×4 Thru/Merge revient à son mode par défaut à chaque mise sous tension. Sur le boîtier de ce montage, le nombre d’appuis sur MODE nécessaire pour sélectionner MERGE dépend du branchement de son port USB.

Le QT Py et le relais automatisent les 5 ou 6 appuis correspondant au branchement retenu. Le contact du relais est câblé en parallèle sur le bouton existant. Une fois la séquence terminée, le relais reste relâché et le NeoPixel est éteint jusqu’au prochain démarrage du microcontrôleur.

Le code est réglé sur 5 appuis par défaut pour une alimentation USB externe. Avant de programmer le QT Py, passer N_PUSH_BUTTON à 6 seulement si le Midiface sera relié à un ordinateur. Le montage ne détecte pas automatiquement le branchement.

Le port USB du Midiface et l’USB-C du QT Py ont des rôles distincts : l’USB-C du QT Py est connecté ponctuellement au PC pour la programmation.

Pour les modes, les voyants et les connexions MIDI, consulter le manuel Midiface 4x4 Thru / Merge DEU-ENG, également disponible sur la page officielle des manuels Miditech.

Liens MC Hobby pour les composants et les fils, donnés à titre indicatif.

MC Hobby ne sponsorise pas ce projet. Nomadly y a simplement acheté le matériel, sans avantage particulier ni compensation. Nomadly recommande cette boutique belge pour la qualité de son service et ses prix.

Débrancher l’alimentation USB et les câbles MIDI avant d’ouvrir le Midiface 4×4 Thru/Merge.

1. Retirer les deux vis situées aux extrémités de la face du boîtier.
2. Déboîter délicatement et enlever la plaque noire. Conserver la plaque et les deux vis pour le remontage.
3. Faire glisser la carte électronique hors du boîtier. Elle est guidée par des rails : la faire coulisser doucement dans leur axe pour l’extraire.

Le firmware s’exécute une seule fois dans setup(). La fonction loop() est vide. La constante N_PUSH_BUTTON définit le nombre d’appuis : 5 sur alimentation USB externe, 6 si l’USB du Midiface est relié à un ordinateur.

Durée selon le branchement du Midiface

Délais cumulés : 8 969 + N_PUSH_BUTTON × (264 + 744) + 7 546. * Hors démarrage du QT Py et temps d’exécution des instructions. Les durées proviennent du fichier MidifaceMerger.ino fourni.

Les deux fils COM / NO reproduisent la fermeture du bouton SW1. Ils ne sont pas reliés à la commande logique du relais. Les couleurs servent de repères dans ce document.

NC reste libre. Le relais est au repos lorsque EN = LOW ; EN = HIGH provoque un appui.

Les photos conservent leur orientation d’origine. Les pastilles du MIDIface et l’ordre des bornes du relais ont été confirmés par le propriétaire du montage le 18 octobre 2026.

Avant toute soudure sur le QT Py, effectuer sa programmation, puis débrancher son câble USB-C.

QT Py ↔ relais

Relais ↔ bouton MODE / SW1

COM et NO peuvent être inversés sur cette paire : le contact sec n’a pas de polarité.

Alimentation depuis le MIDIface

Ne pas utiliser le point mesuré à environ 3 V. Le relais est alimenté depuis les broches 5V et GND du QT Py, jamais par la sortie A2.

#include <Adafruit_NeoPixel.h>

/*
QT Py           Relais
5V   ------->   VDD
GND  ------->   GND
A2   ------->   EN

Relais          MidifaceMerger
COM  ------->   A1
NO   ------->   A2

MidifaceMerger  QT Py
5V   ------->   5V
GND  ------->   GND
*/

const int RELAY = A2;
// Adafruit indique que sur ce modèle la broche 12 coupe l’alimentation du NeoPixel
const int PIN_NEOPIXEL_POWER = 12;

// Si boîtier connecté à l'ordinateur : 6 appuis du bouton (il n'y a aucune raison de relier le boîtier au PC en mode Merge)
// Si boîtier non connecté à l'ordinateur, mais uniquement à alimentation usb externe : 5 appuis du bouton
const int N_PUSH_BUTTON = 5;

Adafruit_NeoPixel pixel(1, PIN_NEOPIXEL);

void setLed(int r, int g, int b)
{
  pixel.setPixelColor(0, pixel.Color(r, g, b));
  pixel.show();
}

void setup()
{
  // Init A2/Relais
  pinMode(RELAY, OUTPUT);
  digitalWrite(RELAY, LOW);

  // Init LED
  pixel.begin();
  pixel.setBrightness(30);

  // Démarrage / attente que le MIDIface soit prêt
  setLed(255, 0, 0); // rouge
  delay(8969);

  // 6 appuis sur le bouton MODE
  for (int i = 0; i < N_PUSH_BUTTON; i++)
  {
    // Bouton pressé
    setLed(0, 0, 255); // bleu
    digitalWrite(RELAY, HIGH);
    delay(264);

    // Bouton relâché
    digitalWrite(RELAY, LOW);
    setLed(0, 255, 0); // vert
    delay(744);
  }

  // Terminé
  setLed(255, 255, 255); // blanc
  delay(7546);

  // Sécurité : relais au repos
  digitalWrite(RELAY, LOW);

  // Eteindre complètement la LED NeoPixel
  pixel.clear();
  pixel.show();

  pinMode(PIN_NEOPIXEL_POWER, OUTPUT);
  digitalWrite(PIN_NEOPIXEL_POWER, LOW);
}

void loop()
{
}

La boucle utilise N_PUSH_BUTTON pour compter les activations du relais. Le choix entre 5 et 6 s’effectue avant le téléversement ; il n’y a pas de détection automatique de la liaison USB du Midiface.

RELAY = A2 ; PIN_NEOPIXEL_POWER = 12 est explicitement déclaré dans ce firmware. Adafruit documente la broche 12 à LOW pour couper l’alimentation du NeoPixel sur le SAMD21/M0.

La compilation et le téléversement sont à vérifier avec l’environnement Arduino utilisé. Conserver la version du core et de la bibliothèque qui fonctionne avec ce fichier.

La connexion de l’USB-C du QT Py au PC sert à programmer le microcontrôleur. Elle ne détermine pas le nombre d’appuis : ce réglage dépend du branchement de l’USB du Midiface pendant son utilisation.

1. Connecter le QT Py seul au PC avec un câble USB-C de données.
2. Préparer Arduino IDE selon le guide officiel Adafruit : support SAMD Adafruit et bibliothèque Adafruit NeoPixel.
3. Ouvrir MidifaceMerger/MidifaceMerger.ino. Conserver const int N_PUSH_BUTTON = 5; par défaut pour une alimentation USB externe du Midiface. Passer à 6 seulement si son USB sera relié à un ordinateur. Sélectionner la carte Adafruit QT Py M0 (SAMD21) et le port correspondant ; vérifier puis téléverser.
4. Débrancher le câble USB-C du QT Py. Effectuer les contrôles d’alimentation, puis réaliser le câblage et les soudures, appareils hors tension.
5. Raccorder les appareils MIDI, puis alimenter le Midiface par son port USB avec la source retenue : alimentation USB externe pour les 5 appuis par défaut, ou ordinateur pour 6 appuis.
6. Contrôler la séquence complète selon la procédure de test.

Prévoir une connexion +5 V facilement débranchable dans le boîtier pour les reprogrammations ultérieures.

Contrôler l’alimentation avant le raccordement, puis vérifier le montage réel avant de refermer le boîtier.

Mesurer le 5 V avant de raccorder le QT Py

1. Le Midiface étant hors tension, repérer les points 5V et GND indiqués sur la photo. Garder le QT Py débranché.
2. Alimenter le Midiface par son port USB et mesurer au multimètre, en mode tension continue, la tension et la polarité entre ces deux points.
3. Débrancher l’alimentation du Midiface et attendre son extinction avant de réaliser les soudures et de raccorder le QT Py.

Contrôles du câblage hors tension

• Contrôler les soudures, l’absence de pont et l’isolation des cartes.
• Vérifier que COM/NO est ouvert au repos, que NC est libre et que seuls les deux contacts SW1 retenus sont raccordés.
• Vérifier qu’aucun câble USB-C ne relie le QT Py au PC.
• Vérifier que le branchement USB du Midiface correspond au nombre d’appuis programmé : 5 sur alimentation USB externe, 6 sur ordinateur.

À chaque essai depuis un démarrage complet

1. Couper l’alimentation du MIDIface ; attendre l’extinction complète avant de la rétablir.
2. Observer le rouge pendant environ 9 s, puis compter 5 activations sur alimentation USB externe, ou 6 si le Midiface est relié à un ordinateur, accompagnées des alternances bleu/vert. Le nombre observé doit correspondre à N_PUSH_BUTTON.
3. Vérifier l’indication du mode MERGE en consultant le manuel du Midiface.
4. Observer le blanc pendant environ 7,5 s, puis le NeoPixel éteint. Le relais doit rester relâché.
5. Laisser l’appareil sous tension au moins une minute : aucun nouvel appui ne doit se produire.
6. Tester le passage des données MIDI selon les connexions décrites dans le manuel du Midiface, puis vérifier que le bouton manuel fonctionne encore.
7. Répéter plusieurs cycles complets ; consigner tout appui manqué et le mode obtenu.

Si le résultat diffère

• Fixer le QT Py et le relais pour qu’ils ne puissent toucher ni le PCB du MIDIface ni les parties conductrices du boîtier.
• Isoler les soudures et borniers exposés ; maintenir les fils sans traction sur les pastilles.
• Conserver l’accès au bouton MODE et à la liaison +5 V débranchable.
• Repérer les fils aux deux extrémités ; identifier distinctement QT Py A2 et SW1 A2.
• Vérifier la tension et le bon fonctionnement pendant les activations du relais avant de refermer le boîtier.
• Intervenir et modifier le câblage hors tension. Ne pas laisser NC raccordé par erreur.

Conserver cette page, le schéma SVG, les photos annotées et le fichier .ino avec l’appareil. Consigner après essai les versions Arduino/core/bibliothèque utilisées et toute différence de matériel.

Le support permet d’organiser l’intégration du QT Py et du relais dans le boîtier du Midiface 4×4 Thru/Merge. Son fichier STL est disponible ci-dessous pour l’impression en 3D.

Vue du support

Rotation à 360°

Montage sur la carte du Midiface

Ce tutoriel est partagé gratuitement par Frédéric Delchambre/Nomadly SRL comme retour d’expérience sur son propre montage, sans garantie de résultat. Toute personne qui choisit de le reproduire doit vérifier la compatibilité de son matériel et reste responsable de ses manipulations. Ces précisions s’appliquent dans les limites prévues par la loi.

Il présente une modification expérimentale et indépendante ; il ne constitue pas une procédure officielle du fabricant.

Interventions et risques

Chaque personne décide de réaliser cette modification à ses propres risques et reste responsable de ses vérifications, de ses choix de matériel et de ses manipulations. Il lui appartient de disposer des compétences nécessaires et de vérifier la compatibilité de son appareil avant toute intervention.

L’ouverture du boîtier, les soudures et les modifications électriques peuvent endommager le MIDIface ou les équipements connectés, provoquer un dysfonctionnement, une perte de données ou des blessures. Elles peuvent également affecter la garantie du fabricant ou les possibilités de prise en charge.

Dans les limites autorisées par le droit applicable, Frédéric Delchambre et Nomadly SRL ne garantissent ni le résultat de cette modification, ni son adéquation à un autre appareil ou à un usage particulier. Ils déclinent toute responsabilité pour les dégâts matériels, pertes de données et frais de réparation ou de remplacement imputables à une erreur de câblage, une manipulation inadaptée, des composants incompatibles ou au non-respect des consignes de sécurité par la personne réalisant la modification.

Marques et droits des tiers

Les marques, noms de produits et logos cités ou visibles, notamment Miditech, MIDIface, Adafruit, QT Py, Pololu et Arduino, appartiennent à leurs titulaires respectifs. Leur mention sert uniquement à identifier le matériel et les outils utilisés. Elle ne revendique aucune affiliation, approbation, certification ou garantie de ces titulaires à l’égard de ce tutoriel ou du montage.

Aucun droit de propriété intellectuelle appartenant à un tiers n’est cédé par ce tutoriel. Les droits des titulaires de marques et des autres ayants droit restent applicables.

Informations légales et coordonnées de Nomadly SRL sur l’accueil du site.