Kit de batterie MIDI sur Python et Arduino : 5 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

J'ai toujours voulu acheter une batterie depuis mon enfance. À l'époque, tous les équipements musicaux n'avaient pas toutes les applications numériques comme nous en avons beaucoup aujourd'hui, d'où les prix et les attentes trop élevés. Récemment, j'ai décidé d'acheter un kit de batterie le moins cher sur eBay, avec la seule priorité: la possibilité de le démonter et d'attacher mon propre matériel et logiciel à l'appareil.

L'achat n'a pas été décevant du tout: kit de batterie portable enroulable avec 9 pads sonores différents, deux pédales de commande au pied pour grosse caisse et charleston et prise d'alimentation micro-USB. Ce qui était vraiment démotivant, ce sont les sons de sortie (l'utilisation réelle de ce kit est de brancher des enceintes externes et d'en profiter). J'ai donc décidé de le convertir en mon propre kit de batterie programmable via USB, basé sur Arduino et une interface utilisateur basée sur Python, pour une utilisation pratique et des modifications faciles comme les sélections de volume, de note et de canal.

Caractéristiques de l'appareil:

• Bas prix
• Création d'un kit de batterie à partir de n'importe quelle entrée numérique - même un ensemble de boutons-poussoirs
• Prise en charge de la communication et alimentation via l'interface USB uniquement - Intégration du convertisseur USB vers UART et du périphérique Arduino
• Pièces minimales pour un bon fonctionnement
• Interface utilisateur basée sur Python facile à utiliser
• Prise en charge MIDI complète avec vélocité, note et broches Arduino réglables
• Enregistrez et chargez les configurations de batterie personnalisées stockées dans la mémoire de l'appareil

Passons au projet…

Étape 1: Théorie du fonctionnement

Diagramme

Tout d'abord, concentrons-nous sur la structure du projet et divisons-la en blocs distincts:

Kit de batterie enroulable

L'unité principale du projet. Il se compose de 9 pads de batterie séparés, où chaque pad est un ensemble de boutons qui changent d'état logique lorsqu'ils sont touchés. En raison de sa structure, il est possible de construire ce kit de batterie particulier à partir de n'importe quel bouton-poussoir. Chaque pad de batterie est connecté à la résistance pull-up sur la carte électronique principale, ainsi, pendant que le pad de batterie est frappé à plusieurs reprises, un interrupteur spécifique est lié à la terre du circuit et un LOW logique est présent sur la ligne de pad de batterie. Lorsqu'aucune pression n'est appliquée, l'interrupteur du pad de batterie est ouvert et en raison de la résistance de rappel vers la ligne d'alimentation, un HAUT logique est présent sur la ligne de pad de batterie. Parce que le but du projet est de créer un appareil MIDI numérique complet, toutes les parties analogiques sur le PCB principal peuvent être négligées. Il est important de noter que ce kit de batterie a deux pédales pour grosse caisse et charleston, qui sont également liées aux résistances pull-up et partagent la même logique de fonctionnement que tous les pads de batterie (nous en discuterons un peu plus tard).

Arduino Pro-Micro

Le cerveau de la batterie. Son but est de détecter s'il y a un signal sortant d'un pad de batterie et de fournir une sortie MIDI appropriée avec tous les paramètres nécessaires: note, vélocité et durée du signal. En raison de la nature numérique des pads de batterie, ils peuvent être simplement liés aux entrées numériques arduino (10 broches au total). Afin de stocker tous les paramètres souhaités et les informations MIDI, nous allons utiliser sa mémoire - EEPROM, donc chaque fois que nous mettons l'appareil sous tension, les informations MIDI sont chargées à partir de l'EEPROM, ce qui la rend reprogrammable et reconfigurable. De plus, Arduino Pro-Micro est disponible dans un très petit emballage et peut être facilement rangé dans le boîtier intérieur du kit de batterie.

Convertisseur FTDI USB vers série

Afin de programmer et de définir les fonctionnalités de notre appareil à l'aide d'une application PC, il est nécessaire de convertir l'interface USB en série, car Arduino Pro-Micro n'a pas d'USB. Étant donné que la communication entre les appareils est basée sur UART, l'appareil FTDI est utilisé dans ce projet, en raison de sa simplicité d'utilisation, quelles que soient ses propriétés supplémentaires.

Application PC - Python

En ce qui concerne le développement d'interfaces utilisateur et de projets rapides à construire, Python est une excellente solution. Le but de l'application d'interface utilisateur est de rendre beaucoup plus pratique la redéfinition des propriétés MIDI de notre kit de batterie, de stocker des informations, de programmer un périphérique et d'établir une communication entre les systèmes sans avoir besoin de compiler le code encore et encore. Parce que nous utilisons une interface série pour communiquer avec le kit de batterie, il existe de nombreux modules gratuits partout sur Internet, qui prennent en charge tous les types de communication série. De plus, comme nous le verrons plus tard, l'interface UART se compose au total de trois broches: RXD, TXD et DTR. DTR est utilisé pour effectuer une réinitialisation sur le module Arduino. Ainsi, lorsque nous souhaitons exécuter une application MIDI ou connecter l'interface utilisateur à un périphérique de programme, il n'est absolument pas nécessaire de rattacher le câble USB ou quoi que ce soit.

Étape 2: Pièces et instruments

les pièces

• Kit de batterie enroulable
• 2 x pédales de sustain (généralement, incluses dans le package DK).
• FTDI - Convertisseur USB vers série
• Arduino Pro Micro
• Câble micro-USB

Instruments

• Fer à souder/Station
• Étain à souder
• Fil à âme unique de diamètre mince
• Pince à épiler
• Coupeur
• Pince
• Couteau
• Tournevis
• Imprimante 3D (en option - pour les plates-formes de pédale personnalisées)

Logiciel

• IDE Arduino
• Python 3 ou supérieur
• JetBrains Pycharme
• Interface MIDI sans poils
• boucleMIDI

Étape 3: Soudure et assemblage

Puisqu'il y a trois modules qui doivent être combinés, le processus de soudure et d'assemblage est court et simple:

• Reliez Arduino Pro-Micro au périphérique FTDI, assurez-vous que les connexions sont conformes aux E/S définies sur chaque périphérique:

  • VBUS-VBUS
  • GND-GND
  • DTR-DTR
  • RXD-TXD
  • TXD-RXD
• Retirez toutes les vis du boîtier en plastique du tambour, assurez-vous que vous pouvez vous concentrer sur le câble pad-to-board et ses résistances de rappel

• Souder des fils minces pour le module Arduino-FTDI que nous avons construit précédemment:

  • Entrées numériques: D[2:11]
  • VBUS
  • J+
  • RÉ-
  • GND
• Insérez le module à l'intérieur du boîtier de la batterie afin que les fils flottent du même côté que les résistances de rappel des pads
• Soudez toutes les entrées numériques aux bornes du pad de batterie comme indiqué sur la dernière figure.
• Soudez le bus micro-USB (VBUS, D+, D-, GND) au périphérique FTDI, assurez-vous qu'il n'y a pas d'erreurs en traçant ces fils.
• Fixez le module Arduino-FTDI avec de la colle chaude au boîtier de la batterie
• Assembler l'appareil avec des vis de fixation appropriées

Nous l'avons fait, l'appareil est assemblé. Continuons avec le code…

Étape 4: Programmation A: Arduino

Décrivons notre croquis étape par étape:

Tout d'abord, il est nécessaire d'inclure deux bibliothèques nécessaires au bon fonctionnement. L'EEPROM est déjà pré-installé dans l'IDE Arduino, mais le module anti-rebond pour grosse caisse doit être installé séparément

#include #include

Ces commutateurs sont principalement utilisés dans les séquences de débogage. Si vous souhaitez essayer la connexion des terminaux Arduino aux pads de batterie et déterminer toutes les entrées numériques, ces commutateurs doivent être définis

/* Commutateurs de développeur: Décommentez le mode souhaité pour le débogage ou l'initialisation *///#define LOAD_DEFAULT_VALUES // Charge les valeurs constantes au lieu de l'EEPROM //#define PRINT_PADS_PIN_NUMBERS // Imprime le numéro de broche qui est connecté à un pad qui a été touché via le port série

Les champs constants représentent toutes les valeurs par défaut, y compris l'énumération des pads de batterie. Afin de faire fonctionner l'appareil pour la toute première fois, il est nécessaire de connaître la connexion exacte des pédales de charleston et de grosse caisse

/* Énumération des types de tambour */

enum DRUM_POSITION { KICK = 0, SNARE, HIHAT, RIDE, CYMBAL1, CYMBAL2, TOM_HIGH, TOM_MID, TOM_LO, HIHAT_PEDAL };

/* Les valeurs par défaut */

const uint8_t DRUM_NOTES[10] = { 36, 40, 42, 51, 49, 55, 47, 45, 43, 48}; const uint8_t DRUM_VELOCITIES[10] = { 110, 100, 100, 110, 110, 110, 110, 110, 110, 110}; const uint8_t DRUM_PINS[10] = { 8, 6, 4, 3, 11, 9, 5, 10, 2, 7 };

/* Durée anti-rebond de grosse caisse */

const uint8_t KICK_DB_DURATION = 30;

L'EEPROM est utilisé pour stocker/charger toutes les données provenant de l'application PC. La plage d'adresses décrite ci-dessus indique l'emplacement exact des informations MIDI pour chaque pad de batterie

/* Mappage des adresses EEPROM

Remarques: |0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09|

Broches: |0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13| Vitesses |0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23| */ const uint8_t NOTES_ADDR = 0x00; const uint8_t VELOCITIES_ADDR = 0x14; const uint8_t PINS_ADDR = 0x0A;

Les variables globales sont utilisées pour déterminer l'état de chaque pad et effectuer la communication MIDI en conséquence

/* Variables globales */

uint8_t drumNotes[10], drumVelocities[10], drumPins[10]; // Variables MIDI

uint8_t uartBuffer[64]; // Buffer UART pour la collecte et le stockage de données MIDI Debouncer kick(DRUM_PINS[KICK], KICK_DB_DURATION); // Objet anti-rebond pour grosse caisse volatile bool previousState[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // États logiques précédents du pad de batterie volatile bool currentState[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // États logiques actuels du pad de batterie

Fonctions EEPROM

/* Stocker les paramètres dans l'EEPROM*/

void storeEEPROM() {

memcpy(Notes de batterie, uartBuffer, 10); memcpy(drumPins, uartBuffer + 10, 10); memcpy(drumVelocities, uartBuffer + 20, 10); pour (uint8_t i = 0; i < 10; i++) EEPROM.write(NOTES_ADDR + i, drumNotes); pour (uint8_t i = 0; i < 10; i++) EEPROM.write(PINS_ADDR + i, drumPins); pour (uint8_t i = 0; i < 10; i++) EEPROM.write(VELOCITIES_ADDR + i, drumVelocities); }

/* Charger les paramètres depuis l'EEPROM*/

void loadEEPROM() { pour (uint8_t i = 0; i < 10; i++) drumNotes = EEPROM.read(NOTES_ADDR + i); pour (uint8_t i = 0; i < 10; i++) drumPins = EEPROM.read(PINS_ADDR + i); pour (uint8_t i = 0; i < 10; i++) drumVelocities = EEPROM.read(VELOCITIES_ADDR + i); }

L'initialisation des variables et le mode de programmation, dans le cas des pédales et du boot Arduino sont activés simultanément

void enterProgrammingMode() {

bool confirmBreak = false; uint8_t lineCnt = 0; uint8_t charCnt = 0; char readChar = 0; while(!confirmBreak) { if (Serial.available()) { uartBuffer[charCnt] = Serial.read(); if (charCnt >= 29) confirmBreak = true; sinon charCnt++; } } Serial.println("OK"); magasinEEPROM(); }

void valeurs init () {

#ifdef LOAD_DEFAULT_VALUES memcpy(drumNotes, DRUM_NOTES, 10); memcpy(drumVelocities, DRUM_VELOCITIES, 10); memcpy(DrumPins, DRUM_PINS, 10); #else loadEEPROM(); #fin si }

Gestionnaires de communication MIDI avec retard de 1 ms de temps de maintien de note

/* Jouer la fonction de note MIDI */

void midiOut(enum DRUM_POSITION drumIn) {

if (drumIn == HIHAT) { // Si HIHAT a été frappé, il est nécessaire de vérifier si la pédale est enfoncée if (!digitalRead(drumPins[HIHAT_PEDAL])) { noteOn(0x90, drumNotes[HIHAT_PEDAL], drumVelocities [HIHAT_PEDAL]); retard(1); noteOn (0x90, drumNotes[HIHAT_PEDAL], 0); } else { noteOn(0x90, drumNotes[HIHAT], drumVelocities[HIHAT]); retard(1); noteOn (0x90, drumNotes[HIHAT], 0); } } else { // Transmission MIDI de batterie normale noteOn(0x90, drumNotes[drumIn], drumVelocities[drumIn]); retard(1); noteOn (0x90, drumNotes[drumIn], 0); } }

void noteOn(int cmd, int pitch, int speed) { Serial.write(cmd); Serial.write(pas); Serial.write(vitesse); }

fonctions setup() et loop() avec boucle de fonctionnement de périphérique infinie:

void setup() {

Serial.begin(115200);

for (uint8_t i = 0; i < 10; i++) { pinMode(i + 2, INPUT); } #ifdef PRINT_PADS_PIN_NUMBERS while(true) { // Boucle de débogage infinie pour (uint8_t i = 0; i < 10; i++) { if (!digitalRead(i + 2)) { Serial.print("Pin No: D"); Serial.print(i + '0'); // Convertit le nombre en caractère ASCII } } } #else initValues(); /* Mode de programmation: Si deux pédales sont enfoncées lors du démarrage - le mode est activé */ si (!digitalRead(drumPins[KICK]) && !digitalRead(drumPins[HIHAT_PEDAL])) enterProgrammingMode(); #fin si }

void loop() { for (uint8_t i = 1; i < 9; i = i + 1) { currentState = digitalRead(drumPins); if (!currentState && previousState) midiOut(i); // Comparer les états et détecter le front descendant previousState = currentState; } kick.update(); // La grosse caisse utilise un algorithme anti-rebond personnalisé if (kick.edge()) if (kick.falling()) midiOut(KICK); }

Étape 5: Programmation B: Python et interface utilisateur

L'interface utilisateur Python est un peu compliquée à comprendre à première vue, nous essaierons donc d'expliquer ses bases, comment l'utiliser, quelle fonction a chaque bouton et comment programmer correctement le périphérique Arduino.

Interface utilisateur - Application

L'interface utilisateur est une représentation graphique de notre programmeur de kit de batterie, ce qui le rend vraiment facile à utiliser et pratique pour programmer un périphérique Arduino à tout moment. L'interface utilisateur se compose de plusieurs modules graphiques qui sont liés à leur opération suggérée. examinons-les un par un:

1. Image de l'ensemble de batterie: l'interface utilisateur Python utilise les coordonnées d'image X-Y pour déterminer le type de batterie sélectionné. Si une région de batterie valide a été sélectionnée, un message IO secondaire s'affiche, avec des champs de note, de vélocité et de terminal Arduino pour le pad de batterie dédié. Une fois ces paramètres vérifiés par l'utilisateur et approuvés, ces valeurs peuvent être transmises directement à l'appareil Arduino.
2. Image du contrôleur externe: Afin de pouvoir utiliser un kit de batterie MIDI avec un environnement de création VST/Music, il est nécessaire d'exécuter l'interpréteur Serial-To-MIDI. J'ai utilisé Hairless, qui est disponible gratuitement et peut être exécuté directement depuis notre interface utilisateur, en appuyant simplement sur son image.
3. Liste des ports COM: afin de communiquer avec Arduino, il est nécessaire de spécifier son port COM connecté. La liste est actualisée en appuyant sur le bouton Actualiser.
4. Charger/enregistrer la configuration: il existe des valeurs MIDI par défaut définies dans le code, qui peuvent être modifiées par l'utilisateur via l'interaction avec l'interface utilisateur. La configuration est définie dans le fichier config.txt dans un format spécifique, qui peut être enregistré ou chargé par l'utilisateur.
5. Bouton Program Device: Afin de stocker toutes les valeurs MIDI modifiées dans l'EEPROM Arduino, il est nécessaire d'appuyer sur deux pédales (Kick drum et Hi-hat pedal) après cela, attendez la fin de la transmission des données. S'il y a eu des problèmes de communication, une fenêtre contextuelle appropriée s'affichera. Si la transmission réussit, l'interface utilisateur affichera son message de réussite.
6. Bouton de sortie: quittez simplement l'application, avec la permission de l'utilisateur.

Points saillants du code Python

Il se passe beaucoup de choses dans le code, nous allons donc développer les fonctions écrites plutôt que l'ensemble du code.

Tout d'abord, pour utiliser l'UI, il faut télécharger plusieurs modules, pour faire fonctionner le code:

importer osimport threading importer tkinter en tant que tk à partir de tkinter importer la boîte de message à partir de tkinter importer * à partir de PIL importer ImageTk, Image importer numpy en tant que np importer serial import glob

Certains modules sont inclus dans le package Python par défaut. Plusieurs modules doivent être installés via l'outil PIP:

pip installer Oreiller

pip installer numpy pip installer ScreenInfo

Il est fortement recommandé d'exécuter l'application via PyCharm. Dans les prochaines versions, je prévois d'exporter un exécutable pour le projet.

Brève explication du code

Il sera beaucoup plus facile de comprendre le code si nous examinons ses lignes du point de vue des fonctions et des classes:

1. La fonction principale - ici le code commence

if _name_ == '_main_': drumkit_gui()

2. Constantes du kit de batterie, coordonnées et informations MIDI par défaut

classe Batterie: DRUM_TYPES = ["Kick", "Hihat", "Snare", "Crash 1", "Crash 2", "Tom High", "Tom Mid", "Tom Low", "Ride", "Hihat Pedal ", "Manette"]

COORDONNÉES_X = [323, 117, 205, 173, 565, 271, 386, 488, 487, 135, 79]

COORDINATES_Y = [268, 115, 192, 40, 29, 107, 104, 190, 71, 408, 208] DIMS_WIDTH = [60, 145, 130, 120, 120, 70, 70, 130, 120, 70, 145] DIMS_LENGTH = [60, 60, 80, 35, 35, 40, 40, 70, 35, 100, 50]

DRUM_ENUM = ["Kick", "Snare", "Hihat", "Ride", "Crash 1", "Crash 2", "Tom High", "Tom Mid", "Tom Low", "Hihat Pedal"]

DRUM_NOTES = [36, 40, 42, 51, 49, 55, 47, 45, 43, 48] DRUM_VELOCITIES = [110, 100, 100, 110, 110, 110, 110, 110, 110, 110] DRUM_PINS = [8, 6, 4, 3, 11, 9, 5, 10, 2, 7]

3. Fonctions UI - Gestion de l'interface utilisateur et des objets graphiques

def set_active(ui)

def secondaire_ui(drum_type)

classe SelectionUi(tk. Frame)

classe Application (tk. Frame)

def drumkit_gui()

def event_ui_clicked(événement)

def getorigin(soi, événement)

4. Communication série

def get_serial_ports()

def communiquer_avec_arduino(port)

5. Travailler avec des fichiers: stocker/charger les paramètres à partir du fichier txt

def save_config()

def load_config()

6. Exécution de l'application externe hairless.exe à partir du code à l'aide des capacités Python Threading

classe ExternalExecutableThread(threading. Thread)

def run_hairless_executable()

Afin d'exécuter le code, il existe une liste de fichiers qui doivent être attachés au dossier du projet:

• config.txt: fichier de paramètres
• hairless.exe: convertisseur MIDI Hairless
• drumkit.png: image qui définit tous les pads de batterie cliquables sur notre interface utilisateur (doit être téléchargé à partir de l'ensemble d'images de cette étape)
• drumgui.py: Le code du projet

C'est tout ce que nous devons souligner pour que cela fonctionne. Il est très important d'ajouter des fichiers au projet: image de batterie, exécutable hairless.exe et fichier de paramètres config.txt.

Et.. C'est fait !:)

J'espère que vous trouverez cette instructable utile.

Merci d'avoir lu!:)