MIDI būgnų rinkinys „Python“ir „Arduino“: 5 žingsniai (su nuotraukomis)

2024 Autorius: John Day | [email protected]. Paskutinį kartą keistas: 2024-01-30 10:45

Nuo vaikystės visada norėjau nusipirkti būgno komplektą. Tuomet visa muzikinė įranga neturėjo visų skaitmeninių programų, kaip šiandien turime daug, todėl kainos ir lūkesčiai buvo per dideli. Neseniai nusprendžiau nusipirkti pigiausią būgnų rinkinį iš „eBay“, kurio vienintelis prioritetas: galimybė jį nugriauti ir prie įrenginio prijungti savo aparatinę ir programinę įrangą.

Pirkimas visiškai nenuvylė: nešiojamas suvyniotų būgnų komplektas su 9 skirtingomis garso pagalvėmis, du kojų jungiklių pedalai, skirti smūginiam būgnui ir „hi-hat“bei „micro-USB“maitinimo lizdas. Iš tikrųjų demotyvuoja išėjimo garsai (tikrasis šio rinkinio naudojimas yra prijungti išorinį garsiakalbį ir mėgautis juo). Taigi, nusprendžiau jį konvertuoti į savo programuojamą per USB, MIDI būgno rinkinį, pagrįstą „Arduino“, ir vartotojo sąsają, pagrįstą „Python“, kad būtų patogu naudoti ir lengvai modifikuoti, pvz., Garsumą, pastabas ir kanalus.

Įrenginio ypatybės:

• Žema kaina
• Būgno rinkinio kūrimas iš bet kokių skaitmeninių įėjimų - net daugybė mygtukų
• Ryšio palaikymas ir maitinimas tik per USB sąsają - USB integravimas į UART keitiklį ir „Arduino“įrenginį
• Minimalios dalys tinkamam veikimui
• Lengvai naudojama „Python“pagrindu sukurta vartotojo sąsaja
• Visiškas MIDI palaikymas su reguliuojamu greičiu, užrašu ir „Arduino“kaiščiais
• Įrašykite ir įkelkite pasirinktines būgno konfigūracijas, išsaugotas įrenginio atmintyje

Pereikime prie projekto…

1 žingsnis: veikimo teorija

Blokinė diagrama

Pirmiausia sutelkime dėmesį į projekto struktūrą ir padalinkime ją į atskirus blokus:

Suvyniojamas būgno komplektas

Pagrindinis projekto vienetas. Jį sudaro 9 atskiros būgno pagalvėlės, kuriose kiekviena trinkelė yra masyvas mygtukų, kurie keičia savo loginę būseną, kai jie yra pataikomi. Dėl savo struktūros yra galimybė sukurti šį būgno komplektą iš bet kurių mygtukų. Kiekvienas būgno kilimėlis yra prijungtas prie traukimo varžos pagrindinėje elektroninėje plokštėje, taigi, kai būgno pagalvėlė pakartotinai smūgiuojama, tam tikras jungiklis yra prijungtas prie grandinės žemės ir būgno pagalvėlės linijoje yra logiška LOW. Kai nėra slėgio, būgno pagalvėlės jungiklis yra atidarytas ir dėl traukos rezistoriaus prie elektros linijos būgno pagalvėlės linijoje yra logiška HIGH. Kadangi projekto tikslas yra sukurti pilną skaitmeninį MIDI įrenginį, visos pagrindinės PCB analoginės dalys gali būti ignoruojamos. Svarbu pastebėti, kad būgno rinkinyje yra du pedalai, skirti smūginiam būgnui ir skrybėlėms, kurie taip pat yra pririšti prie traukimo varžų ir turi tą pačią veikimo logiką kaip ir visos būgno pagalvėlės (šiek tiek vėliau aptarsime tai)).

„Arduino Pro-Micro“

Būgno rinkinio smegenys. Jo tikslas yra nustatyti, ar iš būgno pagalvėlės sklinda signalas, ir pateikti tinkamą MIDI išvestį su visais būtinais parametrais: Pastaba, signalo greitis ir trukmė. Dėl būgno pagalvėlių skaitmeninio pobūdžio jas galima tiesiog susieti su skaitmeninėmis „arduino“įvestimis (iš viso 10 kaiščių). Norėdami išsaugoti visus norimus nustatymus ir MIDI informaciją, mes naudosime jo atmintį-EEPROM, todėl kiekvieną kartą įjungus įrenginį MIDI informacija įkeliama iš EEPROM, todėl ją galima perprogramuoti ir sukonfigūruoti. Be to, „Arduino Pro-Micro“yra labai mažoje pakuotėje ir gali būti lengvai dedamas į būgno rinkinio vidinį dėklą.

FTDI USB į serijos keitiklis

Norint programuoti ir apibrėžti mūsų įrenginio funkcijas naudojant kompiuterio programą, reikia USB sąsają konvertuoti į nuosekliąją, nes „Arduino Pro-Micro“neturi USB. Kadangi ryšys tarp įrenginių yra pagrįstas UART, šiame projekte naudojamas FTDI įrenginys dėl jo naudojimo paprastumo, neatsižvelgiant į jo papildomas savybes.

Kompiuterio programa - „Python“

Kalbant apie vartotojo sąsajų kūrimą ir greitai kuriamus projektus, „Python“yra puikus sprendimas. Naudotojo sąsajos taikymo tikslas yra padaryti daug patogesnį iš naujo apibrėžti mūsų būgno rinkinio MIDI ypatybes, saugoti informaciją, programuoti įrenginį ir užmegzti ryšį tarp sistemų, nereikalaujant iš naujo rinkti kodo. Kadangi mes naudojame serijinę sąsają, kad galėtume bendrauti su būgnų komplektu, visame internete yra daugybė nemokamų modulių, palaikančių bet kokio tipo nuoseklųjį ryšį. Be to, kaip bus aptarta vėliau, UART sąsają sudaro trys kaiščiai: RXD, TXD ir DTR. DTR naudojamas „Arduino“modulio atstatymui atlikti, taigi, kai norime paleisti MIDI programą arba prijungti vartotojo sąsają prie programinio įrenginio, visiškai nereikia iš naujo prijungti USB kabelio ar bet ko.

2 žingsnis: dalys ir prietaisai

Dalys

• Suvyniojamas būgno komplektas
• 2 x priežiūros pedalai (paprastai įeina į DK paketą).
• FTDI - USB į serijos keitiklis
• „Arduino Pro Micro“
• „Micro-USB“kabelis

Instrumentai

• Lituoklis/stotis
• Litavimo skarda
• Plonas skersmuo vieno branduolio viela
• Pincetai
• Kateris
• Žnyplės
• Peilis
• Atsuktuvas
• 3D spausdintuvas (pasirinktinai - pritaikytoms pedalų platformoms)

Programinė įranga

• „Arduino IDE“
• „Python 3“arba naujesnė versija
• „JetBrains Pycharm“
• Plaukų neturinti MIDI sąsaja
• loopMIDI

3 žingsnis: litavimas ir surinkimas

Kadangi yra trys moduliai, kuriuos reikia sujungti, litavimo ir surinkimo procesas yra trumpas ir paprastas:

• Prijunkite „Arduino Pro-Micro“su FTDI įrenginiu, įsitikinkite, kad jungtys atitinka kiekviename įrenginyje nustatytas I/O:

  • VBUS-VBUS
  • GND-GND
  • DTR-DTR
  • RXD-TXD
  • TXD-RXD
• Atsukite visus varžtus iš būgno plastikinio gaubto, įsitikinkite, kad galite sutelkti dėmesį į kabelį nuo plokštės iki plokštės ir jo traukimo varžus

• Lituokite plonus laidus „Arduino-FTDI“moduliui, kurį mes sukūrėme anksčiau:

  • Skaitmeniniai įėjimai: D [2:11]
  • VBUS
  • D+
  • D-
  • GND
• Įdėkite modulį į akumuliatoriaus dėklo vidų, kad laidai plauktų toje pačioje pusėje kaip ir trinkelių ištraukiamieji rezistoriai
• Lituokite visus skaitmeninius įėjimus į būgno pagalvėlės gnybtus, kaip parodyta paskutiniame paveikslėlyje.
• Lituokite mikro-USB magistralę (VBUS, D+, D-, GND) prie FTDI įrenginio, įsitikinkite, kad nėra klaidų sekant šiuos laidus.
• Prie akumuliatoriaus dėklo pritvirtinkite „Arduino-FTDI“modulį karštais klijais
• Sumontuokite prietaisą su atitinkamais varžtais

Mes tai padarėme, įrenginys surinktas. Tęskime kodą …

4 žingsnis: programavimas A: „Arduino“

Leiskite žingsnis po žingsnio aprašyti mūsų eskizą:

Visų pirma, norint tinkamai veikti, reikia įtraukti dvi bibliotekas. EEPROM jau yra iš anksto įdiegtas „Arduino IDE“, tačiau smūginio būgno perjungimo modulis turi būti įdiegtas atskirai

#įtraukti #įtraukti

Šie jungikliai dažniausiai naudojami derinimo sekose. Jei norite išbandyti „Arduino“gnybtų prijungimą prie būgno pagalvėlių ir nustatyti visus skaitmeninius įėjimus, šie jungikliai turėtų būti apibrėžti

/ * Kūrėjo jungikliai: nekomentuokite pageidaujamo derinimo ar inicijavimo režimo

Pastovūs laukai nurodo visas numatytas vertes, įskaitant būgno pagalvėlių išvardijimą. Norint paleisti įrenginį pirmą kartą, reikia žinoti tikslų Hi-Hat ir Kick pedalų sujungimą

/ * Būgno tipo išvardinimas */

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

/* Numatytosios vertės */

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

/ * Būgno smūgio trukmė */

const uint8_t KICK_DB_DURATION = 30;

EEPROM naudojamas saugoti/įkelti visus duomenis, gaunamus iš kompiuterio programos. Aukščiau aprašytas adresų diapazonas rodo tikslią kiekvieno būgno pagalvėlės MIDI informacijos vietą

/* EEPROM Adresų susiejimas

Pastabos: | 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 |

Smeigtukai: | 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13 | Greitis | 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23 | */ const uint8_t PASTABOS_ADDR = 0x00; const uint8_t VELOCITIES_ADDR = 0x14; const uint8_t PINS_ADDR = 0x0A;

Visuotiniai kintamieji naudojami kiekvienos trinkelės būsenai nustatyti ir atitinkamai vykdyti MIDI ryšį

/ * Visuotiniai kintamieji */

uint8_t drumNotes [10], drumVelocities [10], drumPins [10]; // MIDI kintamieji

uint8_t uartBuffer [64]; // UART buferis, skirtas rinkti ir saugoti „MIDI Data Debouncer kick“(DRUM_PINS [KICK], KICK_DB_DURATION); // Atmušimo objektas, skirtas smūginiam būgnui nepastovus bool previousState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Būgno pagalvėlės ankstesnė logika teigia nepastovią bool currentState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // Būgno pagalvėlės dabartinės logikos būsenos

EEPROM funkcijos

/* Saugokite nustatymus EEPROM*/

void storeEEPROM () {

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

/* Įkelkite nustatymus iš EEPROM*/

void loadEEPROM () {for (uint8_t i = 0; i <10; i ++) drumNotes = EEPROM.read (NOTES_ADDR+i); (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); }

Kintamųjų inicijavimas ir programavimo režimas, jei pedalai ir „Arduino“įkrova įjungiami vienu metu

void enterProgrammingMode () {

bool ConfirmBreak = klaidinga; uint8_t eilutėCnt = 0; uint8_t charCnt = 0; char skaitytiChar = 0; while (! ConfirmBreak) {if (Serial.available ()) {uartBuffer [charCnt] = Serial.read (); if (charCnt> = 29) confirmBreak = tiesa; else charCnt ++; }} Serial.println („Gerai“); storeEEPROM (); }

void initValues () {

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

MIDI komunikacijų tvarkytojai su 1 sekundės užrašo atidėjimo vėlavimu

/ * Paleisti MIDI užrašų funkciją */

void midiOut (enum DRUM_POSITION drumIn) {

if (drumIn == HIHAT) {// Jei nukentėjo HI-HAT, reikia patikrinti, ar pedalas yra paspaustas, jei (! digitalRead (drumPins [HIHAT_PEDAL]))) {noteOn (0x90, drumNotes [HIHAT_PEDAL], drumVelocities [HIHAT_PEDAL]); uždelsimas (1); noteOn (0x90, drumNotes [HIHAT_PEDAL], 0); } else {noteOn (0x90, drumNotes [HIHAT], drumVelocities [HIHAT]); uždelsimas (1); noteOn (0x90, drumNotes [HIHAT], 0); }} else {// Įprastas būgno MIDI perdavimo užrašasOn (0x90, drumNotes [drumIn], drumVelocities [drumIn]); uždelsimas (1); noteOn (0x90, drumNotes [drumIn], 0); }}

void noteOn (int cmd, int pitch, int greitis) {Serial.write (cmd); Serial.write (žingsnis); Serial.write (greitis); }

sąrankos () ir kilpos () funkcijos su begaline įrenginio veikimo kilpa:

void setup () {

Serial.begin (115200);

for (uint8_t i = 0; i <10; i ++) {pinMode (i+2, INPUT); } #ifdef PRINT_PADS_PIN_NUMBERS while (true) {// Begalinė derinimo kilpa (uint8_t i = 0; i <10; i ++) {if (! digitalRead (i+2)) {Serial.print ("Pin No: D"); Serijinis atspaudas (i + '0'); // Konvertuoti skaičių į ASCII simbolį}}} #else initValues (); / * Programavimo režimas: jei įkrovos metu paspaudžiami du pedalai - režimas įjungtas */ 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); // Palyginti būsenas ir aptikti krintantį kraštą previousState = currentState ; } kick.update (); // „Kick drum“naudoja pasirinktinį atmetimo algoritmą if (kick.edge ()) if (kick.falling ()) midiOut (KICK); }

5 veiksmas: programavimas B: „Python“ir vartotojo sąsaja

„Python“vartotojo sąsaja yra šiek tiek sudėtinga suprasti iš pirmo žvilgsnio, todėl pabandytume paaiškinti jos pagrindus, kaip naudotis, kokią funkciją turi kiekvienas mygtukas ir kaip tinkamai užprogramuoti „Arduino“įrenginį.

Vartotojo sąsaja - programa

Naudotojo sąsaja yra grafinis mūsų būgnų rinkinio programuotojo atvaizdas, todėl jį naudoti tikrai paprasta ir patogu bet kuriuo metu programuoti „Arduino“įrenginį. UI sudaro keli grafiniai moduliai, susieti su jų siūloma operacija. apžvelkime juos po vieną:

1. Būgno rinkinio vaizdas: „Python“vartotojo sąsaja naudoja XY vaizdo koordinates, kad nustatytų, kuris būgno tipas buvo pasirinktas. Jei pasirinkta tinkama būgno sritis, rodomas antrinis IO pranešimas su pastabos laukais, greičiu ir „Arduino“gnybtu, skirtu specialiai būgno pagalvei. Vartotojui patvirtinus ir patvirtinus šiuos parametrus, šias reikšmes galima tiesiogiai perduoti į „Arduino“įrenginį.
2. Išorinio valdiklio vaizdas: Kad galėtumėte naudoti MIDI būgnų rinkinį su VST/muzikos kūrimo aplinka, reikia paleisti serijinį į MIDI vertėją. Aš naudoju „Hairless“, kurį galima įsigyti nemokamai ir kurį galima paleisti tiesiai iš mūsų vartotojo sąsajos, tiesiog paspaudus jo vaizdą.
3. COM prievadų sąrašas: Norint bendrauti su „Arduino“, reikia nurodyti prie jo pridėtą COM prievadą. Sąrašas atnaujinamas paspaudus mygtuką „Atnaujinti“.
4. Įkelti/išsaugoti konfigūraciją: kode yra nustatytos numatytosios MIDI reikšmės, kurias vartotojas gali keisti sąveikaudamas su vartotojo sąsaja. Konfigūracija apibrėžta faile config.txt tam tikru formatu, kurį vartotojas gali išsaugoti arba įkelti.
5. Programavimo įrenginio mygtukas: Norint išsaugoti visas modifikuotas MIDI reikšmes „Arduino EEPROM“, po to reikia paspausti du pedalus („Kick būgno“ir „Hi-hat“pedalas), palaukite, kol duomenys bus perduoti. Jei iškilo kokių nors bendravimo problemų, bus rodomas tinkamas iššokantis langas. Jei perduoti pavyks, vartotojo sąsaja parodys sėkmingą pranešimą.
6. Išėjimo mygtukas: tiesiog išeikite iš programos su vartotojo leidimu.

Svarbiausi „Python“kodo elementai

Kode yra daug dalykų, todėl išplėsime rašytines funkcijas, o ne visą kodą.

Visų pirma, norint naudoti UI, reikia atsisiųsti kelis modulius, kad kodas veiktų:

importuoti „osimport“sriegį importuoti „tkinter“kaip tk iš „tkinter“importuoti pranešimų dėžutę iš „tkinter import“* iš „PIL import“

Kai kurie moduliai yra įtraukti į numatytąjį „Python“paketą. Naudojant PIP įrankį reikia įdiegti kelis modulius:

pip įdiegti pagalvę

pip install numpy pip install ScreenInfo

Primygtinai rekomenduojama paleisti programą per „PyCharm“. Būsimuose leidimuose planuoju eksportuoti vykdomąjį failą projektui.

Trumpas kodo paaiškinimas

Bus daug lengviau suprasti kodą, jei pažvelgsime į jo eilutes funkcijų ir klasių požiūriu:

1. Pagrindinė funkcija - čia prasideda kodas

jei _vardas_ == '_main_': drumkit_gui ()

2. Būgno rinkinio konstantos, koordinatės ir numatytoji MIDI informacija

klasės būgnai: DRUM_TYPES = ["Kick", "Hihat", "Snare", "Crash 1", "Crash 2", "Tom High", "Tom Mid", "Tom Low", "Ride", "Hihat Pedal" "," Valdiklis "]

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 funkcijos - vartotojo sąsajos ir grafinių objektų tvarkymas

def set_active (vartotojo sąsaja)

def Second_ui (būgno tipas)

klasė SelectionUi (tk. Frame)

klasės taikymas (tk. Frame)

def drumkit_gui ()

def event_ui_clicked (įvykis)

def getorigin (aš, įvykis)

4. Serijinis bendravimas

def get_serial_ports ()

def bendrauti_su_arduino (uostas)

5. Darbas su failais: išsaugokite/įkelkite nustatymus iš txt failo

def save_config ()

def load_config ()

6. Vykdykite išorinę programą hairless.exe iš kodo naudodami „Python Threading“galimybes

klasė ExternalExecutableThread (threading. Thread)

def run_hairless_executable ()

Norėdami paleisti kodą, yra failų, kurie turi būti pridėti prie projekto aplanko, sąrašas:

• config.txt: nustatymų failas
• hairless.exe: beplaukis MIDI keitiklis
• drumkit.png: vaizdas, kuris apibrėžia visas mūsų vartotojo sąsajos spustelėjamas būgno pagalvėles (turi būti atsisiųstas iš šio veiksmo vaizdų rinkinio)
• drumgui.py: projekto kodas

Tai viskas, ką turime pabrėžti, kad tai veiktų. Labai svarbu į projektą įtraukti failus: būgno rinkinio atvaizdą, vykdomąjį failą hairless.exe ir nustatymų failą config.txt.

Ir.. Štai mes padarėme!:)

Tikimės, kad ši pamoka jums bus naudinga.

Ačiū, kad skaitote!:)