Mūzikas notu detektors: 3 soļi

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:51

Pārsteidziet savus draugus un ģimeni ar šo projektu, kas nosaka instrumenta atskaņoto noti. Šis projekts parādīs aptuveno frekvenci, kā arī mūzikas noti, kas atskaņota ar elektronisko tastatūru, klavieru lietotni vai jebkuru citu instrumentu.

Sīkāka informācija

Šim projektam analogā izeja no skaņas moduļa detektora tiek nosūtīta uz Arduino Uno A0 analogo ieeju. Analogā signāla paraugi tiek ņemti un kvantificēti (digitalizēti). Autokorelācijas, svēršanas un regulēšanas kodu izmanto, lai atrastu pamata frekvenci, izmantojot pirmos 3 periodus. Aptuveno pamata frekvenci pēc tam salīdzina ar frekvencēm 3., 4. un 5. oktāvas diapazonā, lai noteiktu tuvāko mūzikas notu frekvenci. Visbeidzot, uz ekrāna tiek izdrukāta piezīme par tuvāko frekvenci.

Piezīme. Šī pamācība ir vērsta tikai uz to, kā izveidot projektu. Lai iegūtu plašāku informāciju par detaļām un dizaina pamatojumu, lūdzu, apmeklējiet šo saiti: Plašāka informācija

Piegādes

• (1) Arduino Uno (vai Genuino Uno)
• (1) Saderīgs ar DEVMO mikrofona sensora augstas jutības skaņas noteikšanas moduli
• (1) bez lodēšanas maizes dēlis
• (1) USB-A līdz B kabelis
• Jumper vadi
• Mūzikas avots (klavieres, tastatūra vai programma ar skaļruņiem)
• (1) Dators vai klēpjdators

1. darbība: izveidojiet aparatūru mūzikas notu detektoram

Izmantojot Arduino Uno, savienojuma vadus, bez lodēšanas maizes dēli un DEVMO mikrofona sensora augstas jutības skaņas noteikšanas moduli (vai līdzīgu) izveidojiet šajā attēlā redzamo shēmu

2. darbība: ieprogrammējiet mūzikas notu detektoru

Arduino IDE pievienojiet šādu kodu.

gistfile1.txt

/*

Faila/skices nosaukums: MusicalNoteDetector

Versijas Nr.: v1.0 Izveidots 2020. gada 7. jūnijā

Sākotnējais autors: Clyde A. Lettsome, PhD, PE, MEM

Apraksts: Šis kods/skice parāda aptuveno frekvenci, kā arī mūzikas noti, kas tiek atskaņota elektroniskajā tastatūrā vai klavieru lietotnē. Šim projektam analogā izeja no

skaņas moduļa detektors tiek nosūtīts uz Arduino Uno A0 analogo ieeju. Analogā signāla paraugi tiek ņemti un kvantificēti (digitalizēti). Tiek izmantota automātiskās korelācijas, svēršanas un regulēšanas kods

atrodiet pamata frekvenci, izmantojot pirmos 3 periodus. Pēc tam aptuveno pamata frekvenci salīdzina ar frekvencēm 3., 4. un 5. oktāvas diapazonā, lai noteiktu tuvāko mūziklu

piezīmju biežums. Visbeidzot, uz ekrāna tiek izdrukāta piezīme par tuvāko frekvenci.

Licence: šī programma ir bezmaksas programmatūra; jūs varat to izplatīt un/vai modificēt saskaņā ar GNU vispārējās publiskās licences (GPL) 3. versijas nosacījumiem vai vēlāk

jūsu izvēlētā versija, ko publicējis Brīvās programmatūras fonds.

Piezīmes: Autortiesības (c) 2020, autors: C. A. Lettsome Services, LLC

Lai iegūtu vairāk informācijas, apmeklējiet vietni

*/

#define PARAUGI 128 // Maksimāli 128 Arduino Uno.

#define SAMPLING_FREQUENCY 2048 // Fs = Pamatojoties uz Nyquist, tam jābūt 2 reizes augstākam par paredzamo biežumu.

#define OFFSETSAMPLES 40 // izmanto kalaborēšanas nolūkos

#define TUNER -3 // Noregulējiet, līdz C3 ir 130,50

pludiņa paraugu ņemšanaPeriods;

neparakstītas garas mikrosekundes;

int X [PARAUGI]; // izveidot parauga lieluma vektoru, lai turētu reālās vērtības

pludiņš autoCorr [PARAUGI]; // izveidot parauga lieluma vektoru, lai turētu iedomātas vērtības

pludiņš glabājasNoteFreq [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]; // izveidot nobīdes vektoru

int avgOffSet; // izveidot nobīdes vektoru

int i, k, periodEnd, periodBegin, punkts, noregulētājs, piezīmeLocation, octaveRange;

peldēt maxValue, minValue;

gara summa;

int thresh = 0;

int numOfCycles = 0;

float signalFrequency, signalFrequency2, signalFrequency3, signalFrequencyGuess, total;

baits state_machine = 0;

int paraugiPerPeriod = 0;

anulēts iestatījums ()

{

Serial.begin (115200); // Sērijas monitora bodu ātrums

}

tukša cilpa ()

{

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

// Kalabrācijas sadaļa

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

Serial.println ("Calabrating. Lūdzu, nespēlējiet nekādas notis calabration laikā.");

par (i = 0; i <OFFSETSAMPLES; i ++)

{

offSet = analogRead (0); // Nolasa vērtību no analogās tapas 0 (A0), kvantē to un saglabā to kā reālu terminu.

//Serial.println(offSet); // izmantojiet šo, lai skaņas noteikšanas moduli noregulētu uz pusi vai 512, ja netiek atskaņota skaņa.

sumOffSet = sumOffSet + offSet ;

}

paraugiPerPeriod = 0;

maxValue = 0;

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

// Sagatavojieties pieņemt ievadi no A0

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

avgOffSet = apaļš (sumOffSet / OFFSETSAMPLES);

Serial.println ("Atpakaļskaitīšana.");

kavēšanās (1000); // pauze uz 1 sekundi

Serial.println ("3");

kavēšanās (1000); // pauze uz 1 sekundi

Serial.println ("2");

kavēšanās (1000); // pauze uz 1

Serial.println ("1");

kavēšanās (1000); // pauze uz 1 sekundi

Serial.println ("Atskaņojiet savu piezīmi!");

kavēšanās (250); // pauze 1/4 sekundes reakcijas laikam

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

// Savāc SAMPLES paraugus no A0 ar paraugu ņemšanas periodu

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

samplingPeriod = 1.0 / SAMPLING_FREQUENCY; // Periods mikrosekundēs

par (i = 0; i <PARAUGI; i ++)

{

mikrosekundes = mikros (); // Atgriež mikrosekundes skaitu, kopš Arduino dēlis sāka darbināt pašreizējo skriptu.

X = analogRead (0); // Nolasa vērtību no analogās tapas 0 (A0), kvantē to un saglabā to kā reālu terminu.

/ *atlikušais gaidīšanas laiks starp paraugiem, ja nepieciešams, sekundēs */

kamēr (mikros () <(mikrosekundes + (paraugu ņemšanas periods * 1000000)))

{

// neko nedari, tikai gaidi

}

}

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

// Autokorelācijas funkcija

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

par (i = 0; i <PARAUGI; i ++) // i = kavēšanās

{

summa = 0;

par (k = 0; k <PARAUGI - i; k ++) // Saskaņojiet signālu ar aizkavētu signālu

{

summa = summa + (((X [k]) - avgOffSet) * ((X [k + i]) - avgOffSet)); // X [k] ir signāls un X [k+i] ir aizkavētā versija

}

autoCorr = summa / PARAUGI;

// First Peak Detect State Machine

ja (štata_mašīna == 0 && i == 0)

{

kulšana = autoCorr * 0,5;

štata_mašīna = 1;

}

citādi, ja (state_machine == 1 && i> 0 && thresh 0) // state_machine = 1, atrodiet 1 periodu pirmā cikla izmantošanai

{

maxValue = autoCorr ;

}

citādi, ja (state_machine == 1 && i> 0 && thresh <autoCorr [i-1] && maxValue == autoCorr [i-1] && (autoCorr -autoCorr [i-1]) <= 0)

{

periodBegin = i-1;

valsts_ mašīna = 2;

numOfCycles = 1;

paraugiPerPeriod = (periodsBegin - 0);

periods = paraugiPerPeriod;

regulators = TUNER+(50,04 * exp (-0,102 * paraugiPerPeriod));

signalFrequency = ((SAMPLING_FREQUENCY) / (samplePerPeriod))-regulētājs; // f = fs/N

}

citādi, ja (state_machine == 2 && i> 0 && thresh 0) // state_machine = 2, atrodiet 2 periodus 1. un 2. ciklam

{

maxValue = autoCorr ;

}

citādi, ja (state_machine == 2 && i> 0 && thresh <autoCorr [i-1] && maxValue == autoCorr [i-1] && (autoCorr -autoCorr [i-1]) <= 0)

{

periodsEnd = i-1;

štata_mašīna = 3;

numOfCycles = 2;

paraugiPerPeriod = (periodsEnd - 0);

signalFrequency2 = (((numOfCycles*SAMPLING_FREQUENCY) / (samplePerPeriod))-regulētājs; // f = (2*fs)/(2*N)

maxValue = 0;

}

citādi, ja (state_machine == 3 && i> 0 && thresh 0) // state_machine = 3, atrodiet 3 periodus 1., 2. un 3. ciklam

{

maxValue = autoCorr ;

}

citādi, ja (state_machine == 3 && i> 0 && thresh <autoCorr [i-1] && maxValue == autoCorr [i-1] && (autoCorr -autoCorr [i-1]) <= 0)

{

periodsEnd = i-1;

štata_mašīna = 4;

numOfCycles = 3;

paraugiPerPeriod = (periodsEnd - 0);

signalFrequency3 = (((numOfCycles*SAMPLING_FREQUENCY) / (samplePerPeriod))-regulētājs; // f = (3*fs)/(3*N)

}

}

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

// Rezultātu analīze

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

ja (samplePerPeriod == 0)

{

Serial.println ("Hmm ….. es neesmu pārliecināts. Vai jūs mēģināt mani apmānīt?");

}

citādi

{

// sagatavot svēršanas funkciju

kopā = 0;

ja (signalFrequency! = 0)

{

kopā = 1;

}

ja (signalFrequency2! = 0)

{

kopā = kopā + 2;

}

ja (signalFrequency3! = 0)

{

kopā = kopā + 3;

}

// aprēķināt frekvenci, izmantojot svēršanas funkciju

signalFrequencyGuess = (((1/kopā) * signalFrequency) + ((2/kopā) * signalFrequency2) + ((3/kopā) * signalFrequency3); // atrast svērto frekvenci

Serial.print ("Jūsu atskaņotā nots ir aptuveni");

Serial.print (signalFrequencyGuess); // Izdrukājiet biežuma minējumu.

Serial.println ("Hz");

// atrodiet oktāvu diapazonu, pamatojoties uz minējumu

oktāvu diapazons = 3;

kamēr (! (signalFrequencyGuess> = uzglabātsNoteFreq [0] -7 && signalFrequencyGuess <= glabātsNoteFreq [11] +7))

{

par (i = 0; i <12; i ++)

{

storageNoteFreq = 2 * uzglabātsNoteFreq ;

}

octaveRange ++;

}

// Atrodiet tuvāko piezīmi

minVērtība = 10000000;

noteLocation = 0;

par (i = 0; i <12; i ++)

{

ja (minValue> abs (signalFrequencyGuess-storageNoteFreq ))

{

minValue = abs (signalFrequencyGuess-storageNoteFreq );

noteLocation = i;

}

}

// Izdrukāt piezīmi

Serial.print ("Es domāju, ka jūs spēlējāt");

ja (noteLocation == 0)

{

Sērijas nospiedums ("C");

}

citādi, ja (noteLocation == 1)

{

Serial.print ("C#");

}

citādi, ja (noteLocation == 2)

{

Serial.print ("D");

}

citādi, ja (noteLocation == 3)

{

Serial.print ("D#");

}

citādi, ja (noteLocation == 4)

{

Sērijas nospiedums ("E");

}

citādi, ja (noteLocation == 5)

{

Sērijas nospiedums ("F");

}

citādi, ja (noteLocation == 6)

{

Serial.print ("F#");

}

citādi, ja (noteLocation == 7)

{

Serial.print ("G");

}

citādi, ja (noteLocation == 8)

{

Serial.print ("G#");

}

citādi, ja (noteLocation == 9)

{

Serial.print ("A");

}

citādi, ja (noteLocation == 10)

{

Serial.print ("A#");

}

citādi, ja (noteLocation == 11)

{

Serial.print ("B");

}

Serial.println (octaveRange);

}

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

//Apstājies šeit. Lai restartētu, nospiediet Arduino atiestatīšanas pogu

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

kamēr (1);

}

apskatīt rawgistfile1.txt, ko mitina GitHub ar ❤

3. darbība. Iestatiet mūzikas notu detektoru

Savienojiet Arduino Uno ar datoru, izmantojot kodu, kas rakstīts vai ielādēts Arduino IDE. Apkopojiet un augšupielādējiet kodu Arduino. Novietojiet ķēdi tuvu mūzikas avotam. Piezīme. Ievadvideo es kā mūzikas avotu izmantoju planšetdatorā kopā ar datora skaļruņiem instalētu lietotni. Nospiediet Arduino dēļa atiestatīšanas pogu un pēc tam atskaņojiet piezīmi mūzikas avotā. Pēc dažām sekundēm mūzikas notu detektors parādīs atskaņoto noti un tās frekvenci.