MIDI trommesæt på Python og Arduino: 5 trin (med billeder)

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:26

Jeg har altid ønsket at købe et trommesæt, siden jeg var barn. Dengang havde alt musikudstyr ikke alle de digitale applikationer, da vi har masser af i dag, derfor var priserne sammen med forventningerne for høje. For nylig har jeg besluttet at købe et billigste trommesæt fra eBay, med den eneste prioritet: Mulighed for at rive det ned og vedhæfte min egen hardware og software til enheden.

Købet var slet ikke skuffende: Bærbart roll-up trommesæt med 9 forskellige lydpuder, to fodkontaktpedaler til kick tromme og hi-hat og mikro-USB stikkontakt. Hvad der virkelig var demotiverende, det er outputlydene (Faktisk brug til dette kit er at tilslutte ekstern højttaler og nyde det). Så jeg besluttede at konvertere det til min egen programmerbare via USB, MIDI -trommesæt baseret på Arduino og brugergrænseflade baseret på Python, til praktisk brug og lette ændringer som f.eks. Volumen, note og kanalvalg.

Enhedens funktioner:

• Lav pris
• Oprettelse af trommesæt fra alle digitale indgange - endda mange trykknapper
• Kommunikationssupport og strømforsyning kun via USB -interface - Integration af USB til UART -konverter og Arduino -enhed
• Mininum dele til korrekt drift
• Let at bruge Python-baseret brugergrænseflade
• Komplet MIDI -understøttelse med justerbar hastighed, note og Arduino -ben
• Gem og indlæs brugerdefinerede tromlekonfigurationer, der er gemt i enhedens hukommelse

Lad os gå videre til projektet …

Trin 1: Teori om drift

Blokdiagram

Lad os først fokusere på projektstrukturen og opdele den i separate blokke:

Roll-up trommesæt

Projektets hovedenhed. Den består af 9 separate tromlepuder, hvor hver pude er en række knapper, der ændrer deres logiske tilstand, mens de bliver ramt. På grund af dets struktur er der mulighed for at konstruere dette særlige trommesæt fra enhver trykknap. Hver tromlepude er forbundet til pull-up-modstanden på det elektroniske hovedkort, så mens tromlepuden bliver ramt gentagne gange, bindes en specifik switch til kredsløbets jord, og der er logisk LOW på tromlepuden. Når der ikke påføres noget tryk, er tromlepudekontakten åben, og på grund af pull-up-modstand til kraftledningen er der logisk HØJT på tromlepuden. Fordi formålet med projektet er at oprette en komplet digital MIDI -enhed, kan alle de analoge dele på hovedkortet negligeres. Det er vigtigt at bemærke, at trommesættet har to pedaler til sparketromle og hi-hat, som også er bundet til pull-up-modstandene og deler den samme driftslogik som alle tromlepuderne (Vi diskuterer det lidt senere).

Arduino Pro-Micro

Trommesættets hjerne. Dens formål er at opdage, om der kommer et signal ud af en tromlepude og tilvejebringe passende MIDI -output med alle de nødvendige parametre: Bemærk, hastighed og varighed af signal. På grund af trommepudernes digitale karakter kan de simpelthen bindes til arduino digitale indgange (i alt 10 ben). For at gemme alle de ønskede indstillinger og MIDI-oplysninger kommer vi til at bruge dens hukommelse-EEPROM, derfor indlæses MIDI-oplysninger hver gang vi tænder enheden fra EEPROM, hvilket gør den omprogrammerbar og genkonfigurerbar. Arduino Pro-Micro fås også i en meget lille pakke og kan let tildeles i trommesættets inderkasse.

FTDI USB til seriel konverter

For at programmere og definere vores enhedsfunktioner ved hjælp af pc-applikationer er der behov for at konvertere USB-interface til seriel, fordi Arduino Pro-Micro ikke har USB. Da kommunikationen mellem enheder er baseret på UART, bruges FTDI -enheden i dette projekt på grund af dets enkle anvendelse uanset dens yderligere egenskaber.

PC -applikation - Python

Når det kommer til udvikling af brugergrænseflader og hurtige at bygge-projekter, er Python en fremragende løsning. Formålet med UI -applikation er at gøre det meget mere bekvemt at omdefinere MIDI -egenskaber til vores trommesæt, gemme oplysninger, programmere enheden og kommunikere mellem systemerne uden at skulle samle koden igen og igen. Fordi vi bruger seriel grænseflade til at kommunikere med trommesæt, er der masser af gratis moduler rundt omkring på internettet, der understøtter enhver form for seriel kommunikation. Som det vil blive diskuteret senere, består UART -grænsefladen desuden af i alt tre ben: RXD, TXD og DTR. DTR bruges til at udføre nulstilling på Arduino -modul, så når vi er interesseret i at køre MIDI -app eller tilslutte UI til programmeringsenhed, er det absolut ikke nødvendigt at tilslutte USB -kabel igen eller overhovedet.

Trin 2: Dele og instrumenter

Dele

• Roll-up trommesæt
• 2 x Sustain Pedals (Normalt inkluderet i DK -pakken).
• FTDI - USB til seriel konverter
• Arduino Pro Micro
• Micro-USB-kabel

Instrumenter

• Loddejern/Station
• Loddetin
• Tynd Diameter Enkeltkern
• Pincet
• Skærer
• Tang
• Kniv
• Skruetrækker
• 3D -printer (valgfri - til tilpassede pedalplatforme)

Software

• Arduino IDE
• Python 3 eller højere
• JetBrains Pycharm
• Hårløs MIDI -interface
• loopMIDI

Trin 3: Lodning og samling

Da der er tre moduler, der skal kombineres, er lodde- og samlingsprocessen kort og enkel:

• Sæt Arduino Pro-Micro sammen med FTDI-enhed, sørg for at forbindelserne overholder I/O defineret på hver enhed:

  • VBUS-VBUS
  • GND-GND
  • DTR-DTR
  • RXD-TXD
  • TXD-RXD
• Fjern alle skruerne fra tromle plastik kabinet, sørg for at du kan fokusere på pad-to-board kabel, og dens pull-up modstande

• Lodde tynde ledninger til Arduino-FTDI modul, som vi tidligere har konstrueret:

  • Digitale indgange: D [2:11]
  • VBUS
  • D+
  • D-
  • GND
• Indsæt modulet i batterikassen, så ledningerne flyder på samme side som pull-up-modstande på puder
• Lod alle digitale indgange til tromlepudeterminalerne, som det er vist i den sidste figur.
• Loddemikro-USB-bus (VBUS, D+, D-, GND) til FTDI-enhed, sørg for, at der ikke er fejl ved sporing af disse ledninger.
• Fastgør Arduino-FTDI-modulet med varm lim til batterikassen
• Monter enheden med passende skruer

Vi har gjort det, enheden er samlet. Lad os fortsætte til koden …

Trin 4: Programmering A: Arduino

Lad os beskrive vores skitse trin for trin:

Først og fremmest er der behov for at inkludere to nødvendige biblioteker for den korrekte drift. EEPROM er allerede forudinstalleret i Arduino IDE, men debouncer-modulet til sparketromle skal installeres separat

#include #include

Disse switches bruges hovedsageligt i fejlsøgningssekvenser. Hvis du vil prøve Arduino -terminalernes forbindelse til tromlepuderne og bestemme alle de digitale indgange, skal disse switche defineres

/ * Udviklerkontakter: Ukommenteret ønsket tilstand til fejlfinding eller initialisering * ///#definere LOAD_DEFAULT_VALUES // Indlæs konstante værdier i stedet for EEPROM //#definere PRINT_PADS_PIN_NUMBERS // Udskriv pin -nummer, der er forbundet til en blok, der blev ramt via seriel port

Konstante felter repræsenterer alle standardværdier, herunder tromlepudeopregning. For at køre enheden for allerførste gang er der brug for at kende den nøjagtige forbindelse mellem Hi-Hat og Kick pedaler

/ * Opstilling af tromletype */

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

/* Standardværdier */

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};

/ * Kick drum debounce varighed */

const uint8_t KICK_DB_DURATION = 30;

EEPROM bruges til at gemme/indlæse alle de data, der kommer fra pc -applikationen. Adresserne, der er beskrevet ovenfor, viser den nøjagtige placering for MIDI -oplysninger for hver tromlepude

/* EEPROM Adresser kortlægning

Bemærkninger: | 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 |

Stifter: | 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13 | Hastigheder | 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;

Globale variabler bruges til at bestemme hver pads tilstand og udføre MIDI -kommunikation i overensstemmelse hermed

/ * Globale variabler */

uint8_t drumNotes [10], drumVelocities [10], drumPins [10]; // MIDI -variabler

uint8_t uartBuffer [64]; // UART -buffer til indsamling og lagring af MIDI Data Debouncer kick (DRUM_PINS [KICK], KICK_DB_DURATION); // Debouncer -objekt til kick drum volatile bool previousState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Tromlepude tidligere logik angiver flygtig bool currentState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Drum pad nuværende logiske tilstande

EEPROM funktioner

/* Gem indstillinger i EEPROM*/

void storeEEPROM () {

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

/* Indlæs indstillinger fra EEPROM*/

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

Initialisering af variabler og programmeringstilstand, i tilfælde af pedaler og Arduino -boot aktiveres samtidigt

void enterProgrammingMode () {

bool confirmBreak = falsk; uint8_t lineCnt = 0; uint8_t charCnt = 0; char readChar = 0; mens (! confirmBreak) {if (Serial.available ()) {uartBuffer [charCnt] = Serial.read (); hvis (charCnt> = 29) confirmBreak = true; ellers charCnt ++; }} Serial.println ("OK"); storeEEPROM (); }

ugyldige initValues () {

#ifdef LOAD_DEFAULT_VALUES memcpy (drumNotes, DRUM_NOTES, 10); memcpy (drumVelocities, DRUM_VELOCITIES, 10); memcpy (drumPins, DRUM_PINS, 10); #else loadEEPROM (); #Afslut Hvis }

MIDI -kommunikationsbehandlere med en forsinkelse på 1ms note holdetid

/ * Afspil MIDI -note -funktion */

void midiOut (enum DRUM_POSITION drumIn) {

hvis (drumIn == HIHAT) {// Hvis HI-HAT blev ramt, skal der kontrolleres, om der trykkes på pedal, hvis (! digitalRead (drumPins [HIHAT_PEDAL])) {noteOn (0x90, drumNotes [HIHAT_PEDAL], drumVelocities [HIHAT_PEDAL]); forsinkelse (1); noteOn (0x90, drumNotes [HIHAT_PEDAL], 0); } else {noteOn (0x90, drumNotes [HIHAT], drumVelocities [HIHAT]); forsinkelse (1); noteOn (0x90, drumNotes [HIHAT], 0); }} else {// Almindelig tromme MIDI -transmission noteOn (0x90, drumNotes [drumIn], drumVelocities [drumIn]); forsinkelse (1); noteOn (0x90, drumNotes [drumIn], 0); }}

void noteOn (int cmd, int pitch, int velocity) {Serial.write (cmd); Serial.write (tonehøjde); Serial.write (hastighed); }

setup () og loop () funktioner med uendelig enhedsdriftsløjfe:

ugyldig opsætning () {

Serial.begin (115200);

for (uint8_t i = 0; i <10; i ++) {pinMode (i+2, INPUT); } #ifdef PRINT_PADS_PIN_NUMBERS mens (true) {// Uendelig fejlfindingssløjfe for (uint8_t i = 0; i <10; i ++) {if (! digitalRead (i+2)) {Serial.print ("Pin No: D"); Serial.print (i + '0'); // Konverter tal til ASCII -tegn}}} #else initValues (); / * Programmeringstilstand: Hvis der trykkes på to pedaler under opstart - tilstanden er aktiveret */ hvis (! DigitalRead (drumPins [KICK]) &&! DigitalRead (drumPins [HIHAT_PEDAL])) indtastProgrammingMode (); #Afslut Hvis }

void loop () {for (uint8_t i = 1; i <9; i = i + 1) {currentState = digitalRead (drumPins ); if (! currentState && previousState ) midiOut (i); // Sammenlign tilstande, og opdag faldende kant previousState = currentState ; } kick.update (); // Kick drum bruger brugerdefineret debounce -algoritme if (kick.edge ()) if (kick.falling ()) midiOut (KICK); }

Trin 5: Programmering B: Python og brugergrænseflade

Python -brugergrænseflade er lidt kompliceret at forstå ved første øjekast, derfor ville vi prøve at forklare dets grundlæggende, hvordan man bruger, hvilken funktion har hver knap og hvordan man programmerer Arduino -enheden korrekt.

Brugergrænseflade - applikation

UI er en grafisk fremstilling for vores trommesætprogrammerer, hvilket gør den virkelig let at bruge og praktisk at programmere Arduino -enheden når som helst. UI består af flere grafiske moduler, der er knyttet til deres foreslåede drift. lad os gennemgå dem en efter en:

1. Trommesætbillede: Python UI bruger XY-billedkoordinater til at bestemme hvilken tromletype der blev valgt. Hvis der blev valgt et gyldigt tromleregion, vises den sekundære IO -meddelelse med notefelter, hastighed og Arduino -terminal til dedikeret tromlepude. Når disse parametre er verificeret af brugeren og godkendt, kan disse værdier overføres direkte til Arduino -enheden.
2. Eksternt controllerbillede: For at kunne bruge MIDI-trommesæt med VST/musikskabende miljø er der behov for at køre Serial-to-MIDI-tolk. Jeg har brugt Hairless, som er tilgængelig gratis og kan køres direkte fra vores brugergrænseflade, bare ved at trykke på dens billede.
3. COM -portliste: For at kommunikere med Arduino er der behov for at angive den tilknyttede COM -port. Listen opdateres ved at trykke på knappen Opdater.
4. Indlæs/gem konfiguration: Der er standard MIDI -værdier defineret i koden, som kan ændres af brugeren via interaktion med UI. Konfiguration er defineret i filen config.txt i et specifikt format, som kan gemmes eller indlæses af brugeren.
5. Program-knap: For at gemme alle de ændrede MIDI-værdier i Arduino EEPROM, er der behov for at trykke på to fodpedaler (sparketromle og Hi-hat-pedal) derefter, vente på overførsel af data for at fuldføre. Hvis der var kommunikationsproblemer, vises korrekt pop-up. Hvis transmissionen lykkes, viser UI sin vellykkede besked.
6. Afslut -knap: Afslut bare programmet med brugerens tilladelse.

Python -kodehøjdepunkter

Der er mange ting, der foregår i koden, så vi vil udvide de skrevne funktioner frem for hele koden.

Først og fremmest er der brug for at downloade flere moduler for at kunne bruge UI for at få koden til at fungere:

import osimport threading import tkinter som tk fra tkinter import messagebox fra tkinter import * fra PIL import ImageTk, Image import numpy som np import seriel import glob

Nogle af modulerne er inkluderet i standard Python -pakken. Flere moduler skal installeres via PIP -værktøj:

pip installer Pude

pip install numpy pip install ScreenInfo

Det anbefales kraftigt at køre applikation via PyCharm. I de fremtidige udgivelser planlægger jeg at eksportere en eksekverbar fil til projektet.

Kort kode Forklaring

Det vil være meget lettere at forstå koden, hvis vi ville se på dens linjer ud fra funktioner og klasser:

1. Hovedfunktionen - her starter koden

hvis _name_ == '_main_': drumkit_gui ()

2. Trommesætkonstanter, koordinater og standard MIDI -oplysninger

klasse Trommer: DRUM_TYPES = ["Kick", "Hihat", "Snare", "Crash 1", "Crash 2", "Tom High", "Tom Mid", "Tom Low", "Ride", "Hihat Pedal "," Controller "]

COORDINATES_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_LÆNGDE = [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. UI -funktioner - Håndtering af brugergrænseflade og grafiske objekter

def set_active (ui)

def sekundær_ui (drum_type)

klasse SelectionUi (tk. Frame)

klasse ansøgning (tk. Frame)

def drumkit_gui ()

def event_ui_clicked (begivenhed)

def getorigin (selv, begivenhed)

4. Seriel kommunikation

def get_serial_ports ()

def communic_with_arduino (port)

5. Arbejde med filer: Gem/indlæs indstillinger fra txt -filen

def save_config ()

def load_config ()

6. Kører ekstern applikation hairless.exe fra koden ved hjælp af Python Threading -funktioner

klasse ExternalExecutableThread (threading. Thread)

def run_hairless_executable ()

For at køre koden er der en liste over filer, der skal vedhæftes projektmappen:

• config.txt: Indstillingsfil
• hairless.exe: Hårløs MIDI -konverter
• drumkit.png: Billede, der definerer alle de klikbare trommepuder i vores brugergrænseflade (skal downloades fra dette trin 'billedsæt)
• drumgui.py: Projektkoden

Det er alt, hvad vi skal understrege for at få det til at fungere. Det er meget vigtigt at tilføje filer til projektet: trommesætbillede, hairless.exe -eksekverbar og indstillingsfil config.txt.

Og.. Her har vi gjort!:)

Håber du finder denne instruktive nyttig.

Tak fordi du læste!:)