संगीत नोट डिटेक्टर: 3 कदम

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:19

इस प्रोजेक्ट के साथ अपने दोस्तों और परिवार को विस्मित करें जो एक उपकरण द्वारा बजाए गए नोट का पता लगाता है। यह प्रोजेक्ट अनुमानित आवृत्ति के साथ-साथ इलेक्ट्रॉनिक कीबोर्ड, पियानो ऐप या किसी अन्य वाद्य यंत्र पर बजने वाले संगीत नोट को प्रदर्शित करेगा।

विवरण

इस प्रोजेक्ट के लिए, साउंड मॉड्यूल डिटेक्टर से एनालॉग आउटपुट को Arduino Uno के A0 एनालॉग इनपुट में भेजा जाता है। एनालॉग सिग्नल का नमूना और परिमाणित (डिजिटल) किया जाता है। पहले 3 अवधियों का उपयोग करके मौलिक आवृत्ति को खोजने के लिए स्वत: सहसंबंध, भार और ट्यूनिंग कोड का उपयोग किया जाता है। निकटतम संगीत नोट आवृत्ति निर्धारित करने के लिए अनुमानित मौलिक आवृत्ति की तुलना ऑक्टेव्स 3, 4, और 5 रेंज में आवृत्तियों की तुलना में की जाती है। अंत में निकटतम आवृत्ति के लिए अनुमानित नोट स्क्रीन पर मुद्रित होता है।

नोट: यह निर्देश केवल इस बात पर केंद्रित है कि प्रोजेक्ट कैसे बनाया जाए। विवरण और डिज़ाइन के औचित्य के बारे में अधिक जानकारी के लिए, कृपया इस लिंक पर जाएँ: अधिक जानकारी

आपूर्ति

• (1) Arduino Uno (या Genuino Uno)
• (1) DEVMO माइक्रोफोन सेंसर उच्च संवेदनशीलता ध्वनि जांच मॉड्यूल संगत
• (1) सोल्डरलेस ब्रेडबोर्ड
• (1) यूएसबी-ए से बी केबल
• जम्पर तार
• संगीत स्रोत (स्पीकर के साथ पियानो, कीबोर्ड या पेनो ऐप)
• (१) कंप्यूटर या लैपटॉप

चरण 1: संगीत नोट डिटेक्टर के लिए हार्डवेयर का निर्माण

एक Arduino Uno, कनेक्शन तारों, एक सोल्डरलेस ब्रेडबोर्ड और एक DEVMO माइक्रोफ़ोन सेंसर उच्च संवेदनशीलता ध्वनि जांच मॉड्यूल (या समान) का उपयोग करके इस छवि में दिखाए गए सर्किट का निर्माण करें

चरण 2: संगीत नोट डिटेक्टर प्रोग्राम करें

Arduino IDE में, निम्न कोड जोड़ें।

gistfile1.txt

/*

फ़ाइल/स्केच नाम: MusicalNoteDetector

संस्करण संख्या: v1.0 बनाया गया 7 जून, 2020

मूल लेखक: क्लाइड ए। लेटसम, पीएचडी, पीई, एमईएम

विवरण: यह कोड/स्केच अनुमानित आवृत्ति के साथ-साथ इलेक्ट्रॉनिक कीबोर्ड या पियानो ऐप पर बजने वाले संगीत नोट को प्रदर्शित करता है। इस परियोजना के लिए, से एनालॉग आउटपुट

साउंड मॉड्यूल डिटेक्टर को Arduino Uno के A0 एनालॉग इनपुट पर भेजा जाता है। एनालॉग सिग्नल का नमूना और परिमाणित (डिजिटल) किया जाता है। ऑटोसहसंबंध, भारोत्तोलन और ट्यूनिंग कोड का उपयोग किया जाता है

पहले 3 आवर्तों का उपयोग करके मौलिक आवृत्ति ज्ञात कीजिए। निकटतम संगीत को निर्धारित करने के लिए अनुमानित मौलिक आवृत्ति की तुलना ऑक्टेव्स 3, 4, और 5 रेंज में आवृत्तियों की तुलना में की जाती है

नोट आवृत्ति। अंत में निकटतम आवृत्ति के लिए अनुमानित नोट स्क्रीन पर मुद्रित होता है।

लाइसेंस: यह प्रोग्राम मुफ्त सॉफ्टवेयर है; आप इसे जीएनयू जनरल पब्लिक लाइसेंस (जीपीएल) संस्करण 3, या किसी भी बाद की शर्तों के तहत पुनर्वितरित और/या संशोधित कर सकते हैं

आपकी पसंद का संस्करण, जैसा कि फ्री सॉफ्टवेयर फाउंडेशन द्वारा प्रकाशित किया गया है।

टिप्पणियाँ: कॉपीराइट (सी) 2020 सीए लेटसम सर्विसेज, एलएलसी द्वारा

अधिक जानकारी के लिए देखें

*/

#define SAMPLES 128 // Arduino Uno के लिए अधिकतम 128।

#define SAMPLING_FREQUENCY 2048 //Fs = Nyquist पर आधारित, उच्चतम अपेक्षित आवृत्ति का 2 गुना होना चाहिए।

#define OFFSETSAMPLES 40 // कैलिब्रेटिंग उद्देश्यों के लिए उपयोग किया जाता है

#define TUNER -3 // C3 तक समायोजित करें 130.50

फ्लोट नमूना अवधि;

अहस्ताक्षरित लंबे माइक्रोसेकंड;

इंट एक्स [नमूने]; // वास्तविक मूल्यों को धारण करने के लिए आकार के नमूने का वेक्टर बनाएं

फ्लोट ऑटोकोर [नमूने]; // काल्पनिक मान रखने के लिए आकार के नमूने का वेक्टर बनाएं

फ्लोट संग्रहीत नोटफ्रीक [१२] = {१३०.८१, १३८.५९, १४६.८३, १५५.५६, १६४.८१, १७४.६१, १८५, १९६, २०७.६५, २२०, २३३.०८, २४६.९४};

इंट समऑफसेट = 0;

इंट ऑफ़सेट [ऑफसेट सैंपल]; // ऑफसेट वेक्टर बनाएं

int avgOffSet; // ऑफसेट वेक्टर बनाएं

int i, k, periodEnd, periodBegin, अवधि, समायोजक, नोट स्थान, ऑक्टेवरेंज;

फ्लोट मैक्सवैल्यू, मिनवैल्यू;

लंबी राशि;

इंट थ्रेश = 0;

इंट numOfCycles = 0;

फ्लोट सिग्नल फ़्रीक्वेंसी, सिग्नल फ़्रिक्वेंसी 2, सिग्नल फ़्रिक्वेंसी 3, सिग्नल फ़्रिक्वेंसी अनुमान, कुल;

बाइट स्टेट_माचिन = 0;

int नमूनेPerPeriod = 0;

व्यर्थ व्यवस्था()

{

सीरियल.बेगिन (115200); //115200 सीरियल मॉनिटर के लिए बॉड दर

}

शून्य लूप ()

{

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

// अंशांकन अनुभाग

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

Serial.println ("कैलब्रेटिंग। कृपया कैलब्रेशन के दौरान कोई नोट न चलाएं।");

के लिए (i = 0; मैं < ऑफसेट नमूने; i++)

{

ऑफ़सेट = एनालॉग रीड (0); // एनालॉग पिन 0 (A0) से मान पढ़ता है, इसे परिमाणित करता है और इसे वास्तविक शब्द के रूप में सहेजता है।

// सीरियल.प्रिंट्लन (ऑफसेट ); // इसका उपयोग साउंड डिटेक्शन मॉड्यूल को लगभग आधे या 512 में समायोजित करने के लिए करें जब कोई ध्वनि न बजाए जाए।

समऑफसेट = समऑफसेट + ऑफ़सेट ;

}

नमूने अवधि = 0;

मैक्सवैल्यू = 0;

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

// A0. से इनपुट स्वीकार करने के लिए तैयार करें

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

avgOffSet = राउंड (sumOffSet / OFFSETSAMPLES);

Serial.println ("काउंटिंग डाउन");

देरी (1000); // 1 सेकंड के लिए रुकें

सीरियल.प्रिंट्लन ("3");

देरी (1000); // 1 सेकंड के लिए रुकें

सीरियल.प्रिंट्लन ("2");

देरी (1000); // 1. के लिए रुकें

सीरियल.प्रिंट्लन ("1");

देरी (1000); // 1 सेकंड के लिए रुकें

Serial.println ("अपना नोट चलाएं!");

देरी (250); // प्रतिक्रिया समय के लिए 1/4 सेकंड के लिए रुकें

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

// नमूना अवधि की नमूना अवधि के साथ A0 से नमूने के नमूने एकत्र करें

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

नमूना अवधि = 1.0 / SAMPLING_FREQUENCY; // माइक्रोसेकंड में अवधि

के लिए (i = 0; मैं < नमूने; i++)

{

माइक्रोसेकंड = माइक्रो (); // जब से Arduino बोर्ड ने वर्तमान स्क्रिप्ट को चलाना शुरू किया है, तब से माइक्रोसेकंड की संख्या लौटाता है।

एक्स = एनालॉग रीड (0); // एनालॉग पिन 0 (A0) से मान पढ़ता है, इसे परिमाणित करता है और इसे वास्तविक शब्द के रूप में सहेजता है।

/*नमूनों के बीच शेष प्रतीक्षा समय यदि आवश्यक हो तो सेकंड में */

जबकि (माइक्रो () <(माइक्रोसेकंड + (नमूना अवधि * 1000000)))

{

// कुछ न करें बस प्रतीक्षा करें

}

}

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

// ऑटोसहसंबंध समारोह

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

के लिए (i = 0; मैं <नमूने; i++) //i=delay

{

योग = 0;

के लिए (के = 0; के <नमूने - i; के ++) // विलंबित सिग्नल के साथ सिग्नल का मिलान करें

{

योग = योग + (((एक्स [के]) - औसत ऑफसेट) * ((एक्स [के + आई]) - औसत ऑफसेट)); // एक्स [के] सिग्नल है और एक्स [के + आई] विलंबित संस्करण है

}

स्वत: सुधार = योग / नमूने;

// फर्स्ट पीक डिटेक्ट स्टेट मशीन

अगर (राज्य_मशीन == 0 && मैं == 0)

{

थ्रेश = ऑटोकोर * 0.5;

राज्य_मशीन = 1;

}

और अगर (state_machine == 1 && i>0 && थ्रेश 0) // State_machine=1, पहले चक्र का उपयोग करने के लिए 1 अवधि खोजें

{

मैक्सवैल्यू = ऑटोकोर ;

}

और अगर (स्टेट_मशीन == 1&& i>0 && थ्रेश <ऑटोकोर [i-1] && मैक्सवैल्यू == ऑटोकोर [i-1] && (ऑटोकोर -ऑटोकोर [i-1])<=0)

{

अवधिबीगिन = i-1;

राज्य_मशीन = 2;

numOfCycles = 1;

नमूनेपेरियोड = (अवधिबीगिन - 0);

अवधि = नमूने अवधि;

समायोजक = ट्यूनर + (५०.०४ * क्स्प (-०.१०२ * नमूने अवधि));

सिग्नल फ़्रीक्वेंसी = ((SAMPLING_FREQUENCY) / (नमूने अवधि)) -समायोजक; // एफ = एफएस / एन

}

और अगर (state_machine == 2 && i>0 && थ्रेश 0) //state_machine=2, पहले और दूसरे चक्र के लिए 2 अवधि खोजें

{

मैक्सवैल्यू = ऑटोकोर ;

}

और अगर (स्टेट_मशीन == 2&& i>0 && थ्रेश <ऑटोकोर [i-1] && मैक्सवैल्यू == ऑटोकोर [i-1] && (ऑटोकोर -ऑटोकोर [i-1])<=0)

{

अवधि समाप्ति = i-1;

राज्य_मशीन = 3;

numOfCycles = 2;

नमूनेपेरियोड = (पीरियडएंड - 0);

सिग्नल फ़्रीक्वेंसी 2 = ((numOfCycles*SAMPLING_FREQUENCY) / (नमूनेपेरियोड)) -समायोजक; // f = (2*fs)/(2*N)

मैक्सवैल्यू = 0;

}

और अगर (state_machine == 3 && i>0 && थ्रेश 0) //state_machine=3, पहले, दूसरे और तीसरे चक्र के लिए 3 पीरियड्स खोजें

{

मैक्सवैल्यू = ऑटोकोर ;

}

और अगर (स्टेट_मशीन == 3&& i>0 && थ्रेश <ऑटोकोर [i-1] && मैक्सवैल्यू == ऑटोकोर [i-1] && (ऑटोकोर -ऑटोकोर [i-1])<=0)

{

अवधि समाप्ति = i-1;

राज्य_मशीन = 4;

numOfCycles = 3;

नमूनेपेरियोड = (पीरियडएंड - 0);

सिग्नलफ्रीक्वेंसी3 = ((numOfCycles*SAMPLING_FREQUENCY) / (नमूनेPeriod)) -समायोजक; // f = (3*fs)/(3*N)

}

}

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

// परिणाम विश्लेषण

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

अगर (नमूने अवधि == 0)

{

Serial.println ("हम्म….. मुझे यकीन नहीं है। क्या आप मुझे बरगलाने की कोशिश कर रहे हैं?");

}

अन्यथा

{

// वेटिंग फंक्शन तैयार करें

कुल = 0;

अगर (सिग्नल फ्रीक्वेंसी! = 0)

{

कुल = 1;

}

अगर (सिग्नल फ्रीक्वेंसी 2! = 0)

{

कुल = कुल + 2;

}

अगर (सिग्नल फ़्रीक्वेंसी 3! = 0)

{

कुल = कुल + 3;

}

// वेटिंग फ़ंक्शन का उपयोग करके आवृत्ति की गणना करें

सिग्नल फ़्रीक्वेंसी अनुमान = ((१/कुल) * सिग्नल फ़्रिक्वेंसी) + ((२/कुल) * सिग्नल फ़्रिक्वेंसी २) + ((३/कुल) * सिग्नल फ़्रिक्वेंसी ३); // भारित आवृत्ति का पता लगाएं

Serial.print ("आपके द्वारा खेला गया नोट लगभग है");

सीरियल.प्रिंट (सिग्नल फ़्रीक्वेंसीगेस); // आवृत्ति अनुमान प्रिंट करें।

Serial.println ("हर्ट्ज।");

// अनुमान के आधार पर ऑक्टेव रेंज खोजें

ऑक्टेवरेंज = 3;

जबकि (!(सिग्नल फ़्रीक्वेंसी अनुमान >= संग्रहित नोटफ़्रेक [0] -7 && सिग्नल फ़्रिक्वेंसी अनुमान <= संग्रहीत नोटफ़्रीक [11] +7))

{

के लिए (i = 0; मैं <12; i++)

{

storeNoteFreq = 2 * storeedNoteFreq;

}

ऑक्टेवरेंज++;

}

// निकटतम नोट खोजें

मिनवैल्यू = 10000000;

नोट स्थान = 0;

के लिए (i = 0; मैं <12; i++)

{

अगर (मिनवैल्यू> एब्स (सिग्नल फ़्रीक्वेंसी अनुमान-संग्रहीत नोटफ़्रेक ))

{

minValue = abs (सिग्नल फ़्रीक्वेंसीग्यूस-स्टोरेड नोटफ़्रेक );

नोट स्थान = मैं;

}

}

// नोट प्रिंट करें

Serial.print ("मुझे लगता है कि आपने खेला");

अगर (नोट स्थान == 0)

{

सीरियल.प्रिंट ("सी");

}

और अगर (नोट स्थान == 1)

{

सीरियल.प्रिंट ("सी #");

}

और अगर (नोट स्थान == 2)

{

सीरियल.प्रिंट ("डी");

}

और अगर (नोट स्थान == 3)

{

सीरियल.प्रिंट ("डी #");

}

और अगर (नोट स्थान == 4)

{

सीरियल.प्रिंट ("ई");

}

और अगर (नोट स्थान == 5)

{

सीरियल.प्रिंट ("एफ");

}

और अगर (नोट स्थान == 6)

{

सीरियल.प्रिंट ("एफ #");

}

और अगर (नोट स्थान == 7)

{

सीरियल.प्रिंट ("जी");

}

और अगर (नोट स्थान == 8)

{

सीरियल.प्रिंट ("जी #");

}

और अगर (नोट स्थान == 9)

{

सीरियल.प्रिंट ("ए");

}

और अगर (नोट स्थान == 10)

{

सीरियल.प्रिंट ("ए #");

}

और अगर (नोट स्थान == 11)

{

सीरियल.प्रिंट ("बी");

}

Serial.println(octaveRange);

}

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

//यहाँ रुको। पुनः आरंभ करने के लिए Arduino पर रीसेट बटन दबाएं

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

जबकि (1);

}

देखें rawgistfile1.txt GitHub द्वारा ❤ के साथ होस्ट किया गया

चरण 3: संगीत नोट डिटेक्टर सेटअप करें

Arduino IDE में लिखे या लोड किए गए कोड के साथ Arduino Uno को PC से कनेक्ट करें। कोड को Arduino पर संकलित करें और अपलोड करें। सर्किट को संगीत स्रोत के करीब रखें। नोट: परिचय वीडियो में, मैं अपने संगीत स्रोत के रूप में पीसी स्पीकर के साथ टैबलेट पर इंस्टॉल किए गए ऐप का उपयोग करता हूं। Arduino Board पर रीसेट बटन दबाएं और फिर संगीत स्रोत पर एक नोट चलाएं। कुछ सेकंड के बाद, म्यूजिकल नोट डिटेक्टर चलाए गए नोट और उसकी आवृत्ति को प्रदर्शित करेगा।