ערכת תופים MIDI על פייתון וארדואינו: 5 שלבים (עם תמונות)

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:12

תמיד רציתי לקנות ערכת תופים מאז שהייתי ילד. אז, כל הציוד המוסיקלי לא היה בעל כל היישומים הדיגיטליים כפי שיש לנו הרבה היום, ולכן המחירים יחד עם הציפיות היו גבוהים מדי. לאחרונה החלטתי לרכוש ערכת תופים הזולה ביותר מאיביי, עם עדיפות יחידה: היכולת לקרוע אותה ולחבר חומרה ותוכנה משלי למכשיר.

הרכישה לא איכזבה כלל: ערכת תופים מגולגלים ניידים עם 9 כריות סאונד שונות, שתי דוושות מתג רגליים לתוף בעיטות והיי-כובע ושקע חשמל מיקרו USB. מה שבאמת היה מניע, זה צלילי הפלט (השימוש בפועל בערכה זו הוא חיבור רמקול חיצוני וליהנות ממנו). אז, החלטתי להמיר אותו לתכנות שלי באמצעות USB, ערכת תופים MIDI המבוססת על Arduino וממשק משתמש מבוסס Python, לשימוש נוח ושינויים קלים כמו, עוצמת שמע, הערות ובחירות ערוצים.

תכונות המכשיר:

• מחיר נמוך
• יצירת ערכת תופים מכל כניסות דיגיטליות - אפילו מערך כפתורי לחיצה
• תמיכה בתקשורת ואספקת חשמל באמצעות ממשק USB בלבד - שילוב ממיר USB ל- UART והתקן Arduino
• חלקי מינינום להפעלה תקינה
• ממשק משתמש מבוסס Python קל לשימוש
• תמיכת MIDI מלאה עם מהירות מתכווננת, פתק וסיכות ארדואינו
• שמור וטען תצורות תוף מותאמות אישית המאוחסנות בזיכרון המכשיר

בואו נמשיך לפרויקט…

שלב 1: תורת הפעולה

תרשים בלוקים

קודם כל, בואו נתמקד במבנה הפרויקט, ונחלק אותו לגושים נפרדים:

ערכת תופים מגולגלת

היחידה המרכזית של הפרויקט. הוא מורכב מ 9 רפידות תופים נפרדות, כאשר כל כרית היא מערך של כפתורים שמשנים את מצב ההיגיון שלהם בזמן שהם נפגעים. בגלל המבנה שלה, קיימת אפשרות לבנות את ערכת התופים המסוימת הזו מכל כפתורי לחיצה. כל כרית תוף מחוברת לנגד המשיכה שעל הלוח האלקטרוני הראשי, כך שבזמן שנפגע שוב ושוב על משטח התוף, מתג ספציפי נקשר לקרקע של המעגל ו- LOW לוגי קיים בקו כרית התופים. כאשר אין לחץ מופעל, מתג כרית התוף פתוח ובשל הנגד משיכה לקו החשמל, HIGH לוגי קיים בקו כרית התוף. מכיוון שמטרת הפרויקט היא יצירת מכשיר MIDI דיגיטלי שלם, ניתן להזניח את כל החלקים האנלוגיים במחשב הלוח הראשי. חשוב לשים לב שלערכת התופים יש שתי דוושות לתוף בעיטות והיי-האט, שגם הן קשורות לנגדי המשיכה וחולקות את אותו היגיון פעולה כמו כל כריות התוף (נדון בזה קצת אחר כך).

Arduino Pro-Micro

המוח של ערכת התופים. מטרתו היא לזהות אם יש אות יוצא ממשטח תופים ולספק פלט MIDI מתאים עם כל הפרמטרים הדרושים: הערה, מהירות ומשך האות. בגלל האופי הדיגיטלי של רפידות התופים, ניתן לקשור אותן פשוט לכניסות דיגיטליות של ארדואינו (10 פינים בסך הכל). על מנת לאחסן את כל ההגדרות הרצויות ומידע MIDI, אנו הולכים להשתמש בזיכרון שלו-EEPROM, ומכאן שכל פעם שאנו מפעילים את המכשיר, מידע MIDI נטען מ- EEPROM, מה שהופך אותו לתכנות מחדש וניתן להגדיר אותו מחדש. כמו כן, Arduino Pro-Micro זמין באריזה קטנה מאוד וניתן להקצות אותו בקלות בתוך מארז התוף הפנימי.

ממיר FTDI USB למערך סידורי

על מנת לתכנת ולהגדיר את תכונות המכשיר שלנו בעזרת יישום מחשב אישי, יש צורך להמיר ממשק USB לסדרה, מכיוון שלארדואינו פרו-מיקרו אין USB. מכיוון שהתקשורת בין מכשירים מבוססת על UART, מכשיר ה- FTDI משמש בפרויקט זה, בשל פשטות השימוש בו ללא קשר למאפיינים הנוספים שלו.

יישום מחשב - Python

כשזה מגיע לפיתוח ממשקי משתמש ופרויקטים מהירים לבנייה, פייתון הוא פתרון מעולה. מטרת יישום UI היא להפוך את זה להרבה יותר נוח להגדיר מחדש מאפייני MIDI עבור ערכת התופים שלנו, לאחסן מידע, לתכנת מכשיר ולעשות תקשורת בין המערכות ללא צורך בחיבור הקוד שוב ושוב. מכיוון שאנו משתמשים בממשק סידורי כדי לתקשר עם ערכת תופים, ישנם הרבה מודולים ללא תשלום ברחבי האינטרנט, התומכים בכל סוגי תקשורת טורית. בנוסף, כפי שידון בהמשך, ממשק UART מורכב משלושה סיכות: RXD, TXD ו- DTR. DTR משמש לביצוע איפוס במודול Arduino, ולכן כאשר אנו מעוניינים להריץ אפליקציית MIDI או לחבר ממשק משתמש למכשיר תכנות, אין צורך לחבר מחדש כבל USB או כלום.

שלב 2: חלקים ומכשירים

חלקים

• ערכת תופים מגולגלת
• 2 x דוושות Sustain (בדרך כלל, כלולות בחבילת DK).
• FTDI - ממיר USB לטורי
• Arduino Pro Micro
• כבל מיקרו USB

כלים

• מגהץ/תחנה
• פח הלחמה
• קוטר דק חוט ליבה אחת
• מַלְקֶטֶת
• מַחתֵך
• צבת
• סַכִּין
• מברג
• מדפסת תלת מימד (אופציונלי - לפלטפורמות דוושות מותאמות אישית)

תוֹכנָה

• Arduino IDE
• Python 3 או גבוה יותר
• JetBrains Pycharm
• ממשק MIDI ללא שיער
• loopMIDI

שלב 3: הלחמה והרכבה

מכיוון שיש לשלב שלושה מודולים, תהליך ההלחמה וההרכבה הוא קצר ופשוט:

• חבר את Arduino Pro-Micro יחד עם מכשיר FTDI, וודא שהחיבורים תואמים ל- I/O המוגדר בכל מכשיר:

  • VBUS-VBUS
  • GND-GND
  • DTR-DTR
  • RXD-TXD
  • TXD-RXD
• הסר את כל הברגים ממארז הפלסטיק של התוף, וודא שאתה יכול להתמקד בכבל משטח ללוח ובנגדי המשיכה שלו.

• חוטים דקים הלחמה עבור מודול Arduino-FTDI שבנינו בעבר:

  • כניסות דיגיטליות: D [2:11]
  • VBUS
  • D+
  • D-
  • GND
• הכנס את המודול לתוך מארז הסוללה כך שהחוטים יצפים באותו צד כמו נגדי משיכה של רפידות
• הלחם את כל הכניסות הדיגיטליות למסופי כרית התוף כפי שמוצג באיור האחרון.
• אוטובוס הלחמה מיקרו USB (VBUS, D+, D-, GND) למכשיר FTDI, וודא שאין טעויות במעקב אחר חוטים אלה.
• חבר את מודול ה- Arduino-FTDI עם דבק חם למארז הסוללה
• הרכיב את המכשיר עם חיבור ברגים מתאים

עשינו את זה, המכשיר מורכב. בואו נמשיך לקוד…

שלב 4: תכנות א: ארדואינו

בואו לתאר את הסקיצה שלנו שלב אחר שלב:

קודם כל, יש צורך לכלול שתי ספריות הכרחיות לפעולה התקינה. EEPROM כבר מותקן מראש ב- Arduino IDE, אך יש להתקין את מודול debouncer לתוף בעיטות בנפרד

#כלול #כלול

מתגים אלה משמשים בעיקר ברצפי איתור באגים. אם ברצונך לנסות את חיבור מסופי ה- 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 Data (DRUM_PINS [KICK], KICK_DB_DURATION); // אובייקט Debouncer לבול תוף נדיף bool previousState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // תוף משטח ההיגיון הקודם מצבי בול נוכחי 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); עבור (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*/

load voEEPROM () {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); עבור (uint8_t i = 0; i <10; i ++) drumVelocities = EEPROM.read (VELOCITIES_ADDR+i); }

אתחול המשתנים ומצב התכנות, במקרה של דוושות ומגף ארדואינו מופעלים במקביל

void enterProgrammingMode () {

bool confirmBreak = false; 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 (); }

initValues () {

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

מטפלים בתקשורת MIDI עם עיכוב של זמן השהיה של הערה של 1ms

/ * הפעל פונקציית פתק MIDI */

void 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 note note On (0x90, drumNotes [drumIn], drumVelocities [drumIn]); עיכוב (1); noteOn (0x90, drumNotes [drumIn], 0); }}

void noteOn (int cmd, int pitch, int speed) {Serial.write (cmd); Serial.write (פיצ'); Serial.write (מהירות); }

פונקציות ההתקנה () והלולאה () עם אינסוף פעולות המכשיר האינסופיות:

הגדרת בטל () {

Serial.begin (115200);

עבור (uint8_t i = 0; i <10; i ++) {pinMode (i+2, INPUT); } #ifdef PRINT_PADS_PIN_NUMBERS בעוד (true) {// אינסוף לולאת איתור באגים עבור (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 (); #endif}

לולאת void () {for (uint8_t i = 1; i <9; i = i + 1) {currentState = digitalRead (drumPins ); if (! currentState && previousState ) midiOut (i); // השווה מצבים וגלה ירידה בקדמת previousState = currentState ; } kick.update (); // תוף בעיטות משתמש באלגוריתם ניפוץ מותאם אישית אם (kick.edge ()) if (kick.falling ()) midiOut (KICK); }

שלב 5: תכנות B: ממשק פייתון ומשתמש

ממשק המשתמש של פייתון מעט מסובך להבנה ממבט ראשון, מכאן שננסה להסביר את היסודות שלו, כיצד להשתמש, באיזו פונקציה יש לכל לחצן וכיצד לתכנת מכשיר Arduino כראוי.

ממשק משתמש - יישום

ממשק המשתמש הוא ייצוג גרפי עבור מתכנת ערכות התופים שלנו, מה שהופך אותו ממש קל לשימוש ונוח לתכנת מכשיר Arduino בכל עת. ממשק המשתמש מורכב מכמה מודולים גרפיים הקשורים לפעולה המוצעת שלהם. בואו נסקור אותם אחד אחד:

1. תמונת ערכת תופים: ממשק המשתמש של Python משתמש בקואורדינטות תמונה XY כדי לקבוע איזה סוג תוף נבחר. אם נבחר אזור תוף תקף, תופיע הודעת IO משנית, עם שדות הערה, מהירות ומסוף Arduino עבור כרית תופים ייעודית. לאחר אימות הפרמטרים על ידי המשתמש ואישורם, ניתן להעביר ערכים אלה ישירות למכשיר Arduino.
2. תמונת בקר חיצוני: על מנת שתוכל להשתמש בערכת תופים של MIDI עם סביבת יצירת VST/מוסיקה, יש צורך בהפעלת מתורגמן ל- MIDI. השתמשתי ב- Hairless, הזמין בחינם וניתן להריץ ישירות מממשק המשתמש שלנו, רק על ידי לחיצה על התמונה שלו.
3. רשימת יציאות COM: על מנת לתקשר עם Arduino, יש לציין את יציאת ה- COM המצורפת שלה. הרשימה מתרעננת על ידי לחיצה על כפתור רענון.
4. תצורת טעינה/שמירה: ישנם ערכי MIDI המוגדרים כברירת מחדל בקוד, אותם ניתן לשנות על ידי המשתמש באמצעות אינטראקציה עם ממשק משתמש. התצורה מוגדרת בקובץ config.txt בפורמט ספציפי, אותו ניתן לשמור או לטעון על ידי המשתמש.
5. לחצן התקן התוכנית: על מנת לאחסן את כל ערכי ה- MIDI שהשתנו ב- Arduino EEPROM, יש צורך ללחוץ על שתי דוושות רגליים (תוף בעיטה ודוושת Hi-hat) לאחר מכן, המתן עד להשלמת הנתונים. אם היו בעיות תקשורת, יוצג מוקפץ תקין. אם השידור יצליח, ממשק המשתמש יציג את המסר המוצלח שלו.
6. לחצן יציאה: פשוט צא מהיישום, באישור המשתמש.

הבהרה של קוד פייתון

יש הרבה דברים שקורים בקוד, אז נרחיב על הפונקציות הכתובות ולא על כל הקוד.

קודם כל, על מנת להשתמש בממשק המשתמש, יש צורך להוריד כמה מודולים כדי שהקוד יעבוד:

ייבוא threading osimport ייבוא tkinter כ tk מ- tkinter יבוא הודעות תיבה מ tkinter יבוא * מ- PIL יבוא ImageTk, ייבוא תמונות numpy כמו np יבוא סידורי גלוב

חלק מהמודולים כלולים בחבילת ברירת המחדל של פייתון. יש להתקין מספר מודולים באמצעות כלי PIP:

pip להתקין כרית

pip install numpy pip להתקין ScreenInfo

מומלץ מאוד להריץ יישום באמצעות PyCharm. במהדורות הבאות, אני מתכנן לייצא קובץ הפעלה לפרויקט.

הסבר קוד קצר

יהיה הרבה יותר קל להבין את הקוד אם נסתכל על הקווים שלו מנקודת המבט של פונקציות ומחלקות:

1. הפונקציה העיקרית - כאן מתחיל הקוד

אם _name_ == '_ עיקר_': drumkit_gui ()

2. קבועי תוף, תואם ומידע ברירת מחדל של 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] DRUM_PINS = [8, 6, 4, 3, 11, 9, 5, 10, 2, 7]

3. פונקציות ממשק משתמש - טיפול בממשק משתמש ואובייקטים גרפיים

def set_active (ממשק משתמש)

def Second_ui (סוג תוף)

class SelectionUi (tk. Frame)

יישום class (tk. Frame)

def drumkit_gui ()

def event_ui_clicked (אירוע)

def getorigin (עצמי, אירוע)

4. תקשורת סדרתית

def get_serial_ports ()

def communic_with_arduino (יציאה)

5. עבודה עם קבצים: אחסן/טען הגדרות מקובץ txt

def save_config ()

def load_config ()

6. הפעלת יישום חיצוני hairless.exe מהקוד באמצעות יכולות Python Threading

class ExternalExecutableThread (threading. Thread)

def run_hairless_executable ()

על מנת להריץ את הקוד, יש רשימה של קבצים שיש לצרף לתיקיית הפרויקט:

• config.txt: קובץ הגדרות
• hairless.exe: ממיר MIDI ללא שיער
• drumkit.png: תמונה המגדירה את כל רפידות התוף הניתנות ללחיצה בממשק המשתמש שלנו (יש להוריד ממערך התמונות של שלב זה)
• drumgui.py: קוד הפרויקט

זה כל מה שאנחנו צריכים להדגיש כדי לגרום לזה לעבוד. חשוב מאוד להוסיף קבצים לפרויקט: תמונת ערכת תופים, הפעלה hairless.exe והגדרות קובץ config.txt.

ו.. הנה סיימנו!:)

מקווה שתמצא את זה שימושי.

תודה שקראתם!:)