Sada MIDI bicích pre Python a Arduino: 5 krokov (s obrázkami)

2024 Autor: John Day | [email protected]. Naposledy zmenené: 2024-01-30 11:56

Odmalička som si vždy chcel kúpiť súpravu bicích nástrojov. V tom čase všetky hudobné zariadenia nemali všetky digitálne aplikácie, ako ich máme dnes veľa, preto boli ceny spolu s očakávaniami príliš vysoké. Nedávno som sa rozhodol kúpiť najlacnejšiu súpravu bicích nástrojov z eBay s jedinou prioritou: Schopnosť ju zbúrať a pripojiť k zariadeniu vlastný hardvér a softvér.

Nákup nebol vôbec sklamaním: prenosná súprava bicích nástrojov s 9 rôznymi zvukovými podložkami, dva pedále na nožnom spínači pre kick drum a hi-hat a elektrickú zásuvku micro-USB. Čo bolo skutočne demotivujúce, sú to výstupné zvuky (skutočným využitím tejto sady je pripojenie externého reproduktora a užívanie si toho). Rozhodol som sa ho teda previesť na svoj vlastný programovateľný pomocou USB, súpravy MIDI bicích na základe Arduina a používateľského rozhrania založeného na Pythone, pre praktické použitie a jednoduché úpravy, ako sú výber hlasitosti, noty a kanála.

Vlastnosti zariadenia:

• Nízka cena
• Vytvorenie súpravy bicích nástrojov z akýchkoľvek digitálnych vstupov - dokonca aj z radu tlačidiel
• Podpora komunikácie a napájanie iba cez rozhranie USB - Integrácia prevodníka USB na UART a zariadenia Arduino
• Minimálne diely pre správnu funkciu
• Ľahko použiteľné používateľské rozhranie založené na Pythone
• Kompletná podpora MIDI s nastaviteľnou rýchlosťou, piny a piny Arduino
• Uložiť a načítať vlastné konfigurácie valcov uložené v pamäti zariadenia

Prejdeme k projektu…

Krok 1: Teória prevádzky

Bloková schéma

V prvom rade sa zamerajme na štruktúru projektu a rozdeľte ho na samostatné bloky:

Súprava roll-up bicie

Hlavná jednotka projektu. Skladá sa z 9 samostatných bicích paličiek, kde každá podložka je rad tlačidiel, ktoré pri stlačení menia svoj logický stav. Vďaka svojej štruktúre je možné zostrojiť túto konkrétnu súpravu bicích z akýchkoľvek tlačidiel. Každá podložka valca je pripojená k vyťahovaciemu odporu na hlavnej elektronickej doske, takže počas opakovaného úderu na podložku bubna je na zem obvodu zapojený konkrétny spínač a na linke bubna je prítomná logická LOW. Ak nie je vyvíjaný žiadny tlak, je spínač bubnovej podložky otvorený a v dôsledku vyťahovacieho odporu k elektrickému vedeniu je na linke bubnovej podložky prítomný logický VYSOKÝ. Pretože účelom projektu je vytvoriť kompletné digitálne MIDI zariadenie, všetky analógové časti na hlavnej doske plošných spojov je možné zanedbať. Je dôležité si uvedomiť, že súprava bicích má dva pedále pre kick drum a hi-hat, ktoré sú tiež viazané na vyťahovacie odpory a zdieľajú rovnakú prevádzkovú logiku ako všetky bicie podložky (Trochu to prediskutujeme neskôr).

Arduino Pro-Micro

Mozog súpravy bicích nástrojov. Cieľom je zistiť, či z bicích pad prichádza signál, a poskytnúť vhodný MIDI výstup so všetkými potrebnými parametrami: Poznámka, rýchlosť a trvanie signálu. Vzhľadom na digitálny charakter bicích podložiek je možné ich jednoducho pripojiť k digitálnym vstupom arduino (celkom 10 pinov). Aby sme mohli uložiť všetky požadované nastavenia a informácie o MIDI, použijeme jeho pamäť-EEPROM, a preto sa pri každom zapnutí zariadenia načítajú informácie o MIDI z pamäte EEPROM, vďaka čomu je možné ich naprogramovať a znova konfigurovať. Arduino Pro-Micro je tiež k dispozícii vo veľmi malom balení a je možné ho ľahko prideliť vo vnútornom puzdre súpravy bicích nástrojov.

Prevodník USB na sériový port FTDI

Aby bolo možné programovať a definovať funkcie nášho zariadenia pomocou PC aplikácie, je potrebné previesť USB rozhranie na sériové, pretože Arduino Pro-Micro nemá USB. Pretože komunikácia medzi zariadeniami je založená na UART, v tomto projekte sa používa zariadenie FTDI kvôli jeho jednoduchosti použitia bez ohľadu na jeho ďalšie vlastnosti.

Aplikácia pre PC - Python

Pokiaľ ide o vývoj používateľských rozhraní a rýchlo zostaviteľné projekty, Python je vynikajúce riešenie. Účelom aplikácie používateľského rozhrania je oveľa pohodlnejšie redefinovať vlastnosti MIDI pre našu súpravu bicích nástrojov, ukladať informácie, programovať zariadenie a komunikovať medzi systémami bez toho, aby bolo potrebné kód znova a znova kompilovať. Pretože na komunikáciu so súpravou bicích používame sériové rozhranie, na internete je k dispozícii množstvo bezplatných modulov, ktoré podporujú všetky typy sériovej komunikácie. Navyše, ako bude diskutované neskôr, rozhranie UART pozostáva z celkom troch pinov: RXD, TXD a DTR. DTR sa používa na resetovanie modulu Arduino, takže keď máme záujem spustiť aplikáciu MIDI alebo pripojiť používateľské rozhranie k programovaciemu zariadeniu, nie je potrebné znova pripájať kábel USB alebo čokoľvek iné.

Krok 2: Diely a nástroje

Časti

• Súprava roll-up bicie
• 2 x Sustain pedále (zvyčajne súčasťou balenia DK).
• FTDI - prevodník USB na sériový port
• Arduino Pro Micro
• Kábel micro-USB

Nástroje

• Spájkovačka/stanica
• Cín na spájkovanie
• Tenký priemer jednožilového drôtu
• Pinzeta
• Rezačka
• Kliešť
• Nôž
• Skrutkovač
• 3D tlačiareň (voliteľné - pre prispôsobené platformy pedálov)

Softvér

• Arduino IDE
• Python 3 alebo vyšší
• JetBrains Pycharm
• Bezsrsté MIDI rozhranie
• loopMIDI

Krok 3: Spájkovanie a montáž

Pretože existujú tri moduly, ktoré je potrebné kombinovať, proces spájkovania a montáže je krátky a jednoduchý:

• Pripojte Arduino Pro-Micro k zariadeniu FTDI a uistite sa, že pripojenia sú v súlade s I/O definovanými na každom zariadení:

  • VBUS-VBUS
  • GND-GND
  • DTR-DTR
  • RXD-TXD
  • TXD-RXD
• Odskrutkujte všetky skrutky z plastového krytu bubna a uistite sa, že sa môžete zamerať na kábel medzi doskou a jeho vyťahovacie odpory

• Spájkujte tenké vodiče pre modul Arduino-FTDI, ktorý sme skonštruovali predtým:

  • Digitálne vstupy: D [2:11]
  • VBUS
  • D+
  • D-
  • GND
• Vložte modul do puzdra na batériu tak, aby vodiče plávali na tej istej strane ako vyťahovacie odpory podložiek
• Spájkujte všetky digitálne vstupy na svorky bubnovej podložky, ako je to znázornené na poslednom obrázku.
• Spájajte zbernicu micro-USB (VBUS, D+, D-, GND) k zariadeniu FTDI a uistite sa, že pri sledovaní týchto vodičov nie sú žiadne chyby.
• Pripojte modul Arduino-FTDI horúcim lepidlom k puzdru na batériu
• Zostavte zariadenie pomocou vhodného skrutkovania

Dokázali sme to, zariadenie je zostavené. Pokračujme v kóde …

Krok 4: Programovanie A: Arduino

Poďme popísať náš náčrt krok za krokom:

V prvom rade je potrebné zahrnúť dve potrebné knižnice pre správnu funkciu. EEPROM je už predinštalovaná v Arduino IDE, ale modul debouncera pre kick drum treba nainštalovať samostatne

#include #include

Tieto prepínače sa používajú hlavne v ladiacich sekvenciách. Ak si chcete vyskúšať pripojenie terminálov Arduino k bicím podložkám a určiť všetky digitálne vstupy, mali by ste definovať tieto prepínače

/ * Prepínače pre vývojárov: Odkomentujte požadovaný režim ladenia alebo inicializácie * ///#define LOAD_DEFAULT_VALUES // Namiesto EEPROM načítajte konštantné hodnoty //#definujte PRINT_PADS_PIN_NUMBERS // Vytlačte číslo pinu, ktorý je pripojený k bloku, ktorý bol zasiahnutý cez sériový port

Konštantné polia predstavujú všetky predvolené hodnoty vrátane enumerácie bubna. Na prvé spustenie zariadenia je potrebné poznať presné prepojenie pedálov Hi-Hat a Kick

/ * Výpočet typu bubna */

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

/* Základné hodnoty */

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

/ * Trvanie odskoku bubna */

konšt uint8_t KICK_DB_DURATION = 30;

EEPROM sa používa na ukladanie/načítanie všetkých údajov pochádzajúcich z aplikácie PC. Rozpätie adries popísané vyššie ukazuje presné umiestnenie informácií MIDI pre každý bubon

/* Mapovanie adries EEPROM

Poznámky: | 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 |

Kolíky: | 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13 | Rýchlosti | 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23 | */ const uint8_t NOTES_ADDR = 0x00; const uint8_t VELOCITIES_ADDR = 0x14; konšt uint8_t PINS_ADDR = 0x0A;

Globálne premenné sa používajú na určenie stavu každého padu a podľa toho vykonávajú MIDI komunikáciu

/ * Globálne premenné */

uint8_t drumNotes [10], drumVelocities [10], drumPins [10]; // MIDI premenné

uint8_t uartBuffer [64]; // UART vyrovnávacia pamäť na zhromažďovanie a ukladanie údajov MIDI Debouncer (DRUM_PINS [KICK], KICK_DB_DURATION); // Objekt debouncera pre kick drum volatile bool previousState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Predchádzajúce logické stavy bubnovej podložky volatile bool currentState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Aktuálne logické stavy bubnovej podložky

Funkcie EEPROM

/* Uložiť nastavenia v EEPROM*/

neplatné storeEEPROM () {

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

/* Načítať nastavenia z EEPROM*/

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

Inicializácia premenných a režim programovania v prípade pedálov a boot Arduino sa aktivujú súčasne

neplatné enterProgrammingMode () {

bool confirmBreak = false; uint8_t lineCnt = 0; uint8_t charCnt = 0; char readChar = 0; while (! confirmBreak) {if (Serial.available ()) {uartBuffer [charCnt] = Serial.read (); ak (charCnt> = 29) confirmBreak = true; 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 (); #koniec Ak }

MIDI komunikačné obslužné nástroje s oneskorením poznámky 1 ms

/ * Prehrať funkciu MIDI noty */

void midiOut (enum DRUM_POSITION drumIn) {

if (drumIn == HIHAT) {// Ak bol zasiahnutý HI-HAT, je potrebné skontrolovať, či je stlačený pedál, ak (! digitalRead (drumPins [HIHAT_PEDAL])) {noteOn (0x90, drumNotes [HIHAT_PEDAL], drumVelocities [HIHAT_PEDAL]); oneskorenie (1); noteOn (0x90, drumNotes [HIHAT_PEDAL], 0); } else {noteOn (0x90, drumNotes [HIHAT], drumVelocities [HIHAT]); oneskorenie (1); noteOn (0x90, drumNotes [HIHAT], 0); }} else {// Bežná MIDI prenosová poznámkaOn (0x90, drumNotes [drumIn], drumVelocities [drumIn]); oneskorenie (1); noteOn (0x90, drumNotes [drumIn], 0); }}

void noteOn (int cmd, int pitch, int velocity) {Serial.write (cmd); Serial.write (rozstup); Serial.write (rýchlosť); }

funkcie setup () a loop () s nekonečnou slučkou ovládania zariadenia:

neplatné nastavenie () {

Serial.begin (115200);

pre (uint8_t i = 0; i <10; i ++) {pinMode (i+2, INPUT); } #ifdef PRINT_PADS_PIN_NUMBERS while (true) {// Nekonečná ladiaca slučka pre (uint8_t i = 0; i <10; i ++) {if (! digitalRead (i+2)) {Serial.print ("Pin No: D"); Serial.print (i + '0'); // Previesť číslo na znak ASCII}}} #else initValues (); / * Režim programovania: Ak sú pri bootovaní stlačené dva pedále - režim je aktivovaný */ if (! DigitalRead (drumPins [KICK]) &&! DigitalRead (drumPins [HIHAT_PEDAL])) enterProgrammingMode (); #koniec Ak }

void loop () {for (uint8_t i = 1; i <9; i = i + 1) {currentState = digitalRead (drumPins ); if (! currentState && previousState ) midiOut (i); // Porovnanie stavov a detekcia zostupnej hrany previousState = currentState ; } kick.update (); // Kick drum používa vlastný algoritmus odskoku if (kick.edge ()) if (kick.falling ()) midiOut (KICK); }

Krok 5: Programovanie B: Python a používateľské rozhranie

Užívateľské rozhranie Pythonu je na prvý pohľad trochu komplikované pochopiť, a preto by sme sa pokúsili vysvetliť jeho základy, spôsob použitia, akú funkciu má každé tlačidlo a ako správne naprogramovať zariadenie Arduino.

Používateľské rozhranie - aplikácia

Používateľské rozhranie je grafickým znázornením nášho programátora bicích súprav, vďaka čomu je použitie a zariadenie Arduino skutočne kedykoľvek jednoduché a praktické. Používateľské rozhranie sa skladá z niekoľkých grafických modulov, ktoré sú viazané na ich navrhovanú činnosť. pozrime sa na ne jeden po druhom:

1. Obrázok sady valcov: Používateľské rozhranie Pythonu používa súradnice obrázka X-Y na určenie, ktorý typ valca bol vybratý. Ak bola vybratá platná oblasť valca, zobrazí sa sekundárna správa IO s poznámkovými poliami, rýchlosťou a terminálom Arduino pre vyhradenú bubnovú podložku. Potom, čo tieto parametre overí používateľ a schváli, je možné tieto hodnoty preniesť priamo do zariadenia Arduino.
2. Obrázok externého ovládača: Aby bolo možné používať súpravu MIDI bicích s prostredím vytvárania VST/hudby, je potrebné spustiť tlmočník Serial-To-MIDI. Použil som Hairless, ktorý je k dispozícii zadarmo a dá sa spustiť priamo z nášho používateľského rozhrania jednoduchým stlačením jeho obrázku.
3. Zoznam portov COM: Aby bolo možné komunikovať s Arduinom, je potrebné špecifikovať jeho pripojený port COM. Zoznam sa aktualizuje stlačením tlačidla Obnoviť.
4. Načítať/uložiť konfiguráciu: V kóde sú definované predvolené hodnoty MIDI, ktoré môže používateľ upraviť prostredníctvom interakcie s používateľským rozhraním. Konfigurácia je definovaná v súbore config.txt v konkrétnom formáte, ktorý môže užívateľ uložiť alebo načítať.
5. Tlačidlo programového zariadenia: Na uloženie všetkých upravených hodnôt MIDI do pamäte Arduino EEPROM je potrebné potom stlačiť dva pedále (Kick drum a Hi-hat pedál) a počkať, kým sa prenos údajov dokončí. V prípade akýchkoľvek problémov s komunikáciou sa zobrazí správne kontextové okno. Ak je prenos úspešný, používateľské rozhranie zobrazí svoju úspešnú správu.
6. Tlačidlo Ukončiť: Ukončite aplikáciu s povolením používateľa.

Hlavné body kódu Python

V kóde sa deje veľa vecí, takže sa budeme venovať skôr písaným funkciám než celému kódu.

Aby bolo možné používať používateľské rozhranie, je potrebné najskôr stiahnuť niekoľko modulov, aby kód fungoval:

importovať vlákno osimport importovať tkinter ako tk z tkinter importovať schránku správ z tkinter importovať * z PIL importovať ImageTk, importovať obrázok nie je možné ako np importovať sériový import glob

Niektoré moduly sú súčasťou predvoleného balíka Python. Prostredníctvom nástroja PIP by malo byť nainštalovaných niekoľko modulov:

pip install Pillow

pip install numpy pip install ScreenInfo

Dôrazne sa odporúča spustiť aplikáciu cez PyCharm. V budúcich vydaniach plánujem exportovať spustiteľný súbor pre projekt.

Stručný kód Vysvetlenie

Porozumieť kódu bude oveľa jednoduchšie, ak by sme sa na jeho riadky pozreli z pohľadu funkcií a tried:

1. Hlavná funkcia - tu začína kód

if _name_ == '_main_': drumkit_gui ()

2. Konštanty, súradnice a predvolené informácie o MIDI súprave bicích nástrojov

triedne bicie: DRUM_TYPES = ["Kick", "Hihat", "Snare", "Crash 1", "Crash 2", "Tom High", "Tom Mid", "Tom Low", "Ride", "Hihat Pedal "," Ovládač "]

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] ROZMERY_ŠÍRKA = [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. Funkcie používateľského rozhrania - Manipulácia s užívateľským rozhraním a grafickými objektmi

def set_active (ui)

def secondary_ui (drum_type)

trieda SelectionUi (tk. Frame)

trieda Aplikácia (tk. Frame)

def drumkit_gui ()

def event_ui_clicked (udalosť)

def getorigin (self, event)

4. Sériová komunikácia

def get_serial_ports ()

def commun_with_arduino (port)

5. Práca so súbormi: Uložte/Načítajte nastavenia zo súboru txt

def save_config ()

def load_config ()

6. Spustenie externej aplikácie hairless.exe z kódu pomocou schopností Python Threading

trieda ExternalExecutableThread (threading. Thread)

def run_hairless_executable ()

Na spustenie kódu je zoznam súborov, ktoré je potrebné pripojiť k priečinku projektu:

• config.txt: Súbor nastavení
• hairless.exe: bezsrstý MIDI prevodník
• drumkit.png: obrázok, ktorý definuje všetky klikacie pady v našom používateľskom rozhraní (je potrebné stiahnuť z tohto súboru obrázkov)
• drumgui.py: Kód projektu

To je všetko, čo musíme zdôrazniť, aby to fungovalo. Je veľmi dôležité pridať do projektu súbory: obrázok sady bicích, spustiteľný súbor hairless.exe a súbor nastavení config.txt.

A.. Tu sme to urobili!:)

Dúfam, že vám tento návod bude užitočný.

Vďaka za prečítanie!:)