MIDI dobkészlet Pythonon és Arduino -n: 5 lépés (képekkel)

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:40

Gyerekkorom óta mindig szerettem volna dobkészletet vásárolni. Akkoriban az összes zenei berendezés nem rendelkezett minden digitális alkalmazással, mivel ma rengeteg van, ezért az árak és a várakozások túl magasak voltak. A közelmúltban úgy döntöttem, hogy veszek egy legolcsóbb dobkészletet az eBay -től, egyetlen prioritással: Lebontható, és saját hardvert és szoftvert csatlakoztathatok az eszközhöz.

A vásárlás egyáltalán nem okozott csalódást: hordozható, feltekerhető dobkészlet 9 különböző hangpárnával, két lábkapcsoló pedállal a dobdobhoz és a kalapos, valamint a mikro-USB konnektorhoz. Ami igazán demotiváló volt, az a kimeneti hangok (Ennek a készletnek a tényleges használata a külső hangszóró csatlakoztatása és élvezése). Tehát úgy döntöttem, hogy átalakítom saját programozhatóvá USB -n keresztül, az Arduino -n alapuló MIDI dobkészletre és a Python -alapú felhasználói felületre, a praktikus használat és az egyszerű módosítások, például a hangerő, a jegyzet és a csatorna kiválasztása érdekében.

A készülék jellemzői:

• Alacsony ár
• Dobkészlet létrehozása bármilyen digitális bemenetről - akár nyomógombokból is
• Kommunikációs támogatás és tápellátás csak USB interfészen keresztül - USB -UART átalakító és Arduino eszköz integrálása
• Mininum alkatrészek a megfelelő működéshez
• Könnyen használható Python-alapú felhasználói felület
• Teljes MIDI támogatás állítható sebességgel, jegyzettel és Arduino csapokkal
• A készülék memóriájában tárolt egyéni dobkonfigurációk mentése és betöltése

Folytassuk a projektet…

1. lépés: A működés elmélete

Blokk diagramm

Először is koncentráljunk a projekt szerkezetére, és osszuk külön blokkokra:

Roll-up dob készlet

A projekt fő egysége. 9 különálló dobpárnából áll, amelyek mindegyike egy sor olyan gomb, amelyek megváltoztatják logikai állapotukat ütés közben. Felépítéséből adódóan lehetőség van arra, hogy ezt a dobkészletet bármilyen nyomógombból elkészítsék. Mindegyik dobpárna a fő elektronikus táblán lévő felhúzó ellenálláshoz van csatlakoztatva, így amíg a dobpárnát többször megütik, egy speciális kapcsoló van az áramkör földeléséhez kötve, és a dobpárna vonalán logikai LOW van. Ha nincs nyomás, akkor a dobpárna kapcsoló nyitva van, és a felhúzó ellenállás miatt a tápvezetékhez logikus HIGH van a dobpárnán. Mivel a projekt célja egy komplett digitális MIDI eszköz létrehozása, a fő NYÁK összes analóg része figyelmen kívül hagyható. Fontos megjegyezni, hogy a dobkészlet két pedállal rendelkezik a dobdobhoz és a kalaphoz, amelyek szintén a felhúzó ellenállásokhoz vannak kötve, és ugyanazt a működési logikát alkalmazzák, mint az összes dobpárna (ezt egy kicsit később tárgyaljuk)).

Arduino Pro-Micro

A dobkészlet agya. Célja annak felderítése, hogy jön -e jel a dobpárnából, és biztosítja a megfelelő MIDI kimenetet az összes szükséges paraméterrel: Megjegyzés, sebesség és a jel időtartama. A dobpárnák digitális jellege miatt egyszerűen csatlakoztathatók az arduino digitális bemenetekhez (összesen 10 érintkező). Az összes kívánt beállítás és MIDI-információ tárolása érdekében a memóriáját fogjuk használni-az EEPROM-ot, ezért minden alkalommal, amikor bekapcsoljuk a készüléket, a MIDI-információk betöltődnek az EEPROM-ból, ezáltal újra programozható és konfigurálható. Ezenkívül az Arduino Pro-Micro nagyon kicsi csomagolásban kapható, és könnyen elhelyezhető a dobkészlet belső tokjában.

FTDI USB soros átalakító

Ahhoz, hogy a számítógépes alkalmazás segítségével programozhassuk és definiálhassuk készülékünk tulajdonságait, az USB interfészt sorosra kell konvertálni, mert az Arduino Pro-Micro nem rendelkezik USB-vel. Mivel az eszközök közötti kommunikáció az UART -on alapul, az FTDI -eszközt használják ebben a projektben, egyszerű használatának köszönhetően, további tulajdonságaitól függetlenül.

PC -alkalmazás - Python

Ami a felhasználói felületek fejlesztését és a gyorsan összeállítható projekteket illeti, a Python kiváló megoldás. A felhasználói felület célja, hogy sokkal kényelmesebbé tegye a dobkészletünk MIDI tulajdonságainak újbóli meghatározását, az információk tárolását, a programozási eszközt és a kommunikációt a rendszerek között anélkül, hogy újra és újra össze kellene állítani a kódot. Mivel soros interfészt használunk a dobkészlettel való kommunikációhoz, az interneten rengeteg ingyenes modul található, amelyek bármilyen soros kommunikációt támogatnak. Ezenkívül, amint azt később tárgyaljuk, az UART interfész összesen három érintkezőből áll: RXD, TXD és DTR. A DTR -t az Arduino modul alaphelyzetbe állítására használják, így ha érdekel a MIDI alkalmazás futtatása vagy az UI csatlakoztatása a programozó eszközhöz, egyáltalán nincs szükség az USB -kábel vagy bármi más csatlakoztatására.

2. lépés: Alkatrészek és műszerek

Alkatrészek

• Roll-up dob készlet
• 2 x Sustain pedál (általában a DK csomagban található).
• FTDI - USB soros átalakító
• Arduino Pro Micro
• Micro-USB kábel

Műszerek

• Forrasztópáka/állomás
• Ón forrasztása
• Vékony átmérőjű egymagos huzal
• Csipesz
• Vágó
• Fogó
• Kés
• Csavarhúzó
• 3D nyomtató (opcionális - testreszabott pedálplatformokhoz)

Szoftver

• Arduino IDE
• Python 3 vagy újabb
• JetBrains Pycharm
• Szőrtelen MIDI felület
• loopMIDI

3. lépés: Forrasztás és összeszerelés

Mivel három modult kell kombinálni, a forrasztási és összeszerelési folyamat rövid és egyszerű:

• Csatlakoztassa az Arduino Pro-Micro-t FTDI-eszközhöz, és győződjön meg arról, hogy a csatlakozások megfelelnek az egyes eszközökön meghatározott I/O-nak:

  • VBUS-VBUS
  • GND-GND
  • DTR-DTR
  • RXD-TXD
  • TXD-RXD
• Távolítsa el az összes csavart a dob műanyag burkolatából, győződjön meg arról, hogy a pad-to-board kábelre és annak felhúzó ellenállására tud összpontosítani

• Vékony huzalok forrasztása az Arduino-FTDI modulhoz, amelyet korábban építettünk:

  • Digitális bemenetek: D [2:11]
  • VBUS
  • D+
  • D-
  • GND
• Helyezze be a modult az elemtartóba, hogy a vezetékek ugyanazon az oldalon lebegjenek, mint a párnák felhúzó ellenállása
• Forrasztja az összes digitális bemenetet a dobpárna csatlakozóira az utolsó ábrán látható módon.
• Forrasztja a mikro-USB buszt (VBUS, D+, D-, GND) az FTDI eszközhöz, és győződjön meg arról, hogy nincsenek hibák a vezetékek nyomon követésében.
• Rögzítse az Arduino-FTDI modult forró ragasztóval az elemtartóhoz
• Szerelje fel a készüléket a megfelelő csavarokkal

Megcsináltuk, a készülék össze van szerelve. Folytassuk a kóddal…

4. lépés: Programozás A: Arduino

Ismertesse vázlatunkat lépésről lépésre:

Először is két szükséges könyvtárat kell tartalmaznia a megfelelő működéshez. Az EEPROM már előre telepítve van az Arduino IDE-be, de a dobdobó debouncer modult külön kell telepíteni

#befoglalni #befoglalni

Ezeket a kapcsolókat elsősorban hibakeresési szekvenciákban használják. Ha ki szeretné próbálni az Arduino csatlakozókat a dobpárnákhoz, és meg szeretné határozni az összes digitális bemenetet, akkor ezeket a kapcsolókat meg kell határozni

/ * Fejlesztői kapcsolók: A hibakeresés vagy az inicializálás kívánt módjának megszüntetése

Az állandó mezők az összes alapértelmezett értéket képviselik, beleértve a dobpárna felsorolását is. Ahhoz, hogy először futtassa az eszközt, ismernie kell a Hi-Hat és a Kick pedálok pontos kapcsolatát

/ * Dob típusok felsorolása */

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

/* Alapértelmezett értékek */

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, 110}; const uint8_t DRUM_PINS [10] = {8, 6, 4, 3, 11, 9, 5, 10, 2, 7};

/ * A dobdobás visszalépési időtartama */

const uint8_t KICK_DB_DURATION = 30;

Az EEPROM a PC alkalmazásból származó összes adat tárolására/betöltésére szolgál. A fent leírt címtartomány az egyes dobpárnák MIDI -információinak pontos helyét mutatja

/* EEPROM Címzett leképezés

Megjegyzések: | 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 |

Csapok: | 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13 | Sebességek | 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;

Globális változókat használnak az egyes padok állapotának meghatározására és ennek megfelelően a MIDI kommunikációra

/ * Globális változók */

uint8_t drumNotes [10], drumVelocities [10], drumPins [10]; // MIDI változók

uint8_t uartBuffer [64]; // UART puffer a MIDI Data Debouncer kick gyűjtésére és tárolására (DRUM_PINS [KICK], KICK_DB_DURATION); // Debouncer objektum rúgódobhoz illékony bool previousState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // Dobpárna korábbi logikája illékony bool currentState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // A dobpárna aktuális logikai állapota

EEPROM funkciók

/* A beállítások tárolása az EEPROM -ban*/

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

/* A beállítások betöltése az EEPROM -ból*/

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

A változók inicializálása és a programozási mód, a pedálok és az Arduino rendszerindítás esetén egyszerre aktiválódnak

void enterProgrammingMode () {

bool ConfirmBreak = hamis; uint8_t lineCnt = 0; uint8_t charCnt = 0; char readChar = 0; while (! ConfirmBreak) {if (Serial.available ()) {uartBuffer [charCnt] = Serial.read (); if (charCnt> = 29) confirmBreak = igaz; else 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 kommunikációs kezelők 1 ms késleltetéssel

/ * MIDI jegyzet lejátszása */

void midiOut (enum DRUM_POSITION drumIn) {

if (drumIn == HIHAT) {// Ha a HI-HAT találatot kapott, ellenőrizni kell, hogy a pedál le van-e nyomva, ha (! digitalRead (drumPins [HIHAT_PEDAL]))) {noteOn (0x90, drumNotes [HIHAT_PEDAL], drumVelocities [HIHAT_PEDAL]); késleltetés (1); noteOn (0x90, drumNotes [HIHAT_PEDAL], 0); } else {noteOn (0x90, drumNotes [HIHAT], drumVelocities [HIHAT]); késleltetés (1); noteOn (0x90, drumNotes [HIHAT], 0); }} else {// Rendes dob MIDI átvitel noteOn (0x90, drumNotes [drumIn], drumVelocities [drumIn]); késleltetés (1); noteOn (0x90, drumNotes [drumIn], 0); }}

void noteOn (int cmd, int pitch, int velocity) {Soros.írás (cmd); Soros.írás (hangmagasság); Soros.írás (sebesség); }

setup () és loop () függvények végtelen eszköz működési hurokkal:

void setup () {

Sorozat.kezdet (115200);

for (uint8_t i = 0; i <10; i ++) {pinMode (i+2, INPUT); } #ifdef PRINT_PADS_PIN_NUMBERS while (true) {// Végtelen hibakeresési ciklus (uint8_t i = 0; i <10; i ++) {if (! digitalRead (i+2)) {Serial.print ("Pin No: D"); Sorozatnyomat (i + '0'); // Szám konvertálása ASCII karakterré}}} #else initValues (); / * Programozási mód: Ha két pedált megnyomnak indítás közben - az üzemmód aktiválva van */ if (! DigitalRead (drumPins [KICK]) &&! DigitalRead (drumPins [HIHAT_PEDAL])) enterProgrammingMode (); #endif}

void loop () {for (uint8_t i = 1; i <9; i = i + 1) {currentState = digitalRead (drumPins ); if (! currentState && previousState ) midiOut (i); // Az állapotok összehasonlítása és a leeső él észlelése previousState = currentState ; } kick.update (); // A Kick drum egyéni visszalépési algoritmust használ, ha (kick.edge ()) if (kick.falling ()) midiOut (KICK); }

5. lépés: B programozás: Python és felhasználói felület

A Python felhasználói felület első látásra kissé bonyolult megérteni, ezért megpróbáljuk elmagyarázni annak alapjait, használatát, minden gomb funkcióját és az Arduino eszköz megfelelő programozását.

Felhasználói felület - Alkalmazás

A felhasználói felület grafikus ábrázolása a dobkészlet programozónknak, így igazán könnyen használható és kényelmesen programozható az Arduino eszköz bármikor. A felhasználói felület több grafikus modulból áll, amelyek a javasolt művelethez vannak kötve. nézzük meg egyenként:

1. Dobkészlet képe: A Python felhasználói felület X-Y képkoordináták alapján határozza meg, hogy melyik dobtípust választotta ki. Ha érvényes dobrégiót választott, megjelenik a másodlagos IO üzenet, megjegyzésmezőkkel, sebességgel és Arduino terminállal a dedikált dobpárna számára. Miután ezeket a paramétereket a felhasználó ellenőrizte és jóváhagyta, ezek az értékek közvetlenül továbbíthatók az Arduino eszközre.
2. Külső vezérlő képe: Annak érdekében, hogy a MIDI dobkészletet VST/Zene létrehozó környezettel lehessen használni, szükség van a Soros-MIDI tolmács futtatására. A Hairless -t használtam, amely ingyenesen elérhető, és közvetlenül a felhasználói felületünkről futtatható, csak a kép megnyomásával.
3. COM portlista: Az Arduino -val való kommunikációhoz meg kell adni a hozzá tartozó COM portot. A lista frissítése a Frissítés gomb megnyomásával történik.
4. Konfiguráció betöltése/mentése: A kódban vannak megadva alapértelmezett MIDI -értékek, amelyeket a felhasználó módosíthat a felhasználói felületen való interakció révén. A konfigurációt a config.txt fájl határozza meg egy adott formátumban, amelyet a felhasználó menthet vagy betölthet.
5. Programozási eszköz gomb: Annak érdekében, hogy az összes módosított MIDI értéket tárolja az Arduino EEPROM-ban, ezt követően két lábpedált (Kick drum és Hi-hat pedal) kell megnyomni, várjon, amíg az adatátvitel befejeződik. Ha kommunikációs problémák merültek fel, a megfelelő előugró ablak jelenik meg. Ha az átvitel sikeres, a felhasználói felület megjeleníti a sikeres üzenetet.
6. Kilépés gomb: Csak lépjen ki az alkalmazásból, a felhasználó engedélyével.

A Python kód kiemelt részei

Sok minden történik a kódban, ezért inkább az írott függvényekre fogunk kiterjedni, mint a teljes kódra.

Először is, a felhasználói felület használatához több modult kell letölteni a kód működéséhez:

importálás osimport szálazás importálás tkinter tk -ként tkinterből import üzenetládából a tkinter importből * a PIL importálásból ImageTk, Képimportálás számjegy np importként soros import glob

Néhány modul az alapértelmezett Python csomagban található. Több modult kell telepíteni a PIP eszköz segítségével:

pip install Párna

pip install numpy pip install ScreenInfo

Erősen ajánlott az alkalmazás PyCharm -on keresztül futtatni. A jövőbeli kiadásokban tervezem egy futtatható fájl exportálását a projekthez.

Rövid kódmagyarázat

Sokkal könnyebb lesz megérteni a kódot, ha a sorait a függvények és az osztályok szemszögéből nézzük:

1. A fő funkció - itt kezdődik a kód

if _name_ == '_main_': drumkit_gui ()

2. A Drum Kit konstansai, koordinátái és alapértelmezett MIDI -adatai

osztályú dobok: DRUM_TYPES = ["Kick", "Hihat", "Snare", "Crash 1", "Crash 2", "Tom High", "Tom Mid", "Tom Low", "Ride", "Hihat Pedal" ", "Vezérlő"]

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, 110] DRUM_PINS = [8, 6, 4, 3, 11, 9, 5, 10, 2, 7]

3. UI funkciók - Felhasználói felület és grafikus objektumok kezelése

def set_active (felhasználói felület)

def másodlagos_ui (dob_típus)

osztály SelectionUi (tk. Frame)

osztályú alkalmazás (tk. Frame)

def drumkit_gui ()

def event_ui_clicked (esemény)

def getorigin (én, esemény)

4. Soros kommunikáció

def get_serial_ports ()

def kommunikáció_arduino -val (port)

5. Fájlok kezelése: A beállítások tárolása/betöltése a txt fájlból

def save_config ()

def load_config ()

6. A hairless.exe külső alkalmazás futtatása a kódból a Python Threading funkció segítségével

osztály ExternalExecutableThread (threading. Thread)

def run_hairless_executable ()

A kód futtatásához van egy lista a fájlokról, amelyeket csatolni kell a projekt mappához:

• config.txt: Beállítások fájl
• hairless.exe: Szőrtelen MIDI konverter
• drumkit.png: Kép, amely meghatározza az összes kattintható dobpárnát a felhasználói felületünkön (ezt a lépést tartalmazó képkészletből kell letölteni)
• drumgui.py: A projekt kódja

Ez minden, amit hangsúlyoznunk kell, hogy működjön. Nagyon fontos, hogy fájlokat adjunk a projekthez: dobkészlet kép, hajmentes.exe futtatható fájl és beállítási fájl config.txt.

És.. Itt végeztünk!:)

Remélem, hasznosnak találja ezt az oktathatót.

Köszönöm, hogy elolvasta!:)