MIDI Drum Kit på Python och Arduino: 5 steg (med bilder)

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:39

Jag har alltid velat köpa ett trumset sedan jag var liten. Då hade all musikutrustning inte alla digitala applikationer eftersom vi har gott om idag, därför var priserna tillsammans med förväntningarna för höga. Nyligen har jag bestämt mig för att köpa ett billigaste trumset från eBay, med den enda prioriteten: Möjligheten att riva det och fästa min egen hårdvara och programvara till enheten.

Köpet var inte alls en besvikelse: Bärbart roll-up trumset med 9 olika ljudkuddar, två fotpedaler för kick trumma och hi-hat och mikro-USB eluttag. Det som verkligen var demotiverande, det är utgångsljuden (Faktisk användning för detta kit är att ansluta extern högtalare och njuta av den). Så jag bestämde mig för att konvertera den till min egen programmerbara via USB, MIDI -trumset baserat på Arduino och användargränssnitt baserat på Python, för praktisk användning och enkla ändringar som, volym, anteckning och kanalval.

Enhetens funktioner:

• Lågt pris
• Skapa trumset från alla digitala ingångar - till och med en mängd tryckknappar
• Kommunikationsstöd och strömförsörjning endast via USB -gränssnitt - Integration av USB till UART -omvandlare och Arduino -enhet
• Mininum delar för korrekt drift
• Lätt att använda Python-baserat gränssnitt
• Komplett MIDI -stöd med justerbar hastighet, notering och Arduino -stift
• Spara och ladda anpassade trumkonfigurationer lagrade i enhetens minne

Låt oss gå vidare till projektet …

Steg 1: Operationsteori

Blockdiagram

Låt oss först fokusera på projektstrukturen och dela den i separata block:

Roll-up trumset

Projektets huvudenhet. Den består av 9 separata trumkuddar, där varje kudde är en uppsättning knappar som ändrar deras logiska tillstånd medan de träffas. På grund av dess struktur finns det en möjlighet att konstruera just detta trumset med valfri tryckknapp. Varje trumplatta är ansluten till uppdragningsmotståndet på det elektroniska huvudkortet, så medan trumkudden träffas upprepade gånger, knyts en specifik strömbrytare till kretsens mark och logisk LÅG finns på trumdynan. När inget tryck appliceras, är trumkuddsbrytaren öppen och på grund av uppdragningsmotståndet till kraftledningen finns logiskt HÖG på trumdynan. Eftersom syftet med projektet är att skapa en komplett digital MIDI -enhet kan alla analoga delar på huvudkortet försummas. Det är viktigt att notera att trumset har två pedaler för kick trumma och hi-hat, som också är knutna till uppdragningsmotstånden och delar samma driftlogik som alla trumkuddar (Vi kommer att diskutera det lite senare).

Arduino Pro-Micro

Hjärnan i trumset. Dess syfte är att upptäcka om det kommer en signal från en trumdynan och ge lämplig MIDI -utgång med alla nödvändiga parametrar: Notera, hastighet och signalens varaktighet. På grund av trumkuddarnas digitala karaktär kan de enkelt kopplas till arduino digitala ingångar (totalt 10 stift). För att lagra alla önskade inställningar och MIDI-information kommer vi att använda dess minne-EEPROM, därför laddas MIDI-information varje gång vi startar enheten från EEPROM, vilket gör den omprogrammerbar och omkonfigurerbar. Arduino Pro-Micro finns också i ett mycket litet paket och kan enkelt delas in i trumset inre fodral.

FTDI USB till seriell omvandlare

För att programmera och definiera våra enhetsfunktioner med hjälp av PC-applikation, måste USB-gränssnittet konverteras till seriellt, eftersom Arduino Pro-Micro inte har USB. Eftersom kommunikationen mellan enheter är baserad på UART används FTDI -enheten i detta projekt, på grund av dess enkelhet oavsett dess ytterligare egenskaper.

PC -applikation - Python

När det gäller utveckling av användargränssnitt och projekt som är snabba att bygga är Python en utmärkt lösning. Syftet med UI -applikationen är att göra det mycket mer bekvämt att omdefiniera MIDI -egenskaper för vårt trumset, lagra information, programmera enhet och kommunicera mellan systemen utan att behöva kompilera koden om och om igen. Eftersom vi använder seriellt gränssnitt för att kommunicera med trumset finns det gott om gratis moduler runt om på internet som stöder alla typer av seriell kommunikation. Dessutom, som det kommer att diskuteras senare, består UART -gränssnittet av totalt tre stift: RXD, TXD och DTR. DTR används för att utföra återställning på Arduino -modulen, så när vi är intresserade av att köra MIDI -app eller ansluta UI till programmeringsenhet, är det absolut inte nödvändigt att ansluta USB -kabeln eller något annat.

Steg 2: Delar och instrument

Delar

• Roll-up trumset
• 2 x Sustain Pedals (ingår vanligtvis i DK -paketet).
• FTDI - USB till seriell omvandlare
• Arduino Pro Micro
• Micro-USB-kabel

Instrument

• Lödkolv/station
• Lödtenn
• Enkel kärntråd med tunn diameter
• Pincett
• Fräs
• Tång
• Kniv
• Skruvmejsel
• 3D -skrivare (tillval - för anpassade pedalplattformar)

programvara

• Arduino IDE
• Python 3 eller högre
• JetBrains Pycharm
• Hårlöst MIDI -gränssnitt
• loopMIDI

Steg 3: Lödning och montering

Eftersom det finns tre moduler som måste kombineras är lödnings- och monteringsprocessen kort och enkel:

• Anslut Arduino Pro-Micro med FTDI-enhet, se till att anslutningarna överensstämmer med I/O som definieras på varje enhet:

  • VBUS-VBUS
  • GND-GND
  • DTR-DTR
  • RXD-TXD
  • TXD-RXD
• Ta bort alla skruvar från trumplasthöljet, se till att du kan fokusera på pad-to-board-kabel och dess uppdragningsmotstånd

• Löd tunna trådar för Arduino-FTDI-modul som vi har konstruerat tidigare:

  • Digitala ingångar: D [2:11]
  • VBUS
  • D+
  • D-
  • GND
• Sätt in modulen inuti batterilådan så att ledningarna flyter på samma sida som uppdragningsmotstånden på dynorna
• Löd alla digitala ingångar till trumplattans terminaler som det visas i den sista figuren.
• Löd mikro-USB-buss (VBUS, D+, D-, GND) till FTDI-enhet, se till att det inte finns några misstag vid spårning av dessa ledningar.
• Fäst Arduino-FTDI-modulen med varmt lim på batterifodralet
• Montera enheten med lämplig skruvfäste

Vi har gjort det, enheten är monterad. Låt oss fortsätta till koden …

Steg 4: Programmering A: Arduino

Låt oss beskriva vår skiss steg-för-steg:

Först och främst måste det finnas två nödvändiga bibliotek för att den ska fungera korrekt. EEPROM är redan förinstallerat i Arduino IDE, men debouncer-modulen för kick drum måste installeras separat

#inkludera #inkludera

Dessa switchar används huvudsakligen i felsökningssekvenser. Om du vill prova anslutningen till Arduino -terminalerna till trumkuddarna och bestämma alla digitala ingångar, bör dessa omkopplare definieras

/ * Utvecklare växlar: Ej önskat läge för felsökning eller initiering * ///#definiera LOAD_DEFAULT_VALUES // Ladda konstanta värden i stället för EEPROM //#definiera PRINT_PADS_PIN_NUMBERS // Skriv ut pin -nummer som är anslutet till en pad som träffades via serieport

Konstanta fält representerar alla standardvärden, inklusive trummans uppräkning. För att köra enheten för första gången måste du veta exakt anslutning av Hi-Hat och Kick-pedaler

/ * Uppräkning av trumtyp */

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

/* Ursprungliga värden */

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 varaktighet */

const uint8_t KICK_DB_DURATION = 30;

EEPROM används för att lagra/ladda all data som kommer från PC -applikationen. Adresserna som beskrivs ovan visar exakt plats för MIDI -information för varje trumkudde

/* EEPROM Adresseringar

Anmärkningar: | 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 |

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

Globala variabler används för att bestämma varje padens tillstånd och utföra MIDI -kommunikation i enlighet därmed

/ * Globala variabler */

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

uint8_t uartBuffer [64]; // UART -buffert för insamling och lagring av MIDI Data Debouncer -kick (DRUM_PINS [KICK], KICK_DB_DURATION); // Debouncer -objekt för kick drum volatile bool previousState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Drum pad tidigare logiktillstånd flyktig bool currentState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Trumplattans nuvarande logiska tillstånd

EEPROM -funktioner

/* Spara inställningar i EEPROM*/

void storeEEPROM () {

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

/* Ladda inställningar från EEPROM*/

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

Initiering av variabler och programmeringsläge, när det gäller pedaler och Arduino -boot aktiveras samtidigt

void enterProgrammingMode () {

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

void initValues () {

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

MIDI -kommunikationshanterare med fördröjning på 1 ms noteringstid

/ * Spela MIDI -notfunktion */

void midiOut (enum DRUM_POSITION drumIn) {

if (drumIn == HIHAT) {// Om HI-HAT träffades, måste du kontrollera om pedalen är nedtryckt om (! digitalRead (drumPins [HIHAT_PEDAL])) {noteOn (0x90, drumNotes [HIHAT_PEDAL], drumVelocities [HIHAT_PEDAL]); fördröjning (1); noteOn (0x90, drumNotes [HIHAT_PEDAL], 0); } annars {noteOn (0x90, drumNotes [HIHAT], drumVelocities [HIHAT]); fördröjning (1); noteOn (0x90, drumNotes [HIHAT], 0); }} else {// Vanlig trumma MIDI -överföringsnotaOn (0x90, drumNotes [drumIn], drumVelocities [drumIn]); fördröjning (1); noteOn (0x90, drumNotes [drumIn], 0); }}

void noteOn (int cmd, int pitch, int velocity) {Serial.write (cmd); Serial.write (tonhöjd); Serial.write (hastighet); }

setup () och loop () funktioner med oändlig enhetsdriftslinga:

void setup () {

Serial.begin (115200);

för (uint8_t i = 0; i <10; i ++) {pinMode (i+2, INPUT); } #ifdef PRINT_PADS_PIN_NUMBERS medan (true) {// Infinite debug loop för (uint8_t i = 0; i <10; i ++) {if (! digitalRead (i+2)) {Serial.print ("Pin No: D"); Serial.print (i + '0'); // Konvertera nummer till ASCII -tecken}}} #else initValues (); / * Programmeringsläge: Om två pedaler trycks ned under uppstart - läge är aktiverat */ om (! DigitalRead (drumPins [KICK]) &&! DigitalRead (drumPins [HIHAT_PEDAL])) angerProgrammingMode (); #endif}

void loop () {for (uint8_t i = 1; i <9; i = i + 1) {currentState = digitalRead (drumPins ); if (! currentState && previousState ) midiOut (i); // Jämför tillstånd och upptäck fallande edge previousState = currentState ; } kick.update (); // Kick drum använder anpassad avstängningsalgoritm if (kick.edge ()) if (kick.falling ()) midiOut (KICK); }

Steg 5: Programmering B: Python och användargränssnitt

Python användargränssnitt är lite komplicerat att förstå vid första ögonkastet, därför skulle vi försöka förklara dess grunder, hur man använder, vilken funktion har varje knapp och hur man programmerar Arduino -enheten korrekt.

Användargränssnitt - Applikation

UI är en grafisk framställning för vår trumset -programmerare, vilket gör det riktigt lätt att använda och bekvämt att programmera Arduino -enheten när som helst. UI består av flera grafiska moduler som är kopplade till den föreslagna funktionen. låt oss granska dem en efter en:

1. Drum Set Image: Python UI använder XY-bildkoordinater för att bestämma vilken trumtyp som valdes. Om giltig trumregion valdes visas det sekundära IO -meddelandet, med notfält, hastighet och Arduino -terminal för dedikerad trumdynor. När dessa parametrar har verifierats av användaren och godkänts kan dessa värden överföras direkt till Arduino -enheten.
2. Extern kontrollerbild: För att kunna använda MIDI-trumset med VST/musikskapande miljö, måste du köra Serial-to-MIDI-tolk. Jag har använt Hairless, som är tillgängligt gratis och kan köras direkt från vårt användargränssnitt, bara genom att trycka på dess bild.
3. COM -portlista: För att kunna kommunicera med Arduino måste du ange dess anslutna COM -port. Listan uppdateras genom att trycka på knappen Uppdatera.
4. Ladda/spara konfiguration: Det finns standard MIDI -värden definierade i koden, som kan ändras av användaren via interaktion med UI. Konfiguration definieras i filen config.txt i ett specifikt format som kan sparas eller laddas av användaren.
5. Knapp för programenhet: För att lagra alla modifierade MIDI-värden i Arduino EEPROM, måste du trycka på två fotpedaler (Kick trumma och Hi-hat pedal) efter det, vänta på överföring av data för att slutföra. Om det fanns några kommunikationsproblem visas korrekt popup-fönster. Om överföringen lyckas visar UI sitt framgångsrika meddelande.
6. Avslutningsknapp: Avsluta bara programmet, med användarens tillstånd.

Python -kodens höjdpunkter

Det är många saker som händer i koden, så vi kommer att utöka de skrivna funktionerna snarare än om hela koden.

Först och främst, för att kunna använda UI, måste du ladda ner flera moduler för att koden ska fungera:

importera osimport trådning importera tkinter som tk från tkinter import meddelandefält från tkinter import * från PIL import ImageTk, Bildimport numpy som np import seriell import glob

Vissa moduler ingår i Python -standardpaketet. Flera moduler bör installeras via PIP -verktyget:

pip installera Kudde

pip install numpy pip install ScreenInfo

Det rekommenderas starkt att köra programmet via PyCharm. I framtida utgåvor planerar jag att exportera en körbar för projektet.

Kort kod Förklaring

Det blir mycket lättare att förstå koden om vi skulle titta på dess rader ur funktion och klasser:

1. Huvudfunktionen - här startar koden

om _name_ == '_main_': drumkit_gui ()

2. Trummans konstanter, koordinater och standard MIDI -information

klass Trummor: 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_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. UI -funktioner - Hantering av användargränssnitt och grafiska objekt

def set_active (ui)

def sekundär_ui (trumma_typ)

class SelectionUi (tk. Frame)

klassapplikation (tk. Frame)

def drumkit_gui ()

def event_ui_clicked (händelse)

def getorigin (själv, händelse)

4. Seriell kommunikation

def get_serial_ports ()

def communic_with_arduino (port)

5. Arbeta med filer: Lagra/ladda inställningar från txt -filen

def save_config ()

def load_config ()

6. Köra extern applikation hairless.exe från koden med hjälp av Python Threading -funktioner

class ExternalExecutableThread (threading. Thread)

def run_hairless_executable ()

För att köra koden finns en lista över filer som måste bifogas till projektmappen:

• config.txt: inställningsfil
• hårlös.exe: Hårlös MIDI -omvandlare
• drumkit.png: Bild som definierar alla klickbara trumkuddar i vårt användargränssnitt (måste laddas ner från detta stegs bilduppsättning)
• drumgui.py: Projektkoden

Det är allt vi behöver betona för att det ska fungera. Det är mycket viktigt att lägga till filer i projektet: trumset bild, hårlös.exe körbar och inställningsfil config.txt.

Och.. Här har vi gjort!:)

Hoppas att du kommer att tycka att det här är användbart.

Tack för att du läser!:)