MIDI Drum Kit პითონზე და არდუინოზე: 5 ნაბიჯი (სურათებით)

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:16

ბავშვობიდან ყოველთვის მინდოდა ბარაბნის ნაკრების ყიდვა. მაშინ, ყველა მუსიკალურ აღჭურვილობას არ გააჩნდა ყველა ციფრული პროგრამა, როგორც დღეს გვაქვს, ამიტომ ფასები მოლოდინებთან ერთად ძალიან მაღალი იყო. ცოტა ხნის წინ მე გადავწყვიტე ვიყიდო იაფი დრამის ნაკრები eBay– დან, ერთადერთი პრიორიტეტით: მისი დანგრევის შესაძლებლობა და მოწყობილობაზე ჩემი საკუთარი ტექნიკის და პროგრამული უზრუნველყოფის მიმაგრება.

შესყიდვა სულაც არ იყო იმედგაცრუებული: პორტატული მოძრავი ბარაბანი ნაკრები 9 განსხვავებული ხმის ბალიშით, ორი ფეხის გადამრთველი პედლითათვის ბარაბანი და მაღალ ქუდი და მიკრო USB დენის ბუდე. რაც მართლაც დემოტივაციას ახდენს, ეს არის გამომავალი ხმები (ამ ნაკრების რეალური გამოყენება გარე სპიკერის დაკავშირება და სიამოვნებაა). ასე რომ, მე გადავწყვიტე მისი გადაკეთება USB- ის საშუალებით, MIDI ბარაბანი ნაკრები Arduino- ზე და მომხმარებლის ინტერფეისი დაფუძნებული Python– ზე, მოსახერხებელი გამოყენებისთვის და მარტივი მოდიფიკაციებისთვის, როგორიცაა მოცულობა, შენიშვნა და არხის შერჩევა.

მოწყობილობის მახასიათებლები:

• Დაბალი ფასი
• დრამის ნაკრების შექმნა ნებისმიერი ციფრული შეყვანისგან - ღილაკების მასივიც კი
• საკომუნიკაციო მხარდაჭერა და ელექტროენერგიის მიწოდება მხოლოდ USB ინტერფეისის საშუალებით - USB- ის UART გადამყვანსა და Arduino მოწყობილობის ინტეგრაცია
• მინიმალური ნაწილები სათანადო მუშაობისთვის
• ადვილად გამოსაყენებელი პითონის დაფუძნებული ინტერფეისი
• სრული MIDI მხარდაჭერა რეგულირებადი სიჩქარით, ნოტით და არდუინოს ქინძისთავებით
• მოწყობილობის მეხსიერებაში შენახული ბარაბნის მორგებული კონფიგურაციების შენახვა და ჩატვირთვა

გავაგრძელოთ პროექტი…

ნაბიჯი 1: ოპერაციის თეორია

ბლოკის დიაგრამა

უპირველეს ყოვლისა, მოდით ფოკუსირება გავაკეთოთ პროექტის სტრუქტურაზე და გავყოთ იგი ცალკეულ ბლოკებად:

Roll-Up Drum Kit

პროექტის მთავარი ერთეული. იგი შედგება 9 ცალკეული ბარაბნისგან, სადაც თითოეული ბალიში არის ღილაკების მასივი, რომელიც ცვლის მათ ლოგიკურ მდგომარეობას დარტყმის დროს. მისი სტრუქტურის გამო, არსებობს შესაძლებლობა ავაშენოთ ეს კონკრეტული ბარაბანი ნაკრები ნებისმიერი ღილაკისგან. თითოეული ბარაბანი უკავშირდება ძირითად ელექტრონულ დაფაზე გამწევ რეზისტორს, ამრიგად, სანამ ბარაბანი არაერთხელ ურტყამს, კონკრეტული გადამრთველი მიბმულია მიკროსქემის მიწაზე და ლოგიკური LOW არის დრამის ბალიშის ხაზზე. როდესაც ზეწოლა არ ხდება, დრამის ბალიშის გადამრთველი ღიაა და ელექტროგადამცემი ხაზის გამწევ წინააღმდეგობის გამო, ლოგიკური HIGH არის დრამის ბალიშის ხაზზე. იმის გამო, რომ პროექტის მიზანია შექმნას სრული ციფრული MIDI მოწყობილობა, ძირითად PCB– ზე ყველა ანალოგური ნაწილის უგულებელყოფა შეიძლება. მნიშვნელოვანია აღინიშნოს, რომ დასარტყამი ნაკრები აქვს ორ პედლს დარტყმის ბარაბანზე და მაღალ ქუდზე, რომლებიც ასევე მიბმულია გამწევ რეზისტორებზე და იზიარებს იგივე მოქმედების ლოგიკას, როგორც ბარაბნის ყველა ბალიში (ამაზე ცოტა მოგვიანებით ვისაუბრებთ).

Arduino Pro-Micro

დასარტყამი ნაკრების ტვინი. მისი მიზანია გამოავლინოს თუ არა სიგნალი დრამის ბალიშიდან და უზრუნველყოს შესაბამისი MIDI გამომავალი ყველა საჭირო პარამეტრით: შენიშვნა, სიჩქარე და სიგნალის ხანგრძლივობა. დრამის ბალიშების ციფრული ხასიათის გამო, ისინი შეიძლება უბრალოდ მიბმული იყოს არდუინოს ციფრულ საშუალებებზე (სულ 10 ქინძისთავით). იმისათვის, რომ შევინახოთ ყველა სასურველი პარამეტრი და MIDI ინფორმაცია, ჩვენ ვაპირებთ გამოვიყენოთ მისი მეხსიერება-EEPROM, ამიტომ ყოველ ჯერზე მოწყობილობის ჩართვისას MIDI ინფორმაცია იტვირთება EEPROM– დან, რაც ხდის ხელახლა პროგრამირებას და ხელახლა კონფიგურაციას. ასევე, Arduino Pro-Micro ხელმისაწვდომია ძალიან მცირე პაკეტში და მისი ადვილად გადანაწილება შესაძლებელია დრამის ნაკრების შიდა ყუთში.

FTDI USB სერიული კონვერტორი

იმისათვის, რომ დავამტკიცოთ და განვსაზღვროთ ჩვენი მოწყობილობის მახასიათებლები კომპიუტერული პროგრამის გამოყენებით, საჭიროა USB ინტერფეისის სერიულ გადაყვანა, რადგან Arduino Pro-Micro– ს არ აქვს USB. ვინაიდან მოწყობილობებს შორის კომუნიკაცია ემყარება UART- ს, FTDI მოწყობილობა გამოიყენება ამ პროექტში, მისი სიმარტივის გამო, მიუხედავად მისი დამატებითი თვისებებისა.

კომპიუტერის პროგრამა - პითონი

რაც შეეხება მომხმარებლის ინტერფეისების განვითარებას და სწრაფად ასაშენებელ პროექტებს, პითონი არის შესანიშნავი გამოსავალი. UI პროგრამის მიზანია გაცილებით მოსახერხებელი გახადოს MIDI თვისებების ხელახალი განსაზღვრა ჩვენი დრამის ნაკრებისთვის, ინფორმაციის შენახვა, პროგრამული მოწყობილობა და სისტემებს შორის კომუნიკაციის დამყარება კოდის შედგენის აუცილებლობის გარეშე. იმის გამო, რომ ჩვენ ვიყენებთ სერიულ ინტერფეისს დრამის ნაკრებთან დასაკავშირებლად, ინტერნეტში არის უამრავი უფასო მოდული, რომელიც მხარს უჭერს ნებისმიერი სახის სერიულ კომუნიკაციას. გარდა ამისა, როგორც მოგვიანებით იქნება განხილული, UART ინტერფეისი შედგება სამი ქინძისთავისგან: RXD, TXD და DTR. DTR გამოიყენება Arduino მოდულის გადატვირთვის შესასრულებლად, ამრიგად, როდესაც ჩვენ დაინტერესებულნი ვართ MIDI პროგრამის გაშვებით ან UI პროგრამის მოწყობილობასთან დაკავშირებით, აბსოლუტურად არ არის საჭირო USB კაბელის ხელახლა მიმაგრება.

ნაბიჯი 2: ნაწილები და ინსტრუმენტები

ნაწილები

• Roll-Up Drum Kit
• 2 x მდგრადი პედლები (ჩვეულებრივ, შედის DK პაკეტში).
• FTDI - USB სერიული კონვერტორი
• Arduino Pro Micro
• მიკრო USB კაბელი

ინსტრუმენტები

• შედუღების რკინა/სადგური
• Soldering Tin
• თხელი დიამეტრის ერთი ბირთვიანი მავთული
• პინცეტი
• საჭრელი
• პლიერი
• დანა
• ხრახნიანი დრაივერი
• 3D პრინტერი (სურვილისამებრ - მორგებული პედლებიანი პლატფორმებისთვის)

პროგრამული უზრუნველყოფა

• Arduino IDE
• პითონი 3 ან უფრო მაღალი
• JetBrains Pycharm
• თმის ვარცხნილობის MIDI ინტერფეისი
• მარყუჟი MIDI

ნაბიჯი 3: შედუღება და შეკრება

ვინაიდან სამი მოდული უნდა გაერთიანდეს, შედუღების და შეკრების პროცესი მოკლე და მარტივია:

• მიამაგრეთ Arduino Pro-Micro FTDI მოწყობილობასთან ერთად, დარწმუნდით, რომ კავშირები შეესაბამება თითოეულ მოწყობილობაზე განსაზღვრულ I/O- ს:

  • VBUS-VBUS
  • GND-GND
  • DTR-DTR
  • RXD-TXD
  • TXD-RXD
• ამოიღეთ ყველა ხრახნი დრამის პლასტმასის შიგნიდან, დარწმუნდით, რომ შეგიძლიათ ფოკუსირება მოახდინოთ დაფაზე დაფაზე კაბელზე და მის გამწევ რეზისტორებზე

• შეაერთეთ თხელი მავთულები Arduino-FTDI მოდულისთვის, რომელიც ჩვენ ადრე ავაშენეთ:

  • ციფრული საშუალებები: D [2:11]
  • VBUS
  • D+
  • დ-
  • GND
• ჩადეთ მოდული ბატარეის კორპუსში ისე, რომ მავთულები მოძრაობდეს იმავე მხარეს, როგორც ბალიშების ამწევი რეზისტორები
• შეაერთეთ ყველა ციფრული შეყვანა დრამის ტერმინალებზე, როგორც ეს ნაჩვენებია ბოლო ფიგურაში.
• შეაერთეთ მიკრო USB ავტობუსი (VBUS, D+, D-, GND) FTDI მოწყობილობაზე, დარწმუნდით, რომ არ არის შეცდომები ამ მავთულხლართების მიკვლევაში.
• მიამაგრეთ Arduino-FTDI მოდული ცხელი წებოთი ბატარეის კორპუსზე
• ააწყეთ მოწყობილობა შესაბამისი ხრახნების დანართით

ჩვენ ეს გავაკეთეთ, მოწყობილობა აწყობილია. მოდით გავაგრძელოთ კოდი…

ნაბიჯი 4: პროგრამირება 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};

/ * დარტყმის დრამუნის ხანგრძლივობა */

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 მონაცემთა განმცხადებლის დარტყმის შეგროვებისა და შესანახად (DRUM_PINS [KICK], KICK_DB_DURATION); // დებუნისერი ობიექტი დარტყმის არასტაბილური ბოულისთვის 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– დან*/

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

ცვლადების ინიციალიზაცია და პროგრამირების რეჟიმი, პედლების და Arduino ჩატვირთვის შემთხვევაში ერთდროულად გააქტიურებულია

void enterProgrammingMode () {

bool confirmBreak = ყალბი; uint8_t lineCnt = 0; uint8_t charCnt = 0; char readChar = 0; ხოლო (! 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); მემკვიდრეობა (drumVelocities, DRUM_VELOCITIES, 10); memcpy (drumPins, DRUM_PINS, 10); #სხვა დატვირთვაEEPROM (); #დაასრულე თუ }

MIDI საკომუნიკაციო დამმუშავებლები 1 ms შენიშვნის შენახვის დროის დაყოვნებით

/ * ითამაშეთ MIDI შენიშვნის ფუნქცია */

void midiOut (enum DRUM_POSITION drumIn) {

თუ (drumIn == HIHAT) {// თუ HI-HAT მოხვდა, საჭიროა შეამოწმოთ არის თუ არა პედლები დაჭერილი თუ (! digitalRead (drumPins [HIHAT_PEDAL])) {noteOn (0x90, drumNotes [HIHAT_PEDAL], drumVelocities [HIHAT_PEDAL]); დაგვიანება (1); შენიშვნა (0x90, drumNotes [HIHAT_PEDAL], 0); } else {noteOn (0x90, drumNotes [HIHAT], drumVelocities [HIHAT]); დაგვიანება (1); შენიშვნა (0x90, drumNotes [HIHAT], 0); }} სხვა {// რეგულარული დასარტყამი MIDI გადაცემის შენიშვნაOn (0x90, drumNotes [drumIn], drumVelocities [drumIn]); დაგვიანება (1); შენიშვნა (0x90, drumNotes [drumIn], 0); }}

void noteOn (int cmd, int pitch, int velocity) {Serial.write (cmd); სერიული. დაწერე (მოედანზე); სერიული. დაწერეთ (სიჩქარე); }

setup () და loop () ფუნქციები უსასრულო მოწყობილობის ოპერაციული მარყუჟით:

void setup () {

Serial.begin (115200);

for (uint8_t i = 0; i <10; i ++) {pinMode (i+2, INPUT); } #ifdef PRINT_PADS_PIN_NUMBERS ხოლო (ჭეშმარიტი) {// უსასრულო გამართვის მარყუჟი for (uint8_t i = 0; i <10; i ++) {if (! digitalRead (i+2)) {Serial.print ("Pin No: D"); Serial.print (i + '0'); // გადააქციე ნომერი ASCII სიმბოლოზე}}} #else initValues (); / * პროგრამირების რეჟიმი: თუ ჩატვირთვისას ორ პედლს დააჭერთ - რეჟიმი გააქტიურებულია */ თუ (! DigitalRead (drumPins [KICK]) &&! DigitalRead (drumPins [HIHAT_PEDAL])) enterProgrammingMode (); #დაასრულე თუ }

void loop () {for (uint8_t i = 1; i <9; i = i + 1) {currentState = digitalRead (drumPins ); თუ (! currentState && previousState ) midiOut (i); // შეადარეთ მდგომარეობა და აღმოაჩინეთ დაცემული ზღვარი previousState = currentState ; } kick.update (); // დარტყმის ბარაბანი იყენებს მორგებულ დებიუნსის ალგორითმს if (kick.edge ()) if (kick.falling ()) midiOut (KICK); }

ნაბიჯი 5: პროგრამირება B: პითონი და მომხმარებლის ინტერფეისი

პითონის მომხმარებლის ინტერფეისი ერთი შეხედვით ცოტათი გასაგებია, ამიტომ ჩვენ შევეცდებით ავხსნათ მისი საფუძვლები, როგორ გამოვიყენოთ, რა ფუნქცია აქვს ყველა ღილაკს და როგორ დავაპროგრამოთ Arduino მოწყობილობა სწორად.

მომხმარებლის ინტერფეისი - პროგრამა

UI არის გრაფიკული გამოსახულება ჩვენი დრამის ნაკრების პროგრამისტისთვის, რაც მას მართლაც ადვილად გამოსაყენებელს და მოსახერხებელს ხდის Arduino მოწყობილობის ნებისმიერ დროს პროგრამირებაში. UI შედგება რამდენიმე გრაფიკული მოდულისგან, რომლებიც დაკავშირებულია მათ შემოთავაზებულ ოპერაციასთან. მოდით გადახედოთ მათ სათითაოდ:

1. Drum Set Image: პითონის ინტერფეისი იყენებს X-Y გამოსახულების კოორდინატებს იმის დასადგენად, თუ რომელი დრამის ტიპია არჩეული. თუ ბარაბნის მოქმედი არე იყო არჩეული, მეორადი IO შეტყობინება გამოჩნდება, სადაც აღინიშნება ველები, სიჩქარე და არდუინოს ტერმინალი დრამის ბალიშისათვის. მას შემდეგ, რაც ეს პარამეტრები დადასტურდება მომხმარებლის მიერ და დამტკიცდება, ეს მნიშვნელობები შეიძლება გადაეცეს პირდაპირ Arduino მოწყობილობას.
2. გარე კონტროლერის სურათი: იმისათვის, რომ შეძლოთ MIDI დრამის ნაკრების გამოყენება VST/მუსიკის შექმნის გარემოთი, საჭიროა სერიული-MIDI თარჯიმნის გაშვება. მე გამოვიყენე Hairless, რომელიც ხელმისაწვდომია უფასოდ და მისი გაშვება შესაძლებელია პირდაპირ ჩვენი ინტერფეისიდან, მხოლოდ მისი გამოსახულების დაჭერით.
3. COM პორტების სია: Arduino– სთან კომუნიკაციის მიზნით, თქვენ უნდა მიუთითოთ მისი თანდართული COM პორტი. სია განახლდება განახლების ღილაკზე დაჭერით.
4. კონფიგურაციის ჩატვირთვა/შენახვა: კოდში განსაზღვრულია ნაგულისხმევი MIDI მნიშვნელობები, რომელთა შეცვლაც მომხმარებელმა UI– თან ურთიერთქმედების გზით შეიძლება. კონფიგურაცია განსაზღვრულია config.txt ფაილში კონკრეტული ფორმატით, რომლის შენახვა ან ჩატვირთვა შესაძლებელია მომხმარებლის მიერ.
5. პროგრამის მოწყობილობის ღილაკი: იმისათვის, რომ შეინახოთ ყველა შეცვლილი MIDI მნიშვნელობა Arduino EEPROM– ში, თქვენ უნდა დააჭიროთ ორ ფეხს (Kick drum და Hi-hat pedal) ამის შემდეგ, დაელოდეთ მონაცემთა გადაცემის დასრულებას. თუ რაიმე კომუნიკაციის პრობლემა იყო, ნაჩვენები იქნება შესაბამისი pop-up. თუ გადაცემა წარმატებულია, ინტერფეისი აჩვენებს მის წარმატებულ შეტყობინებას.
6. გასვლის ღილაკი: უბრალოდ დატოვეთ პროგრამა, მომხმარებლის ნებართვით.

პითონის კოდის მაჩვენებლები

კოდში ბევრი რამ ხდება, ამიტომ ჩვენ გავაფართოვებთ წერილობით ფუნქციებს და არა მთელ კოდს.

უპირველეს ყოვლისა, ინტერფეისის გამოსაყენებლად საჭიროა რამდენიმე მოდულის გადმოტვირთვა, რათა კოდმა იმუშაოს:

იმპორტი osimport threading იმპორტი tkinter როგორც tk საწყისი tkinter იმპორტი შეტყობინება ყუთი tkinter იმპორტიდან * PIL იმპორტი ImageTk, სურათის იმპორტი numpy როგორც np იმპორტი სერიული იმპორტი გლობუსი

ზოგიერთი მოდული შედის ნაგულისხმევი პითონის პაკეტში. რამდენიმე მოდული უნდა იყოს დაინსტალირებული PIP ინსტრუმენტის საშუალებით:

pip დააინსტალირეთ ბალიში

pip დააინსტალირეთ numpy პიპი დააინსტალირეთ ScreenInfo

მკაცრად რეკომენდირებულია პროგრამის გაშვება PyCharm– ის საშუალებით. სამომავლო გამოშვებებში ვგეგმავ პროექტის შემსრულებლის ექსპორტს.

მოკლე კოდის ახსნა

კოდის გაგება გაცილებით ადვილი იქნება, თუ მის ხაზებს შევხედავთ ფუნქციების და კლასების თვალსაზრისით:

1. მთავარი ფუნქცია - აქ იწყება კოდი

თუ _name_ == '_ მთავარი_': 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 = ["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. ინტერფეისის ფუნქციები - მომხმარებლის ინტერფეისისა და გრაფიკული ობიექტების დამუშავება

def set_active (ui)

def საშუალო_ui (drum_type)

კლასის SelectionUi (tk. Frame)

კლასის აპლიკაცია (tk. Frame)

def drumkit_gui ()

def event_ui_clicked (ღონისძიება)

def getorigin (საკუთარი თავი, მოვლენა)

4. სერიული კომუნიკაცია

def get_serial_ports ()

def commun_w_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: სურათი, რომელიც განსაზღვრავს ყველა დასაწკაპუნებელ დრამს ჩვენს ინტერფეისზე (გადმოწერილი უნდა იყოს ამ ნაბიჯის სურათების ნაკრებიდან)
• drumgui.py: პროექტის კოდი

ეს არის ყველაფერი, რაც ჩვენ ხაზგასმით უნდა აღვნიშნოთ, რომ ის იმუშაოს. ძალიან მნიშვნელოვანია პროექტში ფაილების დამატება: drum set image, hairless.exe შესრულებადი და პარამეტრების ფაილი config.txt.

და.. აქ ჩვენ გავაკეთეთ!:)

ვიმედოვნებთ, რომ ეს სასწავლო ინსტრუქცია თქვენთვის სასარგებლო იქნება.

Მადლობა წაკითხვისთვის!:)