Detector ng Tala ng Musika: 3 Mga Hakbang

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

Humanga ang iyong mga kaibigan at pamilya sa proyektong ito na nakita ang tala na nilalaro ng isang instrumento. Ipapakita ng proyektong ito ang tinatayang dalas pati na rin ang tala ng musikal na nilalaro sa isang elektronikong keyboard, piano app o anumang iba pang instrumento.

Mga Detalye

Para sa proyektong ito, ang output ng analog mula sa detektor ng tunog module ay ipinadala sa A0 analog input ng Arduino Uno. Ang analog signal ay na-sample at na-digitize (na-digitize). Ang autocorrelation, weighting at tuning code ay ginagamit upang makahanap ng pangunahing dalas gamit ang unang 3 yugto. Ang tinatayang pangunahing dalas ay pagkatapos ay inihambing sa mga frequency sa oktaba na 3, 4, at saklaw ng 5 upang matukoy ang pinakamalapit na dalas ng nota ng musikal. Sa wakas ang nahulaan na tala para sa pinakamalapit na dalas ay naka-print sa screen.

Tandaan: Ang itinuturo na ito ay nakatuon lamang sa kung paano mabuo ang proyekto. Para sa karagdagang impormasyon tungkol sa mga detalye at katuwiran sa disenyo, mangyaring bisitahin ang link na ito: Karagdagang Impormasyon

Mga gamit

• (1) Arduino Uno (o Genuino Uno)
• (1) DEVMO Microphone Sensor High Sensitivity Sound Detection Module Tugma
• (1) Solderless Breadboard
• (1) USB-A hanggang B Cable
• Jumper wires
• Pinagmulan ng musikal (piano, keyboard o paino app na may mga speaker)
• (1) Computer o laptop

Hakbang 1: Buuin ang Hardware para sa Musical Note Detector

Gamit ang isang Arduino Uno, mga wire ng koneksyon, isang solderless breadboard at isang DEVMO Microphone Sensor High Sensitivity Sound Detection Module (o katulad) na bumuo ng circuit na ipinapakita sa imaheng ito

Hakbang 2: I-program ang Musical Note Detector

Sa Arduino IDE, idagdag ang sumusunod na code.

gistfile1.txt

/*

Pangalan ng File / Sketch: MusicalNoteDetector

Bersyon Walang.: v1.0 Nilikha 7 Hunyo, 2020

Orihinal na May-akda: Clyde A. Lettsome, PhD, PE, MEM

Paglalarawan: Ipinapakita ng code / sketch na ito ang tinatayang dalas pati na rin ang tala ng musikal na nilalaro sa isang elektronikong keyboard o piano app. Para sa proyektong ito, ang output ng analog mula sa

ang detektor ng tunog module ay ipinadala sa A0 analog input ng Arduino Uno. Ang analog signal ay na-sample at na-digitize (na-digitize). Ang autocorrelation, weighting at tuning code ay ginagamit upang

hanapin ang pangunahing dalas gamit ang unang 3 mga panahon. Ang tinatayang pangunahing dalas ay pagkatapos ay ihinahambing sa mga dalas ng mga octaves na 3, 4, at 5 na saklaw upang matukoy ang pinakamalapit na musikal

tandaan dalas. Sa wakas ang nahulaan na tala para sa pinakamalapit na dalas ay naka-print sa screen.

Lisensya: Ang program na ito ay libre software; maaari mo itong ipamahagi muli at / o baguhin ito sa ilalim ng mga tuntunin ng bersyon ng GNU General Public License (GPL) na bersyon 3, o anumang mamaya

bersyon na iyong pinili, tulad ng nai-publish ng Free Software Foundation.

Mga Tala: Copyright (c) 2020 ni C. A. Lettsome Services, LLC

Para sa karagdagang impormasyon bisitahin ang

*/

#define SAMPLES 128 // Max 128 para sa Arduino Uno.

#define SAMPLING_FREQUENCY 2048 // Fs = Batay sa Nyquist, dapat na 2 beses ang pinakamataas na inaasahang dalas.

# tukuyin ang OFFSETSAMPLES 40 // na ginagamit para sa mga layuning calabrating

# tukuyin ang TUNER -3 // Ayusin hanggang sa C3 ay 130.50

float samplingPeriod;

unsigned mahabang microSeconds;

int X [SAMPLES]; // lumikha ng vector ng laki na SAMPLES upang hawakan ang totoong mga halaga

float autoCorr [SAMPLES]; // lumikha ng vector ng laki na SAMPLES upang hawakan ang mga haka-haka na halaga

float nakaimbakNoteFreq [12] = {130.81, 138.59, 146.83, 155.56, 164.81, 174.61, 185, 196, 207.65, 220, 233.08, 246.94};

int sumOffSet = 0;

int offSet [OFFSETSAMPLES]; // lumikha ng offset vector

int avgOffSet; // lumikha ng offset vector

int i, k, periodEnd, periodBegin, period, adjuster, noteLocation, octaveRange;

float maxValue, minValue;

mahabang halaga;

int thresh = 0;

int numOfCycle = 0;

float signalFrequency, signalFrequency2, signalFrequency3, signalFrequencyGuess, total;

byte state_machine = 0;

int samplePerPeriod = 0;

walang bisa ang pag-setup ()

{

Serial.begin (115200); // 115200 Baud rate para sa Serial Monitor

}

walang bisa loop ()

{

//*****************************************************************

// Seksyon ng Calabration

//*****************************************************************

Serial.println ("Calabrating. Mangyaring huwag maglaro ng anumang mga tala sa panahon ng calabration.");

para sa (i = 0; i <OFFSETSAMPLES; i ++)

{

offSet = analogRead (0); // Binabasa ang halaga mula sa analog pin 0 (A0), sukatin ito at i-save ito bilang isang tunay na term.

//Serial.println(offSet); // gamitin ito upang ayusin ang module ng pagtuklas ng tunog sa humigit-kumulang na kalahati o 512 kapag walang tunog na pinatugtog.

sumOffSet = sumOffSet + offSet ;

}

mga samplePerPeriod = 0;

maxValue = 0;

//*****************************************************************

// Maghanda na tanggapin ang input mula sa A0

//*****************************************************************

avgOffSet = bilog (sumOffSet / OFFSETSAMPLES);

Serial.println ("Nagbibilang.");

pagkaantala (1000); // huminto nang 1 segundo

Serial.println ("3");

pagkaantala (1000); // huminto nang 1 segundo

Serial.println ("2");

pagkaantala (1000); // huminto para sa 1

Serial.println ("1");

pagkaantala (1000); // huminto nang 1 segundo

Serial.println ("I-play ang iyong tala!");

pagkaantala (250); // huminto nang 1/4 segundo para sa oras ng reaksyon

//*****************************************************************

// Kolektahin ang mga halimbawang SAMPLES mula sa A0 na may sample na panahon ng samplingPeriod

//*****************************************************************

samplingPeriod = 1.0 / SAMPLING_FREQUENCY; // Panahon sa microseconds

para sa (i = 0; i <SAMPLES; i ++)

{

microSeconds = micros (); // Ibinabalik ang bilang ng mga microsecond mula nang simulang patakbuhin ng Arduino board ang kasalukuyang script.

X = analogRead (0); // Binabasa ang halaga mula sa analog pin 0 (A0), sukatin ito at i-save ito bilang isang tunay na term.

/ * natitirang oras ng paghihintay sa pagitan ng mga sample kung kinakailangan sa ilang segundo * /

habang (micros () <(microSeconds + (samplingPeriod * 1000000)))

{

// huwag kang maghintay lang

}

}

//*****************************************************************

// Autocorrelation Function

//*****************************************************************

para sa (i = 0; i <SAMPLES; i ++) // i = pagkaantala

{

kabuuan = 0;

para sa (k = 0; k <SAMPLES - i; k ++) // Tugma ng signal na may naantala na signal

{

kabuuan = sum + (((X [k]) - avgOffSet) * ((X [k + i]) - avgOffSet)); // X [k] ang signal at X [k + i] ang naantala na bersyon

}

autoCorr = kabuuan / SAMPLES;

// First Peak Detect State Machine

kung (state_machine == 0 && i == 0)

{

thresh = autoCorr * 0.5;

state_machine = 1;

}

kung hindi man (state_machine == 1 && i> 0 && thresh 0) // state_machine = 1, hanapin ang 1 panahon para magamit ang unang cycle

{

maxValue = autoCorr ;

}

kung hindi man (state_machine == 1 && i> 0 && thresh <autoCorr [i-1] && maxValue == autoCorr [i-1] && (autoCorr -autoCorr [i-1]) <= 0)

{

periodBegin = i-1;

state_machine = 2;

numOfCycle = 1;

mga samplePerPeriod = (periodBegin - 0);

panahon = samplePerPeriod;

tagapag-ayos = TUNER + (50.04 * exp (-0.102 * samplePerPeriod));

signalFrequency = ((SAMPLING_FREQUENCY) / (mga samplePerPeriod)) - tagapag-ayos; // f = fs / N

}

kung hindi man (state_machine == 2 && i> 0 && thresh 0) // state_machine = 2, hanapin ang 2 mga panahon para sa ika-1 at ika-2 na cycle

{

maxValue = autoCorr ;

}

kung hindi man (state_machine == 2 && i> 0 && thresh <autoCorr [i-1] && maxValue == autoCorr [i-1] && (autoCorr -autoCorr [i-1]) <= 0)

{

periodEnd = i-1;

state_machine = 3;

numOfCycle = 2;

mga samplePerPeriod = (periodEnd - 0);

signalFrequency2 = (((numOfCycle * SAMPLING_FREQUENCY) / (samplePerPeriod)) - tagapag-ayos; // f = (2 * fs) / (2 * N)

maxValue = 0;

}

kung hindi man (state_machine == 3 && i> 0 && thresh 0) // state_machine = 3, hanapin ang 3 mga panahon para sa ika-1, ika-2 at ika-3 na ikot

{

maxValue = autoCorr ;

}

kung hindi man (state_machine == 3 && i> 0 && thresh <autoCorr [i-1] && maxValue == autoCorr [i-1] && (autoCorr -autoCorr [i-1]) <= 0)

{

periodEnd = i-1;

state_machine = 4;

numOfCycle = 3;

mga samplePerPeriod = (periodEnd - 0);

signalFrequency3 = (((numOfCycle * SAMPLING_FREQUENCY) / (mga samplePerPeriod)) - tagapag-ayos; // f = (3 * fs) / (3 * N)

}

}

//*****************************************************************

// Pagsusuri sa Resulta

//*****************************************************************

kung (mga samplePerPeriod == 0)

{

Serial.println ("Hmm….. Hindi ako sigurado. Sinusubukan mo ba akong lokohin?");

}

iba pa

{

// ihanda ang pagpapaandar ng pagtimbang

kabuuan = 0;

kung (signalFrequency! = 0)

{

kabuuan = 1;

}

kung (signalFrequency2! = 0)

{

kabuuan = kabuuang + 2;

}

kung (signalFrequency3! = 0)

{

kabuuan = kabuuang + 3;

}

// kalkulahin ang dalas gamit ang pag-andar ng pagtimbang

signalFrequencyGuess = ((1 / total) * signalFrequency) + ((2 / total) * signalFrequency2) + ((3 / total) * signalFrequency3); // makahanap ng isang bigat na dalas

Serial.print ("Ang tala na iyong ginampanan ay humigit-kumulang");

Serial.print (signalFrequencyGuess); // I-print ang hula ng dalas.

Serial.println ("Hz.");

// hanapin ang saklaw ng oktaba batay sa hula

octaveRange = 3;

habang (! (signalFrequencyGuess> = naka-storeNoteFreq [0] -7 && signalFrequencyGuess <= naka-saveNoteFreq [11] +7))

{

para sa (i = 0; i <12; i ++)

{

naka-storeNoteFreq = 2 * naka-storeNoteFreq ;

}

octaveRange ++;

}

// Hanapin ang pinakamalapit na tala

minValue = 10000000;

noteLocation = 0;

para sa (i = 0; i <12; i ++)

{

kung (minValue> abs (signalFrequencyGuess-naka-storeNoteFreq ))

{

minValue = abs (signalFrequencyGuess-naka-storeNoteFreq );

noteLocation = i;

}

}

// I-print ang tala

Serial.print ("Sa tingin ko ay naglaro ka");

kung (noteLocation == 0)

{

Serial.print ("C");

}

kung hindi man (noteLocation == 1)

{

Serial.print ("C #");

}

kung hindi man (noteLocation == 2)

{

Serial.print ("D");

}

kung hindi man (noteLocation == 3)

{

Serial.print ("D #");

}

kung hindi man (noteLocation == 4)

{

Serial.print ("E");

}

kung hindi man (noteLocation == 5)

{

Serial.print ("F");

}

kung hindi man (noteLocation == 6)

{

Serial.print ("F #");

}

kung hindi man (noteLocation == 7)

{

Serial.print ("G");

}

kung hindi man (noteLocation == 8)

{

Serial.print ("G #");

}

kung hindi man (noteLocation == 9)

{

Serial.print ("A");

}

kung hindi man (noteLocation == 10)

{

Serial.print ("A #");

}

kung hindi man (noteLocation == 11)

{

Serial.print ("B");

}

Serial.println (octaveRange);

}

//*****************************************************************

//Tumigil dito. Pindutin ang pindutan ng pag-reset sa Arduino upang muling simulan

//*****************************************************************

habang (1);

}

tingnan ang rawgistfile1.txt na naka-host sa ❤ ng GitHub

Hakbang 3: I-set up ang Detector ng Tala ng Musika

Ikonekta ang Arduino Uno sa PC na may nakasulat na code o na-load sa Arduino IDE. Compile at i-upload ang code sa Arduino. Ilagay ang circuit malapit sa pinagmulan ng musika. Tandaan: Sa panimula na video, gumagamit ako ng isang app na naka-install sa tablet kasabay ng mga PC speaker bilang aking mapagkukunan ng musika. Pindutin ang pindutan ng pag-reset sa Arduino Board at pagkatapos maglaro ng isang tala sa mapagkukunan ng musika. Pagkatapos ng ilang segundo, ipapakita ng Musical Note Detector ang tala na nilalaro at ang dalas nito.