Detektor ng Mga Tala ng Musika ng Arduino: 3 Mga Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:11

Ang pagtuklas ng mga tala ng musika mula sa audio signal ay mahirap gawin lalo na sa Arduino dahil sa limitadong memorya at lakas ng pagproseso. Pangkalahatan, ang tala ay hindi isang dalisay na alon ng sine na nagpapahirap sa pagtuklas. Kung gagawin namin ang pagbabago ng dalas ng iba't ibang mga instrumentong pangmusika, maaari itong maglaman ng maraming mga pagkakasabay batay sa tala na pinatugtog. Ang bawat instrumento ay may sariling kumbinasyon ng lagda ng iba't ibang mga harmonika. Sa code na ito, sinubukan kong gumawa ng isang programa na maaaring masakop ang maraming mga instrumento hangga't maaari. Maaari kang mag-refer ng nakalakip na video kung saan sinubukan kong subukan ang iba't ibang uri ng mga instrumento, iba't ibang uri ng mga tono na nabuo ng keyboard, at kahit na ang tunog ng tinig ay nasuri. Ang kawastuhan ng pagtuklas ay nag-iiba-iba ng instrumento sa instrumento. Para sa ilang mga instrumento (ibig sabihin piano) sa isang limitadong saklaw (200-500Hz) ito ay tumpak, habang ang ilang mga instrumento ito ay may mababang kawastuhan (ie Harmonica).

Ginagamit ng code na ito ang dati nang nabuong FFT code na tinatawag na EasyFFT.

Ang pagpapakita ng code ay ipinapakita sa itaas na video na may iba't ibang mga uri ng tunog ng instrumento pati na rin ang tinig.

Mga gamit

- Arduino Nano / Uno o sa itaas

- Module ng mikropono para sa Arduino

Hakbang 1: Algorithm para sa Pagtuklas ng Tandaan

Tulad ng nabanggit sa nakaraang hakbang, ang pagtuklas ay mahirap dahil sa pagkakaroon ng maraming mga frequency sa mga sample ng audio.

Gumagana ang programa sa sumusunod na daloy:

1. Pagkuha ng data:

- Ang seksyon na ito ay tumatagal ng 128 mga sample mula sa audio data, ang paghihiwalay sa pagitan ng dalawang mga sample (dalas ng sampling) depende sa dalas ng interes. Sa kasong ito, gumagamit kami ng spacing sa pagitan ng dalawang mga sample ay ginagamit upang ilapat ang pagpapaandar ng window ng Hann pati na rin ang pagkalkula ng amplitude / RMS. Gumagawa din ang code na ito ng magaspang na zeroing sa pamamagitan ng pagbawas ng 500 mula sa halagang analogread. Ang halagang ito ay maaaring mabago kung kinakailangan. Para sa isang pangkaraniwang kaso, gumagana nang maayos ang mga halagang ito. Dagdag dito, ang ilang pagkaantala ay kailangang idagdag upang magkaroon ng dalas ng sampling na humigit-kumulang na 1200Hz. sa kaso ng 1200Hz sampling frequency max na 600 HZ dalas ay maaaring napansin.

para sa (int i = 0; i <128; i ++) {a = analogRead (Mic_pin) -500; // rough zero shift sum1 = sum1 + a; // sa average na halaga ng sum2 = sum2 + a * a; // to RMS halaga a = a * (kasalanan (i * 3.14 / 128) * kasalanan (i * 3.14 / 128)); // Hann window sa = 4 * a; // scaling for float to int conversion delayMicroseconds (195); // batay sa saklaw ng dalas ng operasyon}

2. FFT:

Kapag handa na ang data, gaganap ang FFT gamit ang EasyFFT. Ang pagpapaandar na EasyFFT na ito ay binago upang ayusin ang FFT para sa 128 na mga sample. Binago rin ang code upang mabawasan ang pagkonsumo ng memorya. Ang orihinal na pag-andar ng EasyFFT na idinisenyo upang magkaroon ng hanggang sa 1028 na mga sample (kasama ang katugmang board), habang kailangan lamang namin ng 128 sample. binabawasan ng code na ito ang pagkonsumo ng memorya ng halos 20% kumpara sa orihinal na pag-andar ng EasyFFT.

Kapag tapos na ang FFT, ibabalik ng code ang nangungunang 5 pinaka nangingibabaw na mga tuktok ng dalas para sa karagdagang pagsusuri. Ang dalas na ito ay nakaayos sa pababang pagkakasunud-sunod ng amplitude.

3. Para sa bawat rurok, nakita ng code ang mga posibleng tala na naiugnay dito. ang code na ito ay nag-i-scan lamang hanggang sa 1200 Hz. Hindi kinakailangan na magkaroon ng tala na kapareho ng dalas na may max amplitude.

Ang lahat ng mga frequency ay nai-map sa pagitan ng 0 hanggang 255, dito nakita ang unang oktaba, halimbawa, 65.4 Hz hanggang 130.8 ay kumakatawan sa isang oktaba, 130.8 Hz hanggang 261.6 Hz ay kumakatawan sa isa pa. Para sa bawat oktaba, ang mga frequency ay nai-map mula 0 hanggang 255. dito ang pagmamapa simula sa C hanggang C '.

kung (f_peaks > 1040) {f_peaks = 0;} kung (f_peaks > = 65.4 && f_peaks = 130.8 && f_peaks = 261.6 && f_peaks = 523.25 && f_peaks = 1046 && f_peaks <= 2093) {f_peaks = 255 * ((f_peaks / 1046) -1);}

Ginagamit ang mga halaga ng arrayV upang maitalaga ang tala sa mga napansin na mga frequency.

byte NoteV [13] = {8, 23, 40, 57, 76, 96, 116, 138, 162, 187, 213, 241, 255};

4. Matapos ang pagkalkula ng tala para sa bawat dalas maaaring ito ang kaso na maraming mga frequency na mayroon na nagmumungkahi ng parehong tala. Upang magkaroon ng isang tumpak na output code ay isinasaalang-alang din ang mga pag-uulit. Ang code ay nagdaragdag ng lahat ng mga halaga ng dalas batay sa pagkakasunud-sunod ng amplitude at mga pag-uulit at mga taluktok ng tala na may maximum na amplitude.

Hakbang 2: Paglalapat

Ang paggamit ng code ay tuwid na pasulong, gayunpaman, mayroon ding maraming mga limitasyon na kailangang tandaan habang ito. Maaaring makopya ang code dahil ginagamit ito para sa pagtuklas ng tala. Ang mga puntos sa ibaba ay kailangang isaalang-alang habang ginagamit ito.

1. Takdang Aralin:

Batay sa kalakip na takdang-aralin ng Pin ay kailangang baguhin. Para sa aking eksperimento, itinago ko ito sa Analog pin 7, void setup () {Serial.begin (250000); Mic_pin = A7; }

2. Pagkasensitibo ng mikropono:

Kailangang mabago ang pagiging sensitibo ng mikropono tulad ng form ng alon na maaaring mabuo nang may mahusay na amplitude. Karamihan, ang module ng Mikropono ay mayroong setting ng pagiging sensitibo. naaangkop na sensitibo upang mapili tulad ng signal na iyon ay hindi masyadong maliit at hindi rin clip off dahil sa mas mataas na amplitude.

3. Amplitude threshold:

Aktibo lamang ang code na ito kung ang signal amplitude kung sapat na mataas. ang setting na ito ay kailangang itakda nang manu-mano ng gumagamit. ang halagang ito ay nakasalalay sa pagiging sensitibo ng mikropono pati na rin ang application.

kung (sum2-sum1> 5) {

..

sa code sa itaas, ang sum2 ay nagbibigay ng halaga ng RMS habang ang kabuuan ay nagbibigay ng halagang halaga. kaya ang pagkakaiba sa pagitan ng dalawang halagang ito ay nagbibigay ng malawak ng signal ng tunog. sa aking kaso, gumagana ito ng maayos sa isang halaga ng amplitude na humigit-kumulang 5.

4. Bilang default, i-print ng code na ito ang napansin na tala. gayunpaman, kung nagpaplano kang gamitin ang tala para sa ibang layunin, dapat gamitin ang direktang itinalagang numero. halimbawa C = 0; C # = 1, D = 2, D # = 3 at pasulong.

5. Kung ang instrumento ay may mas mataas na dalas, ang code ay maaaring magbigay ng maling output. ang maximum na dalas ay limitado ng dalas ng sampling. sa gayon maaari kang maglaro sa paligid ng mga pagkaantala ng pagkaantala upang makakuha ng pinakamabuting kalagayan na output. sa pagkaantala ng code sa ibaba ng 195 microseconds. na maaaring mai-tweak upang makakuha ng pinakamabuting kalagayan na output. Maaapektuhan nito ang pangkalahatang oras ng pagpapatupad.

{a = analogRead (Mic_pin) -500; // magaspang na zero shift

sum1 = sum1 + a; // sa average na halaga ng sum2 = sum2 + a * a; // to RMS halaga a = a * (kasalanan (i * 3.14 / 128) * kasalanan (i * 3.14 / 128)); // Hann window sa = 4 * a; // scaling for float to int conversion delayMicroseconds (195); // batay sa saklaw ng dalas ng operasyon}

6. gagana lamang ang code na ito hanggang sa dalas ng 2000Hz. sa pamamagitan ng pag-aalis ng pagkaantala sa pagitan ng sampling sa paligid ng 3-4 kHz ng mga frequency ng pag-sample ay maaaring makuha.

Pag-iingat:

• Tulad ng nabanggit sa EasyFFT tutorial, ang FFT ay kumakain ng isang malaking halaga ng memorya ng Arduino. Kaya't kung mayroon kang isang programa na kailangang mag-imbak ng ilang mga halaga inirerekumenda na gumamit ng isang board na may mas mataas na memorya.
• Ang code na ito ay maaaring gumana nang maayos para sa isang instrumento / bokalista at masama para sa iba pa. Real-time na Tumpak na pagtuklas ay hindi posible dahil sa mga limitasyon sa computational.

Hakbang 3: Tag-init

Tandaan ang pagtuklas ay computationally masinsinang trabaho, pagkuha ng real-time na output ay napakahirap lalo na sa Arduino. Ang code na ito ay maaaring magbigay sa paligid ng 6.6 mga sample / segundo (para sa 195 microseconds pagkaantala naidagdag). gumagana nang maayos ang code na ito sa piano at ilang iba pang mga instrumento.

Inaasahan kong maging kapaki-pakinabang ang code at tutorial na ito sa iyong proyekto na nauugnay sa musika. sa kaso ng anumang pagdududa o mungkahi huwag mag-atubiling magbigay ng puna o mensahe.

Sa paparating na tutorial, babaguhin ko ang code na ito para sa pagtuklas ng chord ng musika. kaya't manatiling nakatutok