MIDI bungu komplekts Python un Arduino: 5 soļi (ar attēliem)

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:52

Kopš bērnības es vienmēr gribēju iegādāties bungu komplektu. Toreiz visam mūzikas aprīkojumam nebija visu digitālo lietojumu, jo mūsdienās to ir daudz, tāpēc cenas kopā ar cerībām bija pārāk augstas. Nesen esmu nolēmis iegādāties lētāko bungu komplektu no eBay, un vienīgā prioritāte: iespēja to nojaukt un ierīcei pievienot savu aparatūru un programmatūru.

Pirkums nepavisam nelika vilties: pārnēsājams uztīšanas bungu komplekts ar 9 dažādiem skaņas spilventiņiem, divi kāju slēdža pedāļi trumuļa cilindram un cepure un mikro-USB strāvas kontaktligzda. Kas patiešām demotivēja, tas ir izvades skaņas (šī komplekta patiesā izmantošana ir savienot ārējo skaļruni un baudīt to). Tātad, es nolēmu to pārvērst par savu programmējamo, izmantojot USB, MIDI bungu komplektu, kura pamatā ir Arduino, un lietotāja saskarni, kuras pamatā ir Python, ērtai lietošanai un vienkāršām izmaiņām, piemēram, skaļumu, piezīmi un kanālu izvēli.

Ierīces īpašības:

• Zemu cenu
• Bungu komplekta izveide no jebkuras digitālās ieejas - pat spiedpogu klāsts
• Komunikācijas atbalsts un barošana tikai caur USB saskarni - USB integrācija UART pārveidotājā un Arduino ierīcē
• Minimālās detaļas pareizai darbībai
• Viegli lietojams uz Python balstīts UI
• Pilnīgs MIDI atbalsts ar regulējamu ātrumu, piezīmi un Arduino tapām
• Saglabāt un ielādēt ierīces atmiņā saglabātās pielāgotās cilindru konfigurācijas

Pāriesim pie projekta…

1. darbība: darbības teorija

Blokshēma

Pirmkārt, pievērsīsimies projekta struktūrai un sadalīsim to atsevišķos blokos:

Roll-Up Drum Kit

Projekta galvenā vienība. Tas sastāv no 9 atsevišķiem bungu spilventiņiem, kur katrs spilventiņš ir virkne pogu, kas maina savu loģisko stāvokli, kamēr tiek trāpīts. Sakarā ar tās struktūru, šo konkrēto bungu komplektu ir iespējams izgatavot no jebkuras spiedpogas. Katrs cilindra spilventiņš ir savienots ar uzvilkšanas rezistoru uz galvenās elektroniskās plates, tādējādi, kamēr bungas spilventiņš tiek atkārtoti trāpīts, īpašs slēdzis ir piesaistīts ķēdes zemei un uz bungu spilvena līnijas ir loģisks LOW. Ja spiediens netiek pielietots, cilindra spilventiņa slēdzis ir atvērts, un, pievelkot pretestību elektropārvades līnijai, cilindra spilvena līnijā ir loģisks HIGH. Tā kā projekta mērķis ir izveidot pilnīgu digitālo MIDI ierīci, visas galvenās PCB analogās daļas var neņemt vērā. Ir svarīgi atzīmēt, ka bungu komplektam ir divi pedāļi trumuļa cilindram un cepurei, kas arī ir piesaistīti pievelkamajiem rezistoriem un kuriem ir tāda pati darbības loģika kā visiem bungu spilventiņiem (mēs to apspriedīsim nedaudz vēlāk).

Arduino Pro-Micro

Bungu komplekta smadzenes. Tās mērķis ir noteikt, vai no bungu paliktņa nāk signāls, un nodrošināt atbilstošu MIDI izvadi ar visiem nepieciešamajiem parametriem: piezīme, signāla ātrums un ilgums. Bungu spilventiņu digitālā rakstura dēļ tos var vienkārši piesaistīt arduino digitālajām ieejām (kopā 10 tapas). Lai saglabātu visus vēlamos iestatījumus un MIDI informāciju, mēs izmantosim tās atmiņu-EEPROM, tāpēc katru reizi, kad ieslēdzam ierīci, MIDI informācija tiek ielādēta no EEPROM, padarot to pārprogrammējamu un konfigurējamu. Arī Arduino Pro-Micro ir pieejams ļoti mazā iepakojumā, un to var viegli ievietot bungu komplekta iekšējā korpusā.

FTDI USB sērijas pārveidotājs

Lai ieprogrammētu un definētu mūsu ierīces funkcijas ar datora lietojumprogrammas palīdzību, USB interfeiss ir jāpārveido par seriālo, jo Arduino Pro-Micro nav USB. Tā kā saziņa starp ierīcēm ir balstīta uz UART, šajā projektā tiek izmantota FTDI ierīce, jo tā ir vienkārša, neatkarīgi no papildu īpašībām.

Datora lietojumprogramma - Python

Runājot par lietotāja saskarņu un ātri veidojamu projektu izstrādi, Python ir lielisks risinājums. UI lietojumprogrammas mērķis ir padarīt daudz ērtāku no jauna definēt MIDI rekvizītus mūsu bungu komplektam, uzglabāt informāciju, programmēt ierīci un izveidot saziņu starp sistēmām, neizmantojot kodu atkal un atkal. Tā kā mēs izmantojam seriālo saskarni, lai sazinātos ar bungu komplektu, visā internetā ir daudz bezmaksas moduļu, kas atbalsta jebkāda veida seriālos sakarus. Turklāt, kā tas tiks apspriests vēlāk, UART saskarne sastāv no trim tapām: RXD, TXD un DTR. DTR tiek izmantots, lai veiktu Arduino moduļa atiestatīšanu, tādēļ, ja mēs esam ieinteresēti palaist MIDI lietotni vai savienot lietotāja saskarni ar programmas ierīci, absolūti nav nepieciešams atkārtoti pievienot USB kabeli vai kaut ko citu.

2. solis: detaļas un instrumenti

Daļas

• Roll-Up Drum Kit
• 2 x pedāļi (parasti iekļauti DK iepakojumā).
• FTDI - USB uz seriālo pārveidotāju
• Arduino Pro Micro
• Mikro-USB kabelis

Instrumenti

• Lodāmurs/stacija
• Alvas lodēšana
• Plāna diametra viena kodola stieple
• Pincetes
• Kuteris
• Knaibles
• Nazis
• Skrūvgriezis
• 3D printeris (pēc izvēles - pielāgotām pedāļu platformām)

Programmatūra

• Arduino IDE
• Python 3 vai jaunāka versija
• JetBrains Pycharm
• MIDI saskarne bez matiem
• loopMIDI

3. solis: lodēšana un montāža

Tā kā ir jāapvieno trīs moduļi, lodēšanas un salikšanas process ir īss un vienkāršs:

• Pievienojiet Arduino Pro-Micro kopā ar FTDI ierīci, pārliecinieties, vai savienojumi atbilst katrā ierīcē definētajiem I/O:

  • VBUS-VBUS
  • GND-GND
  • DTR-DTR
  • RXD-TXD
  • TXD-RXD
• Noņemiet visas skrūves no cilindra plastmasas korpusa, pārliecinieties, vai varat koncentrēties uz spilventiņa un dēļa kabeli un tā uzvilkšanas rezistoriem

• Lodēt plānos vadus Arduino-FTDI modulim, ko esam izveidojuši iepriekš:

  • Digitālās ieejas: D [2:11]
  • VBUS
  • D+
  • D-
  • GND
• Ievietojiet moduli akumulatora korpusā tā, lai vadi peldētu tajā pašā pusē kā spilventiņu uzvilkšanas rezistori
• Lodējiet visas digitālās ieejas cilindra spilventiņu spailēs, kā parādīts pēdējā attēlā.
• Lodējiet mikro-USB kopni (VBUS, D+, D-, GND) uz FTDI ierīci, pārliecinieties, vai šo vadu izsekošanā nav kļūdu.
• Pievienojiet Arduino-FTDI moduli ar karsto līmi akumulatora korpusam
• Salieciet ierīci ar atbilstošu skrūvju stiprinājumu

Mēs to esam izdarījuši, ierīce ir samontēta. Turpināsim pie koda …

4. solis: Programmēšana A: Arduino

Soli pa solim aprakstīsim mūsu skici:

Pirmkārt, pareizai darbībai ir jāiekļauj divas nepieciešamās bibliotēkas. EEPROM jau ir iepriekš instalēts Arduino IDE, taču trumuļa atvienošanas modulis ir jāinstalē atsevišķi

#iekļaut #iekļaut

Šos slēdžus galvenokārt izmanto atkļūdošanas secībās. Ja vēlaties izmēģināt Arduino termināļu savienojumu ar bungu paliktņiem un noteikt visas digitālās ieejas, šie slēdži ir jādefinē

/ * Izstrādātāja slēdži: izrunājiet vēlamo atkļūdošanas vai inicializācijas režīmu.

Pastāvīgie lauki attēlo visas noklusējuma vērtības, ieskaitot cilindra spilventiņu uzskaitījumu. Lai ierīci palaistu pirmo reizi, ir jāzina precīzs Hi-Hat un Kick pedāļu savienojums

/ * Bungu veidu uzskaitījums */

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

/ * Noklusējuma vērtības */

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

/ * Bungas trieciena ilgums */

const uint8_t KICK_DB_DURATION = 30;

EEPROM tiek izmantots, lai saglabātu/ielādētu visus datus, kas nāk no datora lietojumprogrammas. Iepriekš aprakstītais adrešu diapazons parāda precīzu MIDI informācijas atrašanās vietu katram bungu paliktnim

/* EEPROM Adreses kartēšanai

Piezīmes: | 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 |

Tapas: | 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13 | Ātrumi | 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ālie mainīgie tiek izmantoti, lai noteiktu katra paliktņa stāvokli un attiecīgi veiktu MIDI sakarus

/ * Globālie mainīgie */

uint8_t drumNotes [10], drumVelocities [10], drumPins [10]; // MIDI mainīgie

uint8_t uartBuffer [64]; // UART buferis MIDI Data Debouncer kick savākšanai un glabāšanai (DRUM_PINS [KICK], KICK_DB_DURATION); // Izlādes objekts kick drum volatile bool previousState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Bungu spilventiņa iepriekšējā loģika norāda uz gaistošo bool currentState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Bungu spilventiņu pašreizējās loģikas stāvokļi

EEPROM funkcijas

/* Saglabājiet iestatījumus EEPROM*/

void storeEEPROM () {

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

/* Ielādēt iestatījumus no 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); }

Mainīgo inicializēšana un programmēšanas režīms pedāļu un Arduino sāknēšanas gadījumā tiek aktivizēti vienlaicīgi

void enterProgrammingMode () {

bool confirmBreak = nepatiess; uint8_t lineCnt = 0; uint8_t charCnt = 0; char lasietChar = 0; while (! apstiprinātBreak) {if (Serial.available ()) {uartBuffer [charCnt] = Serial.read (); ja (charCnt> = 29) apstiprinaBreak = true; cits charCnt ++; }} Serial.println ("Labi"); 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 sakaru apstrādātāji ar aizkavēšanos 1ms piezīmju turēšanas laikā

/ * Atskaņot MIDI piezīmju funkciju */

void midiOut (enum DRUM_POSITION drumIn) {

if (drumIn == HIHAT) {// Ja tika trāpīts HI-HAT, ir jāpārbauda, vai pedālis ir nospiests, ja (! digitalRead (drumPins [HIHAT_PEDAL]))) {noteOn (0x90, drumNotes [HIHAT_PEDAL], drumVelocities [HIHAT_PEDAL]); kavēšanās (1); noteOn (0x90, drumNotes [HIHAT_PEDAL], 0); } cits {noteOn (0x90, drumNotes [HIHAT], drumVelocities [HIHAT]); kavēšanās (1); noteOn (0x90, drumNotes [HIHAT], 0); }} cits {// Parastā bungu MIDI pārraides piezīme (0x90, drumNotes [drumIn], drumVelocities [drumIn]); kavēšanās (1); noteOn (0x90, drumNotes [drumIn], 0); }}

void noteOn (int cmd, int piķis, int ātrums) {Serial.write (cmd); Serial.write (piķis); Serial.write (ātrums); }

setup () un loop () funkcijas ar bezgalīgu ierīces darbības cilpu:

void setup () {

Serial.begin (115200);

par (uint8_t i = 0; i <10; i ++) {pinMode (i+2, INPUT); } #ifdef PRINT_PADS_PIN_NUMBERS while (true) {// Bezgalīga atkļūdošanas cilpa (uint8_t i = 0; i <10; i ++) {if (! digitalRead (i+2)) {Serial.print ("Pin No: D"); Sērijas nospiedums (i + '0'); // Pārvērst numuru par ASCII rakstzīmi}}} #else initValues (); / * Programmēšanas režīms: ja palaišanas laikā tiek nospiesti divi pedāļi - režīms ir aktivizēts */ ja (! 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); // Salīdzināt stāvokļus un noteikt krītošo malu previousState = currentState ; } kick.update (); // Kick drum izmanto pielāgotu atkāpšanās algoritmu if (kick.edge ()) if (kick.falling ()) midiOut (KICK); }

5. darbība. Programmēšana B: Python un lietotāja interfeiss

Python lietotāja saskarne ir nedaudz sarežģīta, lai to saprastu no pirmā acu uzmetiena, tāpēc mēs mēģinātu izskaidrot tās pamatus, kā lietot, kāda funkcija ir katrai pogai un kā pareizi ieprogrammēt Arduino ierīci.

Lietotāja saskarne - lietojumprogramma

UI ir mūsu bungu komplekta programmētāja grafisks attēlojums, padarot to patiešām viegli lietojamu un ērtu programmēt Arduino ierīci jebkurā laikā. UI sastāv no vairākiem grafiskiem moduļiem, kas ir piesaistīti to ieteiktajai darbībai. pārskatīsim tos pa vienam:

1. Bungu komplekta attēls: Python lietotāja saskarne izmanto X-Y attēla koordinātas, lai noteiktu, kurš cilindra tips tika izvēlēts. Ja tika izvēlēts derīgs cilindra apgabals, tiek parādīts sekundārais IO ziņojums ar piezīmju laukiem, ātrumu un Arduino spaili speciālajam bungu paliktnim. Pēc tam, kad lietotājs ir pārbaudījis un apstiprinājis šos parametrus, šīs vērtības var pārsūtīt tieši uz Arduino ierīci.
2. Ārējā kontrollera attēls: lai varētu izmantot MIDI bungu komplektu ar VST/mūzikas radīšanas vidi, ir nepieciešams palaist sērijveida-MIDI tulku. Esmu izmantojis Hairless, kas ir pieejams bez maksas un kuru var palaist tieši no mūsu lietotāja saskarnes, vienkārši nospiežot tā attēlu.
3. COM portu saraksts: Lai sazinātos ar Arduino, ir jānorāda tā pievienotais COM ports. Saraksts tiek atsvaidzināts, nospiežot pogu Atsvaidzināt.
4. Ielādēt/saglabāt konfigurāciju: kodā ir noteiktas noklusējuma MIDI vērtības, kuras lietotājs var mainīt, mijiedarbojoties ar lietotāja saskarni. Konfigurācija ir definēta failā config.txt noteiktā formātā, kuru lietotājs var saglabāt vai ielādēt.
5. Programmas ierīces poga: lai saglabātu visas modificētās MIDI vērtības Arduino EEPROM, pēc tam ir jānospiež divi pedāļi (trieciena trumuļa un Hi-hat pedālis), pagaidiet, līdz tiek pabeigta datu pārraide. Ja radās kādas saziņas problēmas, tiks parādīts atbilstošs uznirstošais logs. Ja pārsūtīšana ir veiksmīga, lietotāja saskarne parādīs savu veiksmīgo ziņojumu.
6. Iziešanas poga: vienkārši izejiet no lietotnes ar lietotāja atļauju.

Python koda galvenās iezīmes

Kodā ir daudz lietu, tāpēc mēs izvērsīsim rakstītās funkcijas, nevis visu kodu.

Pirmkārt, lai izmantotu lietotāja saskarni, lai kods darbotos, ir jālejupielādē vairāki moduļi:

importēt osimport threading importēt tkinter kā tk no tkinter importēt ziņojuma lodziņu no tkinter importa * no PIL importēšanas ImageTk, attēlu importa numpy kā np importēt sērijas importa glob

Daži moduļi ir iekļauti noklusējuma Python pakotnē. Izmantojot PIP rīku, jāinstalē vairāki moduļi:

pip instalēt spilvenu

pip install numpy pip install ScreenInfo

Ir ļoti ieteicams palaist lietojumprogrammu, izmantojot PyCharm. Turpmākajos laidienos es plānoju eksportēt projekta izpildāmo failu.

Īss koda skaidrojums

Kodu būs daudz vieglāk saprast, ja aplūkosim tā rindas no funkciju un klašu viedokļa:

1. Galvenā funkcija - šeit sākas kods

ja _name_ == '_main_': drumkit_gui ()

2. Bungu komplekta konstantes, koordinātas un noklusējuma MIDI informācija

klases bungas: DRUM_TYPES = ["Kick", "Hihat", "Snare", "Crash 1", "Crash 2", "Tom High", "Tom Mid", "Tom Low", "Ride", "Hihat Pedal" "," Kontrolieris "]

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 funkcijas - Lietotāja saskarnes un grafisko objektu apstrāde

def set_active (lietotāja saskarne)

def sekundārais_ui (bungas_tips)

klase SelectionUi (tk. Frame)

klases lietojumprogramma (tk. Frame)

def drumkit_gui ()

def event_ui_clicked (notikums)

def getorigin (es, notikums)

4. Sērijas komunikācija

def get_serial_ports ()

def sazināties_ ar_arduino (ports)

5. Darbs ar failiem: Saglabājiet/ielādējiet iestatījumus no txt faila

def save_config ()

def load_config ()

6. Ārējā lietojumprogramma hairless.exe no koda, izmantojot Python Threading iespējas

klase ExternalExecutableThread (threading. Thread)

def run_hairless_executable ()

Lai palaistu kodu, projekta mapē jāpievieno failu saraksts:

• config.txt: iestatījumu fails
• hairless.exe: Matu MIDI pārveidotājs bez matiem
• drumkit.png: attēls, kas definē visus mūsu lietotāja interfeisa klikšķināmos bungu paliktņus (ir jālejupielādē no šīs darbības attēlu kopas)
• drumgui.py: projekta kods

Tas ir viss, kas mums jāuzsver, lai tas darbotos. Ir ļoti svarīgi projektam pievienot failus: bungu komplekta attēlu, izpildāmo failu hairless.exe un iestatījumu failu config.txt.

Un.. Lūk, mēs esam paveikuši!:)

Ceru, ka jums noderēs šī pamācība.

Paldies, ka izlasījāt!:)