Construire une batterie MIDI compacte avec impression 3D

Composants et fournitures

Composant	Quantité
Arduino UNO	1
Écran LCD 16x2 blanc sur bleu (Adafruit Standard)	1
Piézoélectrique (SparkFun)	1
Capteur de force FSR (Adafruit)	1
Résistance 10 kΩ	1
Résistance 1 MΩ	1
Diode Zener 5,1V 1W (SparkFun)	1
Bouton poussoir 12 mm (SparkFun)	1
Interrupteur à glissière	1
Prise TRS (jack 6,35 mm stéréo)	1
Câble USB-A vers USB-B	1
Adaptateur Apple Lightning vers USB Camera	1

Outils et machines nécessaires

• Imprimante 3D (générique)
• Découpeuse laser (générique) – optionnel
• Fer à souder
• Coupe-cercle
• Clé hexagonale, cutter, perceuse-visseuse, forets 9/10 mm

Applications et services en ligne

• Arduino IDE

À propos de ce projet

Cette batterie MIDI minimaliste utilise un Arduino UNO. Elle se compose de deux parties :

1. Pads imprimés en 3D et renforcés de papier épais (1 mm).
2. Convertisseur déclencheur → MIDI sur Arduino UNO.

Le signal des pads est traité par l'Arduino et converti en MIDI, transmis via USB vers iPhone, ordinateur, etc. Aucune alimentation externe n'est nécessaire : l'Arduino est alimenté par l'appareil hôte (smartphone/PC).

Basé sur cet article Arduino.

Matériel nécessaire

Outils

• Imprimante 3D, découpeuse laser (optionnel), clé hexagonale, cutter, coupe-cercle, fer à souder, coupe-tube, perceuse-visseuse, forets 9/10 mm

Matériaux

• Papier épais 1 mm, filament PLA, mousse éponge 5/10 mm, MDF 2,5/5,5 mm (optionnel)
• Boulons/écrous : M6×70, M6×50, M3×10, M3×15, M3×25, vis M2
• Tube inox Ø13 mm

Quincaillerie batterie

• Peaux maillées (mesh heads) 10″ et 8″
• Pied de caisse claire (ex: Yamaha SS662)
• Pied de charleston (ex: Yamaha HS650A)
• Pédale grosse caisse (ex: Yamaha FP7210A)
• Baguettes

Étape 1 : Impression 3D

Tous les fichiers sur Thingiverse et GitHub. Utilisez la version 2 pour les cerclages (rims). Impression : remplissage 20 %, hauteur de couche 0,3 mm. La découpe laser est possible pour les pads (fichiers vectoriels fournis).

Étape 2 : Assemblage des pads

Boulons M3×10 mm pour l'assemblage principal. Boulons M3×15 ou M3×25 mm pour la partie centrale fixant le fond.

Étape 3 : Fabrication du corps (shell)

Hauteur du corps : 55 mm. Découpez trois bandes de 55 mm de large, longueur légèrement supérieure au tour du pad. Insérez une bande dans l'interstice du bas, ajustez pour former un cercle parfait, collez. Répétez 3 fois en superposant. Une fois sec, fixez la peau maillée, percez un trou Ø9 mm pour la prise. Utilisez des écrous papillon ou les clés de tension imprimées fournées. Fixation peau : boulons M6×70 mm. Retirez la peau pour placer le piézo.

Étape 4 : Montage des piézos

Caisse claire (snare) – 2 piézos : Fil rouge de chaque piézo sur tip et ring ; les deux fils noirs sur sleeve. Passez les câbles dans les trous de la plaque capteur avant de souder. Piézo tête (tip) : sandwich mousse 10 mm (1 dessous, 3 dessus en cônes). Placez sur plaque capteur.

Grosse caisse (kick) – 1 piézo : Seul tip utilisé. Pas de plaque capteur. 2 mousses sous le piézo. Position décentrée (évite que le batteur frappe le capteur directement, ce qui fausse la vélocité).

Charleston (hi-hat) – 1 piézo : Même circuit que kick. 1 mousse 10 mm sous le piézo.

Attention : les piézos sont fragiles, ne les pliez pas.

Étape 5 : Pad caisse claire 10″

Fixez d'abord le capteur de rim (cerclage). Fixez solidement la plaque capteur : l'extrémité des cônes doit dépasser de 2-3 mm vu de côté. Même procédure pour un pad 8″ utilisé comme caisse claire.

Étape 6 : Pad grosse caisse 8″

Coupez le tube inox Ø13 mm : 2 × 200 mm + 2 × 365 mm (longueur ajustable). Assemblez selon photos. Les écrous M3 s'insèrent dans les pièces prévues. Fixez solidement avec boulons M3×15 mm.

Étape 7 : Charleston 12″

Corps en papier épais : découpez 3 cercles Ø300 mm. Fente depuis le centre, puis seconde fente à 10 mm parallèlement → 3 « Pac-Man » à petite ouverture. Fermez l'ouverture avec du ruban pour former la forme cymbale. Collez les 3 couches (colle fine et uniforme), pressez fermement, séchez sous poids. Silencieux : mousse 5 mm + perçage (trou caché). Fixez support capteur et guide-câble au ruban double-face (ou pistolet à colle).

Étape 8 : Contrôleur charleston (hi-hat controller)

Envoie l'ouverture/fermeture du charleston à l'Arduino. Circuit simple : 3 pièces. FSR collé sur la partie basse, prise fixée. Mousse 10 mm sur FSR. Couvercle fixé par boulons M3×10 mm. Pourquoi FSR pour un simple ON/OFF ? Pour compatibilité modules sons (Roland, Yamaha) et logiciels (EZ Drummer 2) qui gèrent plusieurs degrés d'ouverture. Le FSR permettrait une gestion continue en modifiant le code (non testé).

Étape 9 : USB-MIDI (Arduino reconnu comme périphérique MIDI)

L'Arduino UNO standard n'est pas reconnu comme périphérique MIDI par iOS. Il faut reflasher le microcontrôleur USB (ATmega16U2) avec le firmware dualMoco.hex (projet MocoLUFA).

1. Suivez la procédure DFU Programming 8U2/16U2.
2. Remplacez Arduino-usbserial-uno.hex par dualMoco.hex :
   sudo dfu-programmer atmega16u2 flash dualMoco.hex
3. Après flashage, l'Arduino est vu comme périphérique MIDI.
4. Pour reprogrammer l'Arduino (via IDE), court-circuitez les deux plots indiqués sur la photo (reset USB) ; sinon il reste en mode MIDI.

Étape 10 : Convertisseur déclencheur → MIDI (Shield Arduino)

Boîtier imprimé 3D (couvercle aussi, ou découpe laser). Shield selon schéma Fritzing. Diodes de protection (peut-être inutiles si protection intégrée Arduino).

Étape 11 : Jouer avec GarageBand

Lancez GarageBand, connectez : aucune configuration complexe. Autres DAW compatibles (Hydrogen gratuit, permet d'ajouter des sons).

Étape 12 : Réglages (via boutons et LCD)

Interface de réglage intégrée pour éviter de recompiler. Boutons : INC/DEC (valeur), NEXT/BACK (paramètre), EDIT (validation).

• THRESHOLD : Seuil minimal de détection.
• SENSITIVITY : Sensibilité. Valeur basse = vélocité élevée même coup faible.
• NOTE : Numéro de note MIDI (change l'instrument).
• FLAG : Seuil fin de frappe (1-10 recommandé). Trop haut = double déclenchement ; trop bas = pertes en frappe rapide.
• SCAN TIME : Fenêtre de recherche du pic (ms). Inutile à modifier.
• HEAD/RIM : Difficulté déclenchement rim. Monter = plus dur ; trop bas = rim sonne sur frappe tête. Logique perfectible.
• PEDAL VELO : Vélocité fixe pédale (défaut 100).
• MASK TIME : Lié à FLAG. Inutile à modifier. Trop haut = pertes en frappe continue.

Étape 13 : Fichiers Fusion 360

Certaines pièces nécessitent des ajustements dimensionnels. STL difficile à modifier → fichiers Fusion 360 fournis : GitHub. Historique de conception parfois chaotique (essais/erreurs), ne pas trop s'y fier.

Extras

Étapes supplémentaires sur Instructables et blog détaillé. N'hésitez pas à poser des questions. Amusez-vous bien !

Code

Hello Drum v2 (Arduino)

/* Drum MIDI Controller
   Created: 28/06/2017 by Ryo Kosaka as "HELLO DRUM" Ver.1.0
   Modified: 05/12/2019 by George Brotherston */
#include 
#include 

// Variables programme
boolean bSnareFlag = false, bHihatFlag = false, bKickFlag = false, bPedalFlag = false;
boolean bButtonState = true, bButtonState_set = true;
int iUPDOWN = 0, iNEXTBACK = 0;

// Tableaux instruments : {threshold, sensitivity, note, flag, velocity, iPeakValue}
int aSNARE[6]      = {150, 950, 38, 3, 0, 0};
int aSNARE_RIM[6]  = {5,   500, 37, 3, 0, 0};
int aHIHAT[6]      = {100, 800, 46, 1, 0, 0};
int aHIHAT_CLOSE[6]= {100, 800, 42, 1, 0, 0};
int aKICK[6]       = {200, 700, 36, 1, 0, 0};

// Pédale charleston : {scantime, snare/rim, pedalVelocity, masktime}
int aHIHAT_PEDAL[4] = {600, 0, 44, 0};

// Réglages : {threshold, sensitivity, note, flag}
int aSETTING[4] = {4, 500, 100, 1};

// LCD
const int rs=12, en=11, d4=5, d5=4, d6=3, d7=2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
MIDI_CREATE_DEFAULT_INSTANCE();

void setup() {
  MIDI.begin(10);
  lcd.begin(16, 2);
  lcd.print("INITIALISING...");
  lcd.setCursor(0, 1);
  lcd.print("DRUM MIDI CONTROLLER");
  pinMode(6, INPUT_PULLUP); // Set
  pinMode(7, INPUT_PULLUP); // Up
  pinMode(8, INPUT_PULLUP); // Down
  pinMode(9, INPUT_PULLUP); // Next
  pinMode(10, INPUT_PULLUP);// Back
}

void loop() {
  // Lecture boutons
  int iButton_set = digitalRead(6);
  int iButton_up  = digitalRead(7);
  int iButton_down= digitalRead(8);
  int iButton_next= digitalRead(9);
  int iButton_back= digitalRead(10);
  
  // Lecture capteurs
  int iPiezoValue_A0 = analogRead(A0); // Snare Head
  int iPiezoValue_A1 = analogRead(A1); // Snare Rim
  int iPiezoValue_A2 = analogRead(A2); // Hi-hat
  int iPiezoValue_A3 = analogRead(A3); // Kick
  int iFSRValue_A4   = analogRead(A4); // Hi-hat Pedal
  
  // ... (logique complète de gestion menu, détection pics, envoi MIDI, voir code source original)
  // Le code complet est disponible dans le dépôt GitHub.
}

Schémas

circuit_nZotR7rJMM.fzz (Fritzing)