MIDI Drum Kit Python- ի և Arduino- ի վրա. 5 քայլ (նկարներով)

2025 Հեղինակ: John Day | [email protected]. Վերջին փոփոխված: 2025-01-23 14:48

Մանկուց միշտ ցանկացել եմ թմբուկ գնել: Այն ժամանակ բոլոր երաժշտական սարքավորումները չունեին բոլոր թվային ծրագրերը, ինչպես մենք ունենք այսօր, ուստի գները սպասումների հետ միասին չափազանց բարձր էին: Վերջերս ես որոշեցի գնել ամենաէժան թմբուկի հավաքածուն eBay- ից ՝ միակ առաջնահերթությամբ.

Գնումը բոլորովին հիասթափեցնող չէր. Դյուրակիր թմբուկի հավաքածու ՝ 9 տարբեր ձայնային բարձիկներով, երկու ոտքով անջատիչ ոտնակներ հարվածային թմբուկի և բարձր գլխարկի և միկրո USB USB վարդակից: Այն, ինչ իսկապես քայքայում էր, դա ելքային հնչյուններն են (այս հավաքածուի իրական օգտագործումը արտաքին բարձրախոսին միացնելն ու վայելելն է): Այսպիսով, ես որոշեցի այն վերածել իմ ծրագրավորվող USB- ի ՝ Arduino- ի և MIDI թմբուկի հիման վրա, որը հիմնված է Arduino- ի և օգտագործողի միջերեսի վրա ՝ հիմնված Python- ի վրա, հարմար օգտագործման և հեշտ փոփոխությունների համար, ինչպիսիք են ՝ ծավալը, նշումները և ալիքների ընտրությունը:

Սարքի առանձնահատկությունները

• Ցածր գին
• Ստեղծելով թմբուկի հավաքածու ցանկացած թվային մուտքից `նույնիսկ սեղմիչ կոճակների զանգված
• Հաղորդակցության աջակցություն և սնուցում միայն USB ինտերֆեյսի միջոցով. USB- ից UART փոխարկիչ և Arduino սարքի ինտեգրում
• Նվազագույն մասեր `ճիշտ աշխատանքի համար
• Հեշտ օգտագործման Python- ի վրա հիմնված UI
• Ամբողջական MIDI աջակցություն ՝ կարգավորելի արագությամբ, նշումով և Arduino կապումներով
• Պահել և բեռնել սարքի հիշողության մեջ պահված թմբուկի հատուկ կազմաձևերը

Անցնենք նախագծին…

Քայլ 1. Գործողության տեսություն

Բլոկ սխեմա

Նախևառաջ, եկեք կենտրոնանանք ծրագրի կառուցվածքի վրա և այն բաժանենք առանձին բլոկների.

Roll-Up Drum Kit

Րագրի հիմնական միավորը: Այն բաղկացած է 9 առանձին թմբուկի բարձիկներից, որտեղ յուրաքանչյուր պահոց կոճակների զանգված է, որոնք հարվածի ժամանակ փոխում են իրենց տրամաբանական վիճակը: Իր կառուցվածքի պատճառով հնարավոր է թմբուկի այս հավաքածուն կառուցել ցանկացած կոճակներից: Թմբուկի յուրաքանչյուր բարձիկ միացված է հիմնական էլեկտրոնային տախտակի ձգվող դիմադրիչին, հետևաբար, երբ թմբուկի բարձիկը բազմիցս հարվածվում է, որոշակի անջատիչ կապված է շղթայի գետնին, և տրամաբանական LOW- ը առկա է թմբուկի բարձիկի գծում: Երբ ճնշում չի գործադրվում, թմբուկի բարձիկի անջատիչը բաց է և հոսանքի գծին ձգվող դիմադրության պատճառով տրամաբանական HIGH- ը առկա է թմբուկի բարձիկի գծի վրա: Քանի որ նախագծի նպատակն է ստեղծել ամբողջական թվային MIDI սարք, հիմնական PCB- ի բոլոր անալոգային մասերը կարող են անտեսվել: Կարևոր է նկատել, որ թմբուկի հավաքածուն ունի երկու ոտնակ `հարվածային թմբուկի և գլխարկի համար, որոնք նույնպես կապված են ձգվող դիմադրիչների հետ և կիսում են գործողության նույն տրամաբանությունը, ինչ թմբուկի բոլոր բարձիկները (մենք դա մի փոքր ուշ կքննարկենք):

Arduino Pro-Micro

Թմբուկի հավաքածուի ուղեղը: Դրա նպատակն է բացահայտել թմբուկի բարձիկից ազդանշանի առկայությունը և ապահովել համապատասխան MIDI ելք բոլոր անհրաժեշտ պարամետրերով `նշանի արագություն և տևողություն: Թմբուկի բարձիկների թվային բնույթի պատճառով դրանք կարող են պարզապես կապված լինել arduino թվային մուտքերի հետ (ընդամենը 10 կապում): Բոլոր ցանկալի պարամետրերը և MIDI տեղեկատվությունը պահելու համար մենք պատրաստվում ենք օգտագործել նրա հիշողությունը ՝ EEPROM, հետևաբար ամեն անգամ, երբ սարքը միացնում ենք, MIDI տեղեկատվությունը բեռնվում է EEPROM- ից ՝ դարձնելով այն ծրագրավորվող և վերակազմակերպելի: Բացի այդ, Arduino Pro-Micro- ն հասանելի է շատ փոքր փաթեթով և կարող է հեշտությամբ տեղաբաշխվել թմբուկի հավաքածուի ներքին պատյանում:

FTDI USB սերիական փոխարկիչ

Համակարգչային հավելվածի միջոցով մեր սարքի հատկությունները ծրագրավորելու և սահմանելու համար անհրաժեշտ է USB ինտերֆեյսը դարձնել սերիական, քանի որ Arduino Pro-Micro- ն USB չունի: Քանի որ սարքերի միջև հաղորդակցությունը հիմնված է UART- ի վրա, FTDI սարքը օգտագործվում է այս նախագծում `օգտագործման պարզության պատճառով` անկախ դրա լրացուցիչ հատկություններից:

ԱՀ դիմում - Python

Երբ խոսքը վերաբերում է օգտագործողների միջերեսների և արագ կառուցվող նախագծերի զարգացմանը, Python- ը հիանալի լուծում է: UI հավելվածի նպատակն է շատ ավելի հարմար դարձնել մեր թմբուկի համար MIDI հատկությունների վերաիմաստավորումը, տեղեկատվության պահպանումը, ծրագրային սարքը և համակարգերի միջև հաղորդակցության հաստատումը `առանց ծածկագիրը անընդհատ կազմելու անհրաժեշտության: Քանի որ մենք օգտագործում ենք սերիական ինտերֆեյս `թմբուկի հետ հաղորդակցվելու համար, ինտերնետում կան բազմաթիվ անվճար մոդուլներ, որոնք աջակցում են սերիական հաղորդակցության ցանկացած տեսակ: Բացի այդ, ինչպես կքննարկվի ավելի ուշ, UART ինտերֆեյսը բաղկացած է ընդամենը երեք կապից ՝ RXD, TXD և DTR: DTR- ն օգտագործվում է Arduino մոդուլի վերակայման համար, հետևաբար, երբ մենք շահագրգռված ենք MIDI հավելվածի գործարկմամբ կամ UI- ն ծրագրային սարքին միացնելով, բացարձակապես կարիք չկա USB մալուխը կամ որևէ այլ բան միացնելու:

Քայլ 2: Մասեր և գործիքներ

Մասեր

• Roll-Up Drum Kit
• 2 x Sustain Pedals (Սովորաբար, ներառված է DK փաթեթում):
• FTDI - USB- ից սերիական փոխարկիչ
• Arduino Pro Micro
• Միկրո USB մալուխ

Գործիքներ

• Sոդման երկաթ/կայան
• Sոդման անագ
• Բարակ տրամագծով մեկ միջուկային մետաղալար
• Պինցետ
• Դանակ
• Աքցան
• Դանակ
• Պտուտակահան
• 3D տպիչ (ըստ ցանկության `հարմարեցված ոտնակով հարթակների համար)

Ծրագրային ապահովում

• Arduino IDE
• Python 3 կամ ավելի բարձր
• JetBrains Pycharm
• Մազազուրկ MIDI ինտերֆեյս
• հանգույց MIDI

Քայլ 3: Sոդում և հավաքում

Քանի որ կան երեք մոդուլներ, որոնք պետք է համատեղվեն, զոդման և հավաքման գործընթացը կարճ և պարզ է.

• Միացրեք Arduino Pro-Micro- ն FTDI սարքի հետ, համոզվեք, որ կապերը համապատասխանում են յուրաքանչյուր սարքում սահմանված I/O- ին.

  • VBUS-VBUS
  • GND-GND
  • DTR-DTR
  • RXD-TXD
  • TXD-RXD
• Հեռացրեք թմբուկի պլաստիկ պատյանի բոլոր պտուտակները, համոզվեք, որ կարող եք կենտրոնանալ պահոցից դեպի տախտակ մալուխի և դրա ձգվող դիմադրիչների վրա:

• Thinոդեք բարակ մետաղալարեր Arduino-FTDI մոդուլի համար, որը մենք պատրաստել ենք նախկինում.

  • Թվային մուտքեր. D [2:11]
  • VBUS
  • D+
  • Դ-
  • GND
• Տեղադրեք մոդուլը մարտկոցի պատյանում, որպեսզի լարերը լողան նույն կողմում, ինչ բարձիկների ձգվող դիմադրիչները
• Digitalոդեք բոլոր թվային մուտքերը թմբուկի բարձիկների տերմինալներին, ինչպես ցույց է տրված վերջին նկարում:
• Միակցեք միկրո USB ավտոբուսը (VBUS, D+, D-, GND) FTDI սարքին, համոզվեք, որ այդ լարերը հետագծելիս սխալներ չկան:
• Մարտկոցի պատյանին ամրացրեք Arduino-FTDI մոդուլը տաք սոսինձով
• Տեղադրեք սարքը համապատասխան պտուտակների կցորդով

Մենք դա արել ենք, սարքը հավաքված է: Եկեք անցնենք ծածկագրին…

Քայլ 4. mingրագրավորում A: Arduino

Եկեք նկարագրենք մեր ուրվագիծը քայլ առ քայլ.

Նախևառաջ, անհրաժեշտ է երկու անհրաժեշտ գրադարան ներառել պատշաճ շահագործման համար: EEPROM- ն արդեն նախապես տեղադրված է Arduino IDE- ում, սակայն հարվածային թմբուկի ապակողպող մոդուլը պետք է տեղադրվի առանձին:

#ներառել #ներառել

Այս անջատիչներն օգտագործվում են հիմնականում կարգաբերման հաջորդականություններում: Եթե ցանկանում եք փորձել Arduino տերմինալների միացումը թմբուկի բարձիկներին և որոշել բոլոր թվային մուտքերը, ապա դրանք պետք է սահմանվեն:

/ * Մշակողի անջատիչներ. Արգելափակման կամ սկզբնավորման համար չցանկանալ մեկնաբանել * ///#սահմանել LOAD_DEFAULT_VALUES // Բեռնել հաստատուն արժեքներ EEPROM- ի փոխարեն //#սահմանել PRINT_PADS_PIN_NUMBERS // Տպել կապի համարը, որը միացված է սերիական պորտի միջոցով հարվածված բարձիկին

Մշտական դաշտերը ներկայացնում են բոլոր կանխադրված արժեքները, ներառյալ թմբուկի բարձիկների թվարկումը: Սարքն առաջին անգամ գործարկելու համար անհրաժեշտ է իմանալ Hi-Hat և Kick ոտնակների ճշգրիտ միացումը:

/ * Թմբուկի տեսակի թվարկում */

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

/ * Լռելյայն արժեքներ */

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

const uint8_t KICK_DB_DURATION = 30;

EEPROM- ն օգտագործվում է համակարգչի ծրագրից ստացված բոլոր տվյալները պահելու/բեռնելու համար: Հասցեները, որոնք նկարագրված են վերևում, ցույց են տալիս MIDI տեղեկատվության ճշգրիտ վայրը յուրաքանչյուր թմբուկի բարձիկի համար

/* EEPROM Հասցեների քարտեզավորում

Նշումներ `| 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 |

Կապում `| 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13 | Արագություններ | 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;

Գլոբալ փոփոխականներն օգտագործվում են յուրաքանչյուր բարձիկի վիճակը որոշելու և համապատասխանաբար MIDI հաղորդակցություն իրականացնելու համար:

/ * Գլոբալ փոփոխականներ */

uint8_t drumNotes [10], drumVelocities [10], drumPins [10]; // MIDI փոփոխականներ

uint8_t uartBuffer [64]; // UART բուֆեր MIDI Data Debouncer հարվածի հավաքման և պահպանման համար (DRUM_PINS [KICK], KICK_DB_DURATION); // Debouncer object for kick drum volatile bool previousState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Drum pad նախորդ տրամաբանական վիճակները անկայուն bool currentState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Թմբուկի պահոցի ընթացիկ տրամաբանական վիճակներ

EEPROM գործառույթներ:

/* Պահել կարգավորումները EEPROM- ում*/

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

/* Բեռնել կարգավորումները EEPROM- ից*/

անվավեր բեռ EEPROM () {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); }

Փոփոխականների և ծրագրավորման ռեժիմի սկզբնավորումը, ոտնակների դեպքում և Arduino բեռնախցիկի դեպքում միաժամանակ ակտիվանում են:

void enterProgrammingMode () {

bool confirmBreak = կեղծ; uint8_t lineCnt = 0; uint8_t charCnt = 0; char readChar = 0; while (! confirmBreak) {if (Serial.available ()) {uartBuffer [charCnt] = Serial.read (); if (charCnt> = 29) confirmBreak = true; այլապես charCnt ++; }} Serial.println ("Լավ"); storeEEPROM (); }

void initValues () {

#ifdef LOAD_DEFAULT_VALUES հիշողություն (drumNotes, DRUM_NOTES, 10); memcpy (drumVelocities, DRUM_VELOCITIES, 10); memcpy (drumPins, DRUM_PINS, 10); #այլ բեռ EEPROM (); #endif}

MIDI հաղորդակցման կարգավորիչներ ՝ 1 մգ նշման պահման հետաձգմամբ

/ * Խաղալ MIDI նշումների գործառույթ */

դատարկ midiOut (enum DRUM_POSITION drumIn) {

եթե (drumIn == HIHAT) {// Եթե HI-HAT- ը հարվածվել է, անհրաժեշտ է ստուգել, թե արդյոք ոտնակը սեղմված է, եթե (! digitalRead (drumPins [HIHAT_PEDAL])) {noteOn (0x90, drumNotes [HIHAT_PEDAL], drumVelocities [HIHAT_PEDAL]); ուշացում (1); noteOn (0x90, drumNotes [HIHAT_PEDAL], 0); } else {noteOn (0x90, drumNotes [HIHAT], drumVelocities [HIHAT]); ուշացում (1); noteOn (0x90, drumNotes [HIHAT], 0); }} else {// Թմբուկի կանոնավոր MIDI փոխանցման նշումOn (0x90, drumNotes [drumIn], drumVelocities [drumIn]); ուշացում (1); noteOn (0x90, drumNotes [drumIn], 0); }}

void noteOn (int cmd, int սկիպիդար, int արագություն) {Serial.write (cmd); Serial.write (սկիպիդար); Սերիա. Գրել (արագություն); }

setup () և loop () գործառույթները անսահմանափակ սարքի շահագործման օղակով

void setup () {

Serial.begin (115200);

for (uint8_t i = 0; i <10; i ++) {pinMode (i+2, INPUT); } #ifdef PRINT_PADS_PIN_NUMBERS while (true) {// Անսահման վրիպազերծման օղակ for (uint8_t i = 0; i <10; i ++) {if (! digitalRead (i+2)) {Serial.print ("Pin No: D"); Serial.print (i + '0'); // համարը փոխակերպել ASCII նիշի}}} #else initValues (); / * Mingրագրավորման ռեժիմ. Եթե բեռնման ընթացքում երկու ոտնակ սեղմված է `ռեժիմն ակտիվացված է */ եթե (! DigitalRead (drumPins [KICK]) &&! DigitalRead (drumPins [HIHAT_PEDAL])) enterProgrammingMode (); #endif}

void loop () {for (uint8_t i = 1; i <9; i = i + 1) {currentState = digitalRead (drumPins ); եթե (! currentState && previousState ) midiOut (i); // Համեմատեք վիճակները և հայտնաբերեք եզրերի անկում նախորդ State = currentState ; } kick.update (); // Kick drum- ը օգտագործում է անջատման հատուկ ալգորիթմ, եթե (kick.edge ()) if (kick.falling ()) midiOut (KICK); }

Քայլ 5. Bրագրավորում B. Python և օգտագործողի միջերես

Python- ի օգտագործողի միջերեսը մի փոքր բարդ է առաջին հայացքից հասկանալու համար, ուստի մենք կփորձենք բացատրել դրա հիմունքները, ինչպես օգտագործել, ինչ գործառույթ ունի յուրաքանչյուր կոճակ և ինչպես ճիշտ ծրագրավորել Arduino սարքը:

Օգտվողի միջերես - Դիմում

UI- ն գրաֆիկական պատկեր է մեր թմբուկի ծրագրավորողի համար, ինչը իսկապես դյուրին է դարձնում և հարմար է ցանկացած պահի Arduino սարքը ծրագրավորելու համար: UI- ն բաղկացած է մի քանի գրաֆիկական մոդուլներից, որոնք կապված են իրենց առաջարկած գործողության հետ: եկեք դրանք մեկ առ մեկ վերանայենք.

1. Թմբուկի պատկեր Եթե ընտրված է թմբուկի վավեր շրջանը, ապա հայտնվում է երկրորդային IO հաղորդագրությունը `նշման, արագության և Arduino տերմինալով` հատուկ թմբուկի համար: Այս պարամետրերը օգտագործողի կողմից հաստատվելուց և հաստատվելուց հետո այդ արժեքները կարող են ուղղակիորեն փոխանցվել Arduino սարքին:
2. Արտաքին վերահսկիչի պատկեր. Որպեսզի կարողանաք օգտագործել MIDI թմբուկի հավաքածուն VST/Music ստեղծող միջավայրով, անհրաժեշտ է գործարկել Serial-To-MIDI թարգմանիչ: Ես օգտագործել եմ Hairless- ը, որը հասանելի է անվճար և կարող է գործարկվել անմիջապես մեր UI- ից ՝ պարզապես սեղմելով դրա պատկերը:
3. COM նավահանգստի ցուցիչ. Arduino- ի հետ շփվելու համար անհրաժեշտ է նշել դրա կցված COM նավահանգիստը: Listանկը թարմացվում է ՝ սեղմելով Թարմացնել կոճակը:
4. Բեռնել/պահպանել կազմաձևը. Կան կանխադրված MIDI արժեքներ ծածկագրում, որոնք օգտագործողները կարող են փոփոխել UI- ի հետ փոխգործակցության միջոցով: Կազմաձևը սահմանվում է config.txt ֆայլում ՝ հատուկ ձևաչափով, որը կարող է պահպանվել կամ բեռնվել օգտվողի կողմից:
5. Deրագրի սարքի կոճակ. Arduino EEPROM- ում բոլոր փոփոխված MIDI արժեքները պահելու համար անհրաժեշտ է դրանից հետո երկու ոտնակ (Kick drum և Hi-hat ոտնակ) սեղմել, սպասել տվյալների փոխանցման ավարտին: Եթե որևէ կապի խնդիր կար, ապա կցուցադրվի համապատասխան թռուցիկ: Եթե փոխանցումը հաջողվի, UI- ն ցույց կտա իր հաջողված հաղորդագրությունը:
6. Ելքի կոճակ. Պարզապես դուրս եկեք ծրագրից ՝ օգտագործողի թույլտվությամբ:

Python Code- ի կարևորագույն կետերը

Կոդում շատ բաներ են կատարվում, այնպես որ մենք կընդլայնենք գրված գործառույթները, այլ ոչ թե ամբողջ ծածկագիրը:

Նախևառաջ, UI- ն օգտագործելու համար անհրաժեշտ է ներբեռնել մի քանի մոդուլ ՝ ծածկագիրը աշխատեցնելու համար.

ներմուծել osimport թելով ներմուծել tkinter որպես tk tkinter ներմուծել հաղորդագրություն tkinter ներմուծումից * PIL ներմուծումից ImageTk, Image import numpy as np import serial import glob

Որոշ մոդուլներ ներառված են լռելյայն Python փաթեթում: Մի քանի մոդուլ պետք է տեղադրվեն PIP գործիքի միջոցով.

pip տեղադրել Բարձ

pip install numpy pip տեղադրել ScreenInfo

Խստորեն խորհուրդ է տրվում կիրառել ծրագիրը PyCharm- ի միջոցով: Ապագա թողարկումներում ես պլանավորում եմ արտահանել նախագծի համար կատարվող ծրագիր:

Համառոտ օրենսգրքի բացատրություն

Շատ ավելի հեշտ կլինի հասկանալ կոդը, եթե դրա տողերին նայենք գործառույթների և դասերի տեսանկյունից.

1. Հիմնական գործառույթը `այստեղ կոդը սկսվում է

եթե _name_ == '_main_': drumkit_gui ()

2. Drum Kit- ի հաստատուններ, կոորդինատներ և կանխադրված MIDI տեղեկատվություն

դասի հարվածային գործիքներ ՝ DRUM_TYPES = [«Հարված», «Հիհաթ», «Թակարդ», «Վթար 1», «Վթար 2», «Թոմ Բարձր», «Թոմ Միդ», «Թոմ Լոու», «Ուղևորություն», «Հիհաթ ոտնակ» "," Կառավարիչ "]

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 = [«Հարված», «Թակարդ», «Հիհաթ», «Ուղևորություն», «Վթար 1», «Վթար 2», «Թոմ Բարձր», «Թոմ Միդ», «Թոմ Լոու», «Հիհաթ ոտնակ»]

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 գործառույթներ - Օգտվողի միջերեսի և գրաֆիկական օբյեկտների կառավարում

def set_active (UI)

def երկրորդական_ուի (թմբուկի տեսակ)

դաս SelectionUi (tk. Frame)

դասի դիմում (tk. Frame)

def drumkit_gui ()

def event_ui_clicked (իրադարձություն)

def getorigin (ես, իրադարձություն)

4. Սերիական հաղորդակցություն

def get_serial_ports ()

def commun_with_arduino (նավահանգիստ)

5. Ֆայլերի հետ աշխատել. Պահել/բեռնել կարգավորումները txt ֆայլից

def save_config ()

def load_config ()

6. Գործարկել արտաքին hairless.exe ծրագիրը ծածկագրից ՝ օգտագործելով Python Threading հնարավորությունները

դաս ExternalExecutableThread (threading. Thread)

def run_hairless_executable ()

Կոդը գործարկելու համար կա ֆայլերի ցանկ, որոնք պետք է կցվեն նախագծի թղթապանակին.

• config.txt: Կարգավորումների ֆայլ
• hairless.exe: Մազազուրկ MIDI փոխարկիչ
• drumkit.png: Պատկեր, որը սահմանում է մեր UI- ում թմբուկի բոլոր սեղմակները (պետք է ներբեռնել այս քայլի պատկերների հավաքածուից)
• drumgui.py: Նախագծի ծածկագիրը

Դա այն ամենն է, ինչ մենք պետք է ընդգծենք, որպեսզի այն աշխատի: Շատ կարևոր է նախագծին ֆայլեր ավելացնել ՝ թմբուկի հավաքածուի պատկեր, hairless.exe գործարկվող և պարամետրերի ֆայլ config.txt:

Եվ.. Ահա մենք արեցինք::)

Հուսով եմ, որ այս ուսանելիը օգտակար կգտնեք:

Շնորհակալություն կարդալու համար::)