MIDI Drum Kit บน Python และ Arduino: 5 ขั้นตอน (พร้อมรูปภาพ)

2024 ผู้เขียน: John Day | [email protected]. แก้ไขล่าสุด: 2024-01-30 13:03

ฉันอยากซื้อกลองคิทมาตั้งแต่เด็ก ย้อนกลับไปในตอนนั้น อุปกรณ์ดนตรีทั้งหมดไม่มีแอปพลิเคชันดิจิทัลทั้งหมด เนื่องจากเรามีอยู่มากมายในปัจจุบัน ดังนั้นราคาและความคาดหวังจึงสูงเกินไป เมื่อเร็ว ๆ นี้ ฉันได้ตัดสินใจซื้อกลองชุดที่ถูกที่สุดจาก eBay โดยให้ความสำคัญเพียงอย่างเดียวคือ ความสามารถในการฉีกและต่อฮาร์ดแวร์และซอฟต์แวร์ของตัวเองเข้ากับอุปกรณ์

การซื้อนั้นไม่ทำให้ผิดหวังเลย: กลองชุดโรลอัพแบบพกพาพร้อมแผ่นเสียงที่แตกต่างกัน 9 แบบ แป้นเหยียบสวิตช์แบบสองเท้าสำหรับดรัมเตะและไฮแฮทและช่องเสียบไฟ micro-USB สิ่งที่ลดทอนลงจริงๆ ก็คือเสียงที่ส่งออก (การใช้งานจริงสำหรับชุดนี้คือการเชื่อมต่อลำโพงภายนอกและสนุกกับมัน) ดังนั้นฉันจึงตัดสินใจแปลงเป็นโปรแกรมของฉันเองผ่าน USB ดรัมคิท MIDI ที่ใช้ Arduino และส่วนต่อประสานผู้ใช้ตาม Python เพื่อการใช้งานที่สะดวกและการปรับเปลี่ยนที่ง่ายดาย เช่น ระดับเสียง บันทึกย่อ และการเลือกช่อง

คุณสมบัติของอุปกรณ์:

• ราคาถูก
• การสร้างชุดกลองจากอินพุตดิจิตอลใดๆ - แม้กระทั่งปุ่มกดแบบอาร์เรย์
• รองรับการสื่อสารและจ่ายไฟผ่านอินเทอร์เฟซ USB เท่านั้น - การรวม USB เข้ากับตัวแปลง UART และอุปกรณ์ Arduino
• ชิ้นส่วนขนาดเล็กเพื่อการทำงานที่เหมาะสม
• UI ที่ใช้ Python ที่ใช้งานง่าย
• รองรับ MIDI อย่างสมบูรณ์ด้วยความเร็วที่ปรับได้, โน้ตและพิน Arduino
• บันทึกและโหลดการกำหนดค่ากลองแบบกำหนดเองที่จัดเก็บไว้ในหน่วยความจำของอุปกรณ์

ไปต่อกันที่โครงการ…

ขั้นตอนที่ 1: ทฤษฎีการดำเนินงาน

บล็อกไดอะแกรม

ก่อนอื่น เรามาเน้นที่โครงสร้างโครงการกันก่อน แล้วแบ่งเป็นช่วงๆ:

ชุดกลองโรลอัพ

หน่วยหลักของโครงการ ประกอบด้วยดรัมแพดแยกกัน 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: ชิ้นส่วนและเครื่องมือ

อะไหล่

• ชุดกลองโรลอัพ
• 2 x Sustain Pedal (ปกติจะรวมอยู่ในแพ็คเกจ DK)
• FTDI - USB เป็นตัวแปลงอนุกรม
• Arduino Pro Micro
• สายไมโคร USB

เครื่องมือ

• หัวแร้ง/สถานี
• บัดกรีดีบุก
• ลวดแกนเดี่ยวเส้นผ่านศูนย์กลางบาง
• แหนบ
• เครื่องตัด
• คีม
• มีด
• ไขควง
• เครื่องพิมพ์ 3 มิติ (ตัวเลือก - สำหรับแท่นเหยียบแบบกำหนดเอง)

ซอฟต์แวร์

• Arduino IDE
• Python 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+
  • NS-
  • GND
• ใส่โมดูลเข้าไปในกล่องแบตเตอรี่เพื่อให้สายไฟลอยอยู่ด้านเดียวกับตัวต้านทานแบบดึงขึ้นของแผ่นอิเล็กโทรด
• ประสานอินพุตดิจิตอลทั้งหมดเข้ากับขั้วต่อดรัมแพดดังที่แสดงในรูปสุดท้าย
• บัดกรีบัส micro-USB (VBUS, D+, D-, GND) ไปยังอุปกรณ์ FTDI ตรวจสอบให้แน่ใจว่าไม่มีข้อผิดพลาดในการติดตามสายเหล่านี้
• ติดโมดูล Arduino-FTDI ด้วยกาวร้อนกับกล่องแบตเตอรี่
• ประกอบอุปกรณ์ด้วยสกรูยึดที่เหมาะสม

เราเสร็จแล้ว อุปกรณ์ประกอบ. มาต่อกันที่โค้ด…

ขั้นตอนที่ 4: การเขียนโปรแกรม A: Arduino

ให้อธิบายร่างของเราทีละขั้นตอน:

ประการแรก จำเป็นต้องมีไลบรารี่ที่จำเป็นสองไลบรารีสำหรับการทำงานที่เหมาะสม EEPROM ได้รับการติดตั้งไว้ล่วงหน้าใน Arduino IDE แล้ว แต่จะต้องติดตั้งโมดูล debouncer สำหรับ kick drum แยกต่างหาก

#รวม #รวม

สวิตช์เหล่านี้ส่วนใหญ่จะใช้ในลำดับการดีบัก หากคุณต้องการลองเชื่อมต่อเทอร์มินัล Arduino กับดรัมแพด และกำหนดอินพุตดิจิตอลทั้งหมด ควรกำหนดสวิตช์เหล่านี้

/* Developer Switches: Uncomment โหมดที่ต้องการสำหรับการดีบักหรือการเริ่มต้น *///#define LOAD_DEFAULT_VALUES // โหลดค่าคงที่แทน EEPROM //#define 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 Buffer สำหรับรวบรวมและจัดเก็บ MIDI Data Debouncer kick (DRUM_PINS[KICK], KICK_DB_DURATION); // วัตถุ Debouncer สำหรับกลองเตะ volatile bool PreviousState[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // ลอจิกก่อนหน้าของ Drum pad ระบุสถานะบูลแบบระเหย currentState[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Drum pad สถานะลอจิกปัจจุบัน

ฟังก์ชัน EEPROM

/* จัดเก็บการตั้งค่าใน EEPROM*/

โมฆะ storeEEPROM () {

memcpy (drumNotes, uartBuffer, 10); memcpy(drumPins, uartBuffer + 10, 10); memcpy(drumVelocities, uartBuffer + 20, 10); สำหรับ (uint8_t i = 0; i < 10; i++) EEPROM.write (NOTES_ADDR + i, drumNotes); สำหรับ (uint8_t i = 0; i < 10; i++) EEPROM.write (PINS_ADDR + i, drumPins); สำหรับ (uint8_t i = 0; i < 10; i++) EEPROM.write (VELOCITIES_ADDR + i, drumVelocities); }

/* โหลดการตั้งค่าจาก EEPROM*/

เป็นโมฆะ loadEEPROM () { สำหรับ (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); สำหรับ (uint8_t i = 0; i < 10; i++) drumVelocities = EEPROM.read(VELOCITIES_ADDR + i); }

การเริ่มต้นของตัวแปรและโหมดการเขียนโปรแกรม ในกรณีของเหยียบและบูต Arduino ถูกเปิดใช้งานพร้อมกัน

เป็นโมฆะ enterProgrammingMode () {

บูล ConfirmBreak = เท็จ; uint8_t lineCnt = 0; uint8_t charCnt = 0; ถ่าน readChar = 0; ในขณะที่ (!confirmBreak) { ถ้า (Serial.available ()) { uartBuffer [charCnt] = Serial.read (); ถ้า (charCnt >= 29) ConfirmBreak = true; อื่น charCnt++; } } Serial.println("ตกลง"); ร้านค้าEEPROM(); }

เป็นโมฆะ initValues () {

#ifdef LOAD_DEFAULT_VALUES memcpy(drumNotes, DRUM_NOTES, 10); memcpy(drumVelocities, DRUM_VELOCITIES, 10); memcpy (กลองพิน, DRUM_PINS, 10); #else โหลดEEPROM(); #endif }

ตัวจัดการการสื่อสาร MIDI ที่มีความล่าช้า 1ms เวลาในการบันทึกโน้ต

/* เล่นฟังก์ชันโน้ต MIDI */

เป็นโมฆะ midiOut (enum DRUM_POSITION drumIn) {

if (drumIn == HIHAT) { // หาก HI-HAT โดน จำเป็นต้องตรวจสอบว่ามีการเหยียบแป้นหรือไม่ if (!digitalRead(drumPins[HIHAT_PEDAL])) { noteOn(0x90, drumNotes[HIHAT_PEDAL], drumVelocities [HIHAT_PEDAL]); ล่าช้า(1); noteOn(0x90, ดรัมโน้ต[HIHAT_PEDAL], 0); } อื่น ๆ { noteOn(0x90, drumNotes[HIHAT], drumVelocities[HIHAT]); ล่าช้า(1); noteOn(0x90, ดรัมโน้ต[HIHAT], 0); } } อื่น {// กลองปกติการส่ง MIDI noteOn(0x90, drumNotes[drumIn], drumVelocities[drumIn]); ล่าช้า(1); noteOn(0x90, ดรัมโน้ต[drumIn], 0); } }

เป็นโมฆะ noteOn (int cmd, int pitch, int velocity) { Serial.write (cmd); Serial.write(พิทช์); Serial.write (ความเร็ว); }

ฟังก์ชัน setup() และลูป () พร้อมลูปการทำงานของอุปกรณ์ไม่สิ้นสุด:

การตั้งค่าเป็นโมฆะ () {

Serial.begin(115200);

สำหรับ (uint8_t i = 0; i < 10; i ++) {pinMode (i + 2, INPUT); } #ifdef PRINT_PADS_PIN_NUMBERS ในขณะที่ (จริง) { // ลูปดีบักอนันต์สำหรับ (uint8_t i = 0; i <10; i++) { if (!digitalRead (i + 2)) { Serial.print ("Pin No: D"); Serial.print(i + '0'); // แปลงตัวเลขเป็นอักขระ ASCII } } } #else initValues(); /* โหมดการเขียนโปรแกรม: หากเหยียบแป้นสองแป้นขณะบูต - โหมดถูกเปิดใช้งาน */ if (!digitalRead(drumPins[KICK]) && !digitalRead(drumPins[HIHAT_PEDAL])) enterProgrammingMode(); #endif }

วงเป็นโมฆะ () { สำหรับ (uint8_t i = 1; i <9; i = i + 1) { currentState = digitalRead (drumPins ); ถ้า (!currentState && PreviousState) midiOut(i); // เปรียบเทียบสถานะและตรวจหาขอบที่ตกลงมา PreviousState = currentState; } kick.update(); // Kick drum ใช้อัลกอริธึม debounce แบบกำหนดเอง if (kick.edge()) if (kick.falling()) midiOut(KICK); }

ขั้นตอนที่ 5: การเขียนโปรแกรม B: Python & User Interface

ส่วนต่อประสานผู้ใช้ Python นั้นซับซ้อนเล็กน้อยที่จะเข้าใจตั้งแต่แรกเห็น ดังนั้นเราจะพยายามอธิบายพื้นฐานของมัน วิธีใช้งาน ทุกปุ่มมีฟังก์ชันอะไรบ้าง และวิธีตั้งโปรแกรมอุปกรณ์ Arduino อย่างถูกต้อง

ส่วนต่อประสานผู้ใช้ - แอปพลิเคชัน

UI คือการแสดงภาพกราฟิกสำหรับโปรแกรมเมอร์ชุดดรัมของเรา ทำให้ใช้งานง่ายและสะดวกในการตั้งโปรแกรมอุปกรณ์ Arduino ทุกเวลา UI ประกอบด้วยโมดูลกราฟิกหลายโมดูลที่เชื่อมโยงกับการทำงานที่แนะนำ มาทบทวนกันทีละคน:

1. ภาพชุดกลอง: Python UI ใช้พิกัดภาพ XY เพื่อกำหนดประเภทดรัมที่เลือก หากเลือกขอบเขตกลองที่ถูกต้อง ข้อความ IO สำรองจะปรากฏขึ้น พร้อมช่องหมายเหตุ ความเร็ว และเทอร์มินัล Arduino สำหรับดรัมแพดเฉพาะ หลังจากที่ผู้ใช้ตรวจสอบพารามิเตอร์เหล่านี้และได้รับการอนุมัติแล้ว ค่าเหล่านี้สามารถส่งไปยังอุปกรณ์ Arduino ได้โดยตรง
2. อิมเมจคอนโทรลเลอร์ภายนอก: เพื่อให้สามารถใช้ดรัมคิท MIDI กับสภาพแวดล้อมการสร้าง VST/Music ได้ จำเป็นต้องเรียกใช้ล่าม Serial-To-MIDI ฉันเคยใช้ Hairless ซึ่งให้บริการฟรีและสามารถเรียกใช้ได้โดยตรงจาก UI ของเราเพียงแค่กดที่รูปภาพ
3. รายการพอร์ต COM: ในการสื่อสารกับ Arduino จำเป็นต้องระบุพอร์ต COM ที่แนบมา กำลังรีเฟรชรายการโดยกดปุ่มรีเฟรช
4. การกำหนดค่าโหลด/บันทึก: มีค่า MIDI เริ่มต้นที่กำหนดไว้ในโค้ด ซึ่งผู้ใช้สามารถแก้ไขได้ผ่านการโต้ตอบกับ UI การกำหนดค่าถูกกำหนดในไฟล์ config.txt ในรูปแบบเฉพาะ ซึ่งผู้ใช้สามารถบันทึกหรือโหลดได้
5. ปุ่มโปรแกรมอุปกรณ์: ในการจัดเก็บค่า MIDI ที่แก้ไขแล้วทั้งหมดใน Arduino EEPROM จำเป็นต้องกดแป้นเหยียบ 2 อัน (Kick drum และ Hi-hat pedal) หลังจากนั้นรอให้การส่งข้อมูลเสร็จสิ้น หากมีปัญหาในการสื่อสาร ป๊อปอัปที่เหมาะสมจะปรากฏขึ้น หากการส่งสำเร็จ UI จะแสดงข้อความสำเร็จ
6. ปุ่มออก: เพียงออกจากแอปพลิเคชันโดยได้รับอนุญาตจากผู้ใช้

ไฮไลท์รหัสหลาม

มีหลายสิ่งที่เกิดขึ้นในโค้ด ดังนั้นเราจะขยายฟังก์ชันที่เป็นลายลักษณ์อักษรมากกว่าในโค้ดทั้งหมด

ก่อนอื่น เพื่อที่จะใช้ UI นั้น จำเป็นต้องดาวน์โหลดหลายโมดูล เพื่อให้โค้ดใช้งานได้:

นำเข้าเธรด osimport นำเข้า tkinter เป็น tk จากกล่องข้อความนำเข้า tkinter จากการนำเข้า tkinter * จาก PIL นำเข้า ImageTk การนำเข้ารูปภาพจำนวนมากเป็น np นำเข้าซีเรียลอิมพอร์ต glob

บางโมดูลรวมอยู่ในแพ็คเกจ Python เริ่มต้น ควรติดตั้งโมดูลหลายโมดูลผ่านเครื่องมือ PIP:

pip ติดตั้ง Pillow

pip ติดตั้ง numpy ติดตั้ง pip ติดตั้ง ScreenInfo

ขอแนะนำอย่างยิ่งให้เรียกใช้แอปพลิเคชันผ่าน PyCharm ในรุ่นต่อๆ ไป ฉันกำลังวางแผนที่จะส่งออกไฟล์ปฏิบัติการสำหรับโปรเจ็กต์

คำอธิบายรหัสโดยย่อ

มันจะง่ายกว่ามากที่จะเข้าใจโค้ดถ้าเราจะดูบรรทัดจากมุมมองของฟังก์ชันและคลาส:

1. ฟังก์ชั่นหลัก - นี่คือรหัสเริ่มต้น

ถ้า _name_ == '_main_': drumkit_gui()

2. ค่าคงที่ พิกัด และข้อมูล MIDI เริ่มต้นของ Drum Kit

กลองคลาส: DRUM_TYPES = ["Kick", "Hihat", "Snare", "Crash 1", "Crash 2", "Tom High", "Tom Mid", "Tom Low", "Ride", "Hihat Pedal" "," ผู้ควบคุม "]

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] DRUM_PINS = [8, 6, 4, 3, 11, 9, 5, 10, 2, 7]

3. ฟังก์ชั่น UI - การจัดการส่วนต่อประสานผู้ใช้และวัตถุกราฟิก

def set_active (ui)

def รอง_ui (กลอง_ประเภท)

class SelectionUi(tk. Frame)

แอปพลิเคชันคลาส (tk. Frame)

def drumkit_gui()

def event_ui_clicked(เหตุการณ์)

def getorigin(ตัวเอง, เหตุการณ์)

4. การสื่อสารแบบอนุกรม

def get_serial_ports()

def สื่อสาร_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

และ.. เสร็จแล้ว!:)

หวังว่าคุณจะพบว่าคำแนะนำนี้มีประโยชน์

ขอบคุณที่อ่าน!:)