Kitanda cha ngoma cha MIDI kwenye chatu na Arduino: Hatua 5 (na Picha)

2024 Mwandishi: John Day | [email protected]. Mwisho uliobadilishwa: 2024-01-30 12:50

Siku zote nilitaka kununua kitanda cha ngoma tangu nilipokuwa mtoto. Nyuma ya hapo, vifaa vyote vya muziki havikuwa na matumizi yote ya dijiti kwani tuna mengi ya leo, kwa hivyo bei pamoja na matarajio yalikuwa ya juu sana. Hivi karibuni nimeamua kununua kit cha bei rahisi kutoka kwa eBay, na kipaumbele pekee: Uwezo wa kuibomoa na kushikamana na vifaa vyangu na programu kwenye kifaa.

Ununuzi haukuwa wa kukatisha tamaa hata kidogo: Kitanda cha kusambaza cha kubebeka na pedi 9 za sauti tofauti, pedi mbili za kubadili miguu kwa ngoma ya kick na hi-kofia na tundu la umeme la USB-ndogo. Kilichokuwa kinapunguza moyo sana, ni sauti za pato (Matumizi halisi ya kit hiki ni kuunganisha spika ya nje na kufurahiya). Kwa hivyo, niliamua kuibadilisha iwe inayoweza kusanidiwa kupitia USB, kitanda cha ngoma cha MIDI kulingana na Arduino na Interface ya Mtumiaji kulingana na Python, kwa matumizi rahisi na marekebisho rahisi kama, sauti, noti na chaguzi za kituo.

Makala ya kifaa:

• Bei ya chini
• Kuunda vifaa vya ngoma kutoka kwa pembejeo yoyote ya dijiti - hata safu ya vifungo vya kushinikiza
• Usaidizi wa mawasiliano na usambazaji wa umeme kupitia kiolesura cha USB tu - Ujumuishaji wa USB na kibadilishaji cha UART na kifaa cha Arduino
• Sehemu ndogo kwa operesheni sahihi
• UI rahisi kutumia UI inayotegemea Python
• Kamilisha msaada wa MIDI na kasi inayoweza kubadilishwa, noti na pini za Arduino
• Hifadhi na upakie mipangilio ya ngoma maalum iliyohifadhiwa kwenye kumbukumbu ya kifaa

Wacha tuendelee kwenye mradi…

Hatua ya 1: Nadharia ya Uendeshaji

Mchoro wa Kuzuia

Kwanza kabisa, wacha tuangalie muundo wa mradi, na ugawanye katika vizuizi tofauti:

Kitanda cha Drum-Up

Kitengo kuu cha mradi. Inayo vidonge 9 tofauti vya ngoma, ambapo kila pedi ni safu ya vifungo ambavyo hubadilisha hali yao ya mantiki wakati wanapigwa. Kwa sababu ya muundo wake, kuna uwezekano wa kujenga kit hiki cha ngoma kutoka kwa vifungo vyovyote vya kushinikiza. Kila pedi ya ngoma imeunganishwa na kontena la kuvuta kwenye bodi kuu ya elektroniki, kwa hivyo wakati pedi ya ngoma inapigwa mara kwa mara, swichi maalum imefungwa kwa ardhi ya mzunguko na mantiki LOW iko kwenye laini ya pedi ya ngoma. Wakati hakuna shinikizo linalotumiwa, swichi ya pedi ya ngoma iko wazi na kwa sababu ya kontena la kuvuta kwa laini ya nguvu, mantiki ya HIGH iko kwenye laini ya pedi ya ngoma. Kwa sababu kusudi la mradi ni kuunda kifaa kamili cha dijiti cha MIDI, sehemu zote za analog kwenye PCB kuu zinaweza kupuuzwa. Ni muhimu kutambua, kwamba kitanda cha ngoma kina pedal mbili kwa ngoma ya kick na hi-kofia, ambayo pia imefungwa kwa vizuizi vya kuvuta na inashiriki mantiki sawa ya operesheni na pedi zote za ngoma (Tutaijadili kidogo baadaye).

Arduino Pro-Micro

Ubongo wa kitanda cha ngoma. Kusudi lake ni kugundua ikiwa kuna ishara inayotoka kwenye pedi ya ngoma na kutoa pato linalofaa la MIDI na vigezo vyote muhimu: Kumbuka, kasi na muda wa ishara. Kwa sababu ya asili ya dijiti ya pedi za ngoma, zinaweza kufungwa tu na pembejeo za dijiti za dijiti (pini 10 jumla). Ili kuhifadhi mipangilio yote inayotakikana na habari ya MIDI, tutatumia kumbukumbu yake - EEPROM, kwa hivyo kila wakati tunapowasha kifaa, habari ya MIDI inapakuliwa kutoka EEPROM, na kuifanya iweze kupangiliwa na kusanidi tena. Pia, Arduino Pro-Micro inapatikana katika kifurushi kidogo sana na inaweza kutolewa kwa urahisi katika kesi ya ndani ya kit.

FTDI USB Kwa Converter Serial

Ili kupanga na kufafanua vipengee vya kifaa chetu kwa msaada wa programu tumizi ya PC, kuna haja ya kubadilisha kiolesura cha USB kuwa serial, kwa sababu Arduino Pro-Micro haina USB. Kwa kuwa mawasiliano kati ya vifaa yanategemea UART, kifaa cha FTDI kinatumika katika mradi huu, kwa sababu ya unyenyekevu wa matumizi bila kujali mali zake za ziada.

Maombi ya PC - Chatu

Linapokuja suala la ukuzaji wa maingiliano ya watumiaji na miradi ya kujenga haraka, Python ni suluhisho bora. Madhumuni ya programu ya UI ni kuifanya iwe rahisi zaidi kufafanua tena mali za MIDI kwa kitanda chetu, habari za duka, kifaa cha programu na kufanya mawasiliano kati ya mifumo bila hitaji la kukusanya nambari tena na tena. Kwa sababu tunatumia kiolesura cha serial kuwasiliana na kitanda cha ngoma, kuna moduli nyingi bila malipo kote kwenye wavuti, ambazo zinasaidia aina yoyote ya mawasiliano ya serial. Kwa kuongezea, kama itajadiliwa baadaye, kiolesura cha UART kina jumla ya pini tatu: RXD, TXD na DTR. DTR hutumiwa kufanya upya kwenye moduli ya Arduino, kwa hivyo wakati tunapenda kuendesha programu ya MIDI au kuunganisha UI kwenye kifaa cha programu, hakuna kabisa haja ya kuambatanisha tena kebo ya USB au chochote kile.

Hatua ya 2: Sehemu na Vyombo

Sehemu

• Kitanda cha Drum-Up
• 2 x Endeleza Pedals (Kawaida, imejumuishwa kwenye kifurushi cha DK).
• FTDI - USB Kwa Kubadilisha fedha
• Arduino Pro Micro
• Cable ya Micro-USB

Vyombo

• Kuchuma Chuma / Kituo
• Kuunganisha Bati
• Kipenyo nyembamba waya moja ya waya
• Kibano
• Mkataji
• Plier
• Kisu
• Screw Dereva
• Printa ya 3D (Hiari - kwa majukwaa ya kanyagio yaliyoboreshwa)

Programu

• Arduino IDE
• Chatu 3 au Juu
• JetBrains Pycharm
• Kiolesura cha MIDI kisicho na nywele
• kitanziMIDI

Hatua ya 3: Soldering na Mkutano

Kwa kuwa kuna moduli tatu ambazo zinapaswa kuunganishwa, mchakato wa kutengeneza na kukusanyika ni mfupi na rahisi:

• Ambatisha pamoja Arduino Pro-Micro na kifaa cha FTDI, hakikisha uunganisho unatii I / O iliyoainishwa kwenye kila kifaa:

  • VBUS-VBUS
  • GND-GND
  • DTR-DTR
  • RXD-TXD
  • TXD-RXD
• Ondoa screws zote kutoka kwenye fimbo ya plastiki ya ngoma, hakikisha unaweza kuzingatia kebo ya pedi-kwa-bodi, na vizuizi vyake vya kuvuta

• Waya nyembamba za Solder kwa moduli ya Arduino-FTDI ambayo tumejenga hapo awali:

  • Pembejeo za dijiti: D [2:11]
  • VBUS
  • D +
  • D-
  • GND
• Ingiza moduli ndani ya sanduku la betri ili waya zingekuwa zikielea upande mmoja na vipinga-kuvuta vya pedi
• Solder pembejeo zote za dijiti kwa vituo vya pedi ya ngoma kama inavyoonyeshwa kwenye takwimu ya mwisho.
• Solder micro-USB bus (VBUS, D +, D-, GND) kwa kifaa cha FTDI, hakikisha kuwa hakuna makosa ya kufuatilia waya hizi.
• Ambatisha moduli ya Arduino-FTDI na gundi moto kwenye kesi ya betri
• Unganisha kifaa na kiambatisho kinachofaa cha vis

Tumeifanya, kifaa kimekusanyika. Wacha tuendelee na nambari …

Hatua ya 4: Programu A: Arduino

Hebu Fafanua mchoro wetu hatua kwa hatua:

Kwanza kabisa, kuna haja ya kujumuisha maktaba mbili muhimu kwa operesheni inayofaa. EEPROM tayari imewekwa mapema katika Arduino IDE, lakini moduli ya mtoaji malipo kwa ngoma ya kick inapaswa kuwekwa kando

#jumuisha #jumuisha

Swichi hizi hutumiwa haswa katika utaftaji wa utatuzi. Ikiwa unataka kujaribu unganisho la vituo vya Arduino kwenye pedi za ngoma, na uamua pembejeo zote za dijiti, swichi hizi zinapaswa kufafanuliwa

/ * Swichi za Wasanidi Programu: Njia inayotakikana ya kuondoa hitilafu au kuanzisha * /// # fafanua LOAD_DEFAULT_VALUES // Pakia maadili ya kila wakati badala ya EEPROM // # fafanua PRINT_PADS_PIN_NUMBERS // Nambari ya pini ya kuchapisha ambayo imeunganishwa kwenye pedi ambayo iligongwa kupitia bandari kuu

Sehemu za kawaida zinawakilisha maadili yote chaguo-msingi, pamoja na hesabu ya pedi ya ngoma. Ili kuendesha kifaa kwa mara ya kwanza kabisa, kuna haja ya kujua unganisho haswa la Hi-Hat na Kick pedals

/ * Kuhesabu aina ya ngoma * /

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

/ * Thamani chaguomsingi * /

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

/ * Piga muda wa kupuuza ngoma * / /

const uint8_t KICK_DB_DURATION = 30;

EEPROM hutumiwa kuhifadhi / kupakia data zote zinazokuja kutoka kwa programu ya PC. Anwani zilizoainishwa hapo juu, zinaonyesha mahali halisi kwa habari ya MIDI kwa kila pedi ya ngoma

/ * EEPROM Inashughulikia ramani

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

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

Vigeugeu vya kimataifa hutumiwa kuamua hali ya kila pedi, na kufanya mawasiliano ya MIDI ipasavyo

/ * Viwango vya Ulimwenguni * /

uint8_t ngomaNoto [10], ngomaVelocities [10], ngomaPini [10]; // Vigezo vya MIDI

uint8_t uartBuffer [64]; // Bafa ya UART ya kukusanya na kuhifadhi kick kicker ya MIDI Data (DRUM_PINS [KICK], KICK_DB_DURATION); // Kitu cha mdai kwa bomu la kick kick volatable StateState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Pedi ya hapo awali mantiki inasema bool ya sasa ya hali mbaya # 9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Mantiki ya sasa ya pedi ya Drum inasema

Kazi za EEPROM

/ * Hifadhi mipangilio katika EEPROM * /

duka tupuEEPROM () {

memcpy (ngomaNotes, uartBuffer, 10); memcpy (ngomaPini, uartBuffer + 10, 10); memcpy (ngomaVelocities, uartBuffer + 20, 10); kwa (uint8_t i = 0; i <10; i ++) EEPROM.andika (VIDOKEZO_ADDR + i, ngomaNakala ); kwa (uint8_t i = 0; i <10; i ++) EEPROM.andika (PINS_ADDR + i, pini za ngoma ); kwa (uint8_t i = 0; i <10; i ++) EEPROM.andika (VELOCITIES_ADDR + i, ngomaVelocities ); }

/ * Pakia mipangilio kutoka kwa EEPROM * /

mzigo batiliEEPROM () {for (uint8_t i = 0; i <10; i ++) drumNotes = EEPROM.read (NOTES_ADDR + i); kwa (uint8_t i = 0; i <10; i ++) ngoma Pini = soma EEPROM (PINS_ADDR + i); kwa (uint8_t i = 0; i <10; i ++) ngomaVelocities = soma EEPROM. (VELOCITIES_ADDR + i); }

Uanzishaji wa anuwai na hali ya programu, katika kesi ya kanyagio na buti ya Arduino imeamilishwa wakati huo huo

batili EnterProgrammingMode () {

bool confirmBreak = uongo; uint8_t mstariCnt = 0; uint8_t charCnt = 0; char readChar = 0; wakati (! confirmBreak) {if (Serial.available ()) {uartBuffer [charCnt] = Serial.read (); ikiwa (charCnt> = 29) confirmBreak = kweli; mwingine charCnt ++; }} Serial.println ("Sawa"); dukaEEPROM (); }

batili initValues () {

#ifdef LOAD_DEFAULT_VALUES memcpy (ngomaNotes, DRUM_NOTES, 10); memcpy (ngomaVelocities, DRUM_VELOCITIES, 10); memcpy (pini za ngoma, DRUM_PINS, 10); # mzigo mwingineEEPROM (); # mwisho}

Wasimamizi wa Mawasiliano ya MIDI na kucheleweshwa kwa muda wa kushikilia noti ya 1ms

/ * Cheza kazi ya kumbuka MIDI * /

tupu midiOut (enum DRUM_POSITION ngoma ndani) {

ikiwa (ngomaIn == HIHAT) {// Ikiwa HI-HAT ilipigwa, kuna haja ya kufanya ukaguzi ikiwa kanyagio ni taabu ikiwa (! [HIHAT_PEDAL]); kuchelewesha (1); KumbukaOn (0x90, ngomaNotes [HIHAT_PEDAL], 0); } mwingine {noteOn (0x90, drumNotes [HIHAT], ngomaVelocities [HIHAT]); kuchelewesha (1); KumbukaOn (0x90, ngomaNotes [HIHAT], 0); }} mwingine {// Duru ya kawaida ya kupitisha ngoma ya MIDIOn (0x90, ngomaNotes [drumIn], ngomaVelocities [drumIn]); kuchelewesha (1); KumbukaOn (0x90, ngomaNotes [ngomaIn], 0); }}

batili noteOn (int cmd, int pitch, int velocity) {Serial.write (cmd); Andika mfululizo (lami); Serial.write (kasi); }

usanidi () na kitanzi () hufanya kazi na kitanzi kisicho na kipimo cha operesheni ya kifaa:

usanidi batili () {

Serial. Kuanza (115200);

kwa (uint8_t i = 0; i <10; i ++) {pinMode (i + 2, INPUT); } #ifdef PRINT_PADS_PIN_NUMBERS wakati ni kweli {// Infinite debug loop for (uint8_t i = 0; i <10; i ++) {if (! digitalRead (i + 2)) {Serial.; Serial.print (i + '0'); // Badilisha namba kuwa herufi ya ASCII}}} #else initValues (); / * Modi ya programu: Ikiwa kanyagio mbili zimebanwa wakati wa kuwasha - mode imeamilishwa * / ikiwa (! DigitalRead (dripPins [KICK]) &&! DigitalRead (drumPins [HIHAT_PEDAL])) enterProgrammingMode (); # mwisho}

kitanzi batili () {for (uint8_t i = 1; i <9; i = i + 1) {currentState = digitalRead (drumPins ); ikiwa (! currentState && StateState ) midiOut (i); // Linganisha nchi na tambua ukingo unaoangukaState iliyotangulia = jimbo la sasa ; } sasisha kick (); // Kick ngoma hutumia algorithm ya kawaida ya kudondoa ikiwa (kick.edge ()) ikiwa (kick.falling ()) midiOut (KICK); }

Hatua ya 5: Kupanga programu B: Python & Interface ya Mtumiaji

Maingiliano ya Mtumiaji wa Python ni ngumu kidogo kuelewa wakati wa kwanza, kwa hivyo tutajaribu kuelezea misingi yake, jinsi ya kutumia, kila kitufe kina kazi gani na jinsi ya kupanga kifaa cha Arduino vizuri.

Muunganisho wa Mtumiaji - Maombi

UI ni uwakilishi wa picha kwa programu yetu ya vifaa vya ngoma, na kuifanya iwe rahisi kutumia na rahisi kupanga kifaa cha Arduino wakati wowote. UI ina moduli kadhaa za picha ambazo zimefungwa na operesheni yao inayopendekezwa. wacha tukague moja kwa moja:

1. Picha ya Kuweka Drum: UI ya Python hutumia kuratibu za picha za X-Y kuamua ni aina gani ya ngoma iliyochaguliwa. Ikiwa eneo halali la ngoma lilichaguliwa, ujumbe wa sekondari wa IO unajitokeza, na uwanja wa noti, kasi na kituo cha Arduino kwa pedi ya ngoma iliyojitolea. Baada ya vigezo hivi kuthibitishwa na mtumiaji na kupitishwa, maadili haya yanaweza kupitishwa moja kwa moja kwenye kifaa cha Arduino.
2. Picha ya Mdhibiti wa nje: Ili kuweza kutumia kitanda cha ngoma cha MIDI na mazingira ya VST / Muziki, kuna haja ya kukimbia mkalimani wa Serial-To-MIDI. Nimetumia nywele isiyo na nywele, ambayo inapatikana bure na inaweza kuendeshwa moja kwa moja kutoka kwa UI yetu, kwa kubonyeza picha yake.
3. Orodha ya Bandari ya COM: Ili kuwasiliana na Arduino, kuna haja ya kutaja bandari yake ya COM iliyoambatishwa. Orodha inaburudishwa kwa kubonyeza kitufe cha Refresh.
4. Mzigo / Hifadhi Usanidi: Kuna viwango chaguo-msingi vya MIDI vilivyoainishwa kwenye nambari, ambayo inaweza kubadilishwa na mtumiaji kupitia kuingiliana na UI. Usanidi hufafanuliwa katika faili ya config.txt katika muundo maalum, ambayo inaweza kuhifadhiwa au kupakiwa na mtumiaji.
5. Kitufe cha Kifaa cha Programu: Ili kuhifadhi nambari zote za MIDI zilizobadilishwa katika Arduino EEPROM, kuna haja ya kubonyeza pedal mbili za miguu (Kick ngoma na Hi-hat pedal) baada ya hapo, subiri upitishaji wa data ukamilike. Ikiwa kulikuwa na maswala yoyote ya mawasiliano, pop-up sahihi itaonyeshwa. Ikiwa maambukizi yatafanikiwa, UI itaonyesha ujumbe wake uliofanikiwa.
6. Kitufe cha Toka: Ondoka tu kwa matumizi, kwa idhini ya mtumiaji.

Vivutio vya Nambari za Python

Kuna mambo mengi yanaendelea kwenye nambari, kwa hivyo tutapanua kazi zilizoandikwa kuliko kwa nambari yote.

Kwanza kabisa, ili kutumia UI, kuna haja ya kupakua moduli kadhaa, ili kufanya nambari ifanye kazi:

kuagiza osimport threading kuagiza tkinter kama tk kutoka sanduku la kuingiza tkinter kutoka tkinter kuagiza * kutoka PIL kuagiza ImageTk, kuagiza picha numpy kama np kuagiza serial glob

Baadhi ya moduli zimejumuishwa kwenye kifurushi chaguo-msingi cha chatu. Moduli kadhaa zinapaswa kuwekwa kupitia zana ya PIP:

bomba kufunga Mto

bomba funga bomba la kusanikisha ScreenInfo

Inashauriwa sana kutumia programu kupitia PyCharm. Katika matoleo yajayo, ninapanga kusafirisha inayoweza kutekelezwa kwa mradi huo.

Ufafanuzi wa Nambari Fupi

Itakuwa rahisi sana kuelewa nambari ikiwa tungeangalia mistari yake kutoka kwa mtazamo wa kazi na darasa:

1. Kazi kuu - hapa nambari inaanza

ikiwa _name_ == '_main_': drumkit_gui ()

2. Vipindi vya Drum Kit, kuratibu na habari chaguomsingi ya MIDI

Ngoma za darasa: DRUM_TYPES = ["Kick", "Hihat", "Snare", "Crash 1", "Crash 2", "Tom High", "Tom Mid", "Tom Low", "Ride", "Hihat Pedal "," Mdhibiti "]

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", "mtego", "Hihat", "Ride", "Crash 1", "Crash 2", "Tom High", "Tom Mid", "Tom Low", "Hihat Pedal"]

NGOMA_MAELEZO = [36, 40, 42, 51, 49, 55, 47, 45, 43, 48] NGOMA_ZITO = [110, 100, 100, 110, 110, 110, 110, 110, 110, 110] DRUM_PINS = [8, 6, 4, 3, 11, 9, 5, 10, 2, 7]

3. UI Kazi - Utunzaji wa kiolesura cha mtumiaji na vitu vya picha

def set_active (ui)

def sekondari_ui (aina ya ngoma)

Uteuzi wa darasa (tk fremu)

Matumizi ya darasa (tk. Sura)

def drumkit_gui ()

def event_ui_ bonyeza (tukio)

def getorigin (binafsi, tukio)

4. Mawasiliano ya serial

def get_serial_ports ()

mawasiliano mawasiliano_na_arduino (bandari)

5. Kufanya kazi na faili: Hifadhi / Weka mipangilio kutoka kwa faili ya txt

def save_config ()

def mzigo_config ()

6. Kuendesha programu ya nje isiyo na nywele.exe kutoka kwa nambari kwa kutumia uwezo wa Threading ya Python

darasa ExternalExecutableThread (threading. Thread)

def run_hair_ecutable ()

Ili kuendesha nambari hiyo, kuna orodha ya faili ambazo zinapaswa kushikamana na folda ya mradi:

• config.txt: Faili ya mipangilio
• hairless.exe: Kigeuzi kisicho na nywele cha MIDI
• drumkit.png: Picha ambayo inafafanua pedi zote zinazobofyeka kwenye UI yetu (Inapaswa kupakuliwa kutoka kwa picha ya hatua hii)
• drumgui.py: Nambari ya mradi

Hiyo ndiyo kila kitu tunachohitaji kusisitiza kuifanya ifanye kazi. Ni muhimu sana kuongeza faili kwenye mradi: seti ya ngoma, hairless.exe inayoweza kutekelezwa na mipangilio ya faili ya config.txt.

Na.. Hapa tumefanya!:)

Natumahi utapata hii inayofaa kufundisha.

Asante kwa kusoma!:)