न्यूनतम चार भाग मिडी खिलाड़ी

प्रस्तावित खिलाड़ी को मेमोरी कार्ड की आवश्यकता नहीं होती है, यह ATTiny85 माइक्रोकंट्रोलर (सीधे इस क्लासिक डिज़ाइन के विपरीत, जो WAV फ़ाइलों को खेलता है, इसे स्वाभाविक रूप से मेमोरी कार्ड की आवश्यकता होती है) के विपरीत लंबाई में 6,000 बाइट्स तक की MIDI फ़ाइल संग्रहीत करता है। पीडब्लूएम का उपयोग करते हुए क्षीणन के साथ चार-तरफा प्लेबैक सॉफ्टवेयर में लागू किया जाता है। ध्वनि का एक उदाहरण यहाँ है ।

उपकरण योजना के अनुसार बनाया गया है:



माइक्रोकंट्रोलर और गतिशील सिर के बीच इलेक्ट्रोलाइटिक संधारित्र निरंतर घटक को याद नहीं करेगा यदि एक सॉफ्टवेयर विफलता के परिणामस्वरूप पीबी 4 के आउटपुट पर एक तार्किक इकाई दिखाई देती है। सिर की अनिच्छा पीडब्लूएम आवृत्ति को पारित नहीं करती है। यदि आप एम्पलीफायर से डिवाइस को कनेक्ट करने का निर्णय लेते हैं, तो पीडब्लूएम सिग्नल के साथ उत्तरार्द्ध को ओवरलोड करने से बचने के लिए, आपको यहां कम-पास फिल्टर जोड़ने की आवश्यकता है ।

मिडी फ़ाइल को प्रपत्र के एक सरणी के रूप में फर्मवेयर स्रोत में रखा जाना चाहिए:

const uint8_t Tune[] PROGMEM = { 0x4d, 0x54, 0x68, 0x64, 0x00, 0x00, 0x00, 0x06, 0x00, 0x01, 0x00, 0x01, 0x03, 0xc0, 0x4d, 0x54, 0x72, 0x6b, 0x00, 0x00, 0x0a, 0x7e, 0x00, 0xff, ... 0x50, 0xb0, 0x5b, 0x00, 0x00, 0xff, 0x2f, 0x00 }; 

फ़ाइल को इस प्रारूप में UNIX- जैसे OS - xxd उपयोगिता में परिवर्तित करने के लिए तैयार समाधान है। हम मिडी फ़ाइल लेते हैं और इस तरह से इस उपयोगिता से गुजरते हैं:

 xxd -i musicbox.mid 

कंसोल कुछ इस तरह प्रदर्शित होगा:

 unsigned char musicbox_mid[] = { 0x4d, 0x54, 0x68, 0x64, 0x00, 0x00, 0x00, 0x06, 0x00, 0x01, 0x00, 0x01, 0x03, 0xc0, 0x4d, 0x54, 0x72, 0x6b, 0x00, 0x00, 0x0a, 0x7e, 0x00, 0xff, ... 0x50, 0xb0, 0x5b, 0x00, 0x00, 0xff, 0x2f, 0x00 }; unsigned int musicbox_mid_len = 2708; 

2708 बाइट्स में लंबाई है। यह 6000 से कम निकला - इसका मतलब है कि यह फिट बैठता है। क्लिपबोर्ड के माध्यम से हेक्साडेसिमल संख्याओं के अनुक्रम को स्केच पर स्थानांतरित किया जाता है (बस याद रखें: कंसोल में - कोई Ctrl + C ) डिफ़ॉल्ट सरणी के बजाय। या अगर हम इसे छोड़ना चाहते हैं तो यह सब न करें।

टाइमर काउंटर 1 PLL से 64 मेगाहर्ट्ज की आवृत्ति पर काम करेगा:

  PLLCSR = 1<<PCKE | 1<<PLLE; 

हम DAC के रूप में काम करने के लिए इस टाइमर को PWM मोड में स्थानांतरित करते हैं; कर्तव्य चक्र OCR1B के मान पर निर्भर करेगा:

  TIMSK = 0; // Timer interrupts OFF TCCR1 = 1<<CS10; // 1:1 prescale GTCCR = 1<<PWM1B | 2<<COM1B0; // PWM B, clear on match OCR1B = 128; DDRB = 1<<DDB4; // Enable PWM output on pin 4 

आयताकार दालों की आवृत्ति OCR1C के मूल्य पर निर्भर करती है, हम इसे 255 (डिफ़ॉल्ट रूप से) के बराबर छोड़ देते हैं, फिर 64 मेगाहर्ट्ज की आवृत्ति को 256 से विभाजित किया जाएगा, और हमें 250 kHz मिलता है।

टाइमर काउंटर 0 अवरोध उत्पन्न करेगा:

  TCCR0A = 3<<WGM00; // Fast PWM TCCR0B = 1<<WGM02 | 2<<CS00; // 1/8 prescale OCR0A = 19; // Divide by 20 TIMSK = 1<<OCIE0A; // Enable compare match, disable overflow 

16 मेगाहर्ट्ज की एक घड़ी आवृत्ति को विभक्त द्वारा 8 से विभाजित किया जाता है, और फिर 19 + 1 के OCR0A मान से, और 100 kHz प्राप्त किया जाता है। खिलाड़ी चार आवाज वाला होता है, प्रत्येक आवाज के लिए 25 kHz प्राप्त होता है। रुकावट होने पर, एक ISR प्रोसेसिंग रूटीन कहा जाता है (TIMER0_COMPA_vect), जो ध्वनियों की गणना और आउटपुट करता है।

वॉचडॉग टाइमर को हर 16 एमएस में एक बाधा उत्पन्न करने के लिए कॉन्फ़िगर किया गया है, जिसे नोट आवृत्तियों को प्राप्त करना आवश्यक है:

 WDTCR = 1<<WDIE | 0<<WDP0; // Interrupt every 16ms 

किसी दिए गए आकार के दोलनों को प्राप्त करने के लिए, प्रत्यक्ष डिजिटल संश्लेषण का उपयोग किया जाता है। ATtiny85 में कोई हार्डवेयर गुणन नहीं है, इसलिए हम आयताकार दालों को लेते हैं और लिफाफे के आयाम को 1 या -1 से गुणा करते हैं। आयाम रैखिक रूप से घटता है, और समय में इसे एक निश्चित समय पर गणना करने के लिए, यह मीटर रीडिंग को रैखिक रूप से कम करने के लिए पर्याप्त है।

प्रत्येक चैनल के लिए तीन चर प्रदान किए जाते हैं: Freq [] - आवृत्ति, Acc [] - चरण बैटरी, Amp [], लिफाफा प्रवर्धित मूल्य। Freq [] और Acc [] के मूल्य संक्षेप हैं। आयताकार दालों को प्राप्त करने के लिए उच्च-क्रम बिट Acc [] का उपयोग किया जाता है। अधिक Freq [], उच्च आवृत्ति। तैयार तरंग लिफाफे Amp [] द्वारा गुणा किया जाता है। सभी चार चैनल मल्टीप्लेक्स हैं और एनालॉग आउटपुट को खिलाया जाता है।

कार्यक्रम का एक महत्वपूर्ण हिस्सा टाइमर-काउंटर 0 से रुकावट को संसाधित करने की प्रक्रिया है, जो एनालॉग उत्पादन के लिए दोलनों को आउटपुट करता है। इस प्रक्रिया को लगभग 95 kHz की आवृत्ति पर कहा जाता है। वर्तमान चैनल c के लिए, यह Acc [c] और Amp [c] के मूल्यों को अद्यतन करता है, और वर्तमान नोट के मूल्य की गणना भी करता है। परिणाम OCR1B टाइमर-काउंटर के OCR1B तुलना रजिस्टर को पिन 4 पर एक एनालॉग सिग्नल प्राप्त करने के लिए भेजा जाता है:

 ISR(TIMER0_COMPA_vect) { static uint8_t c; signed char Temp, Mask, Env, Note; Acc[c] = Acc[c] + Freq[c]; Amp[c] = Amp[c] - (Amp[c] != 0); Temp = Acc[c] >> 8; Temp = Temp & Temp<<1; Mask = Temp >> 7; Env = Amp[c] >> Volume; Note = (Env ^ Mask) + (Mask & 1); OCR1B = Note + 128; c = (c + 1) & 3; } 

पंक्ति

 Acc[c] = Acc[c] + Freq[c]; 

बैटरी Acc [c] में फ्रीक्वेंसी freq [c] जोड़ता है। अधिक से अधिक Freq [c], तेजी से Acc [c] मान बदल जाएगा। फिर लाइन

 Amp[c] = Amp[c] - (Amp[c] != 0); 

किसी दिए गए चैनल के लिए आयाम मान को घटाता है। टुकड़ा (Amp [c]! = 0) की आवश्यकता है ताकि आयाम शून्य तक पहुंचने के बाद यह और कम न हो। अब रेखा

 Temp = Acc[c] >> 8; 

Acc [c] के उच्च 9 बिट्स को Temp में स्थानांतरित करता है। और रेखा

 Temp = Temp & Temp<<1; 

इस चर के उच्च-क्रम बिट को एक के बराबर छोड़ता है यदि दो उच्च-क्रम बिट एक के बराबर हैं, और उच्च-क्रम बिट को शून्य पर सेट करता है यदि यह नहीं है। परिणाम आयताकार दालों के साथ 25/75 के ऑन / ऑफ अनुपात है। पिछले निर्माणों में से एक में, लेखक ने एक मेन्डंडर लगाया, जबकि नई विधि के साथ, हार्मोनिक्स थोड़ा अधिक प्राप्त किया जाता है। पंक्ति

 Mask = Temp >> 7; 

सबसे महत्वपूर्ण बाइट के शेष बिट्स के मूल्यों को स्थानांतरित करता है, उदाहरण के लिए, यदि सबसे महत्वपूर्ण बिट 0 था, तो 0x00 प्राप्त किया जाएगा, और यदि 1 - तो 0xFF। पंक्ति

 Env = Amp[c] >> Volume; 

वॉल्यूम के मान से Enp [c] बिट को Env में ट्रांसफर करता है, डिफ़ॉल्ट रूप से सीनियर द्वारा, वॉल्यूम = 8. स्ट्रिंग के बाद से

 Note = (Env ^ Mask) + (Mask & 1); 

यह सब एकजुट करता है। यदि मास्क = 0x00 है, तो नोट को Env मान दिया गया है। यदि मास्क = 0xFF, तो नोट को Env + 1 के लिए अतिरिक्त मान दिया गया है, अर्थात, एक ऋण चिह्न के साथ Env। नोट में वर्तमान तरंग है, जो वर्तमान आयाम के सकारात्मक से नकारात्मक मानों में बदल रही है। पंक्ति

 OCR1B = Note + 128; 

नोट में 128 जोड़ता है और OCR1B पर परिणाम लिखता है। पंक्ति

 c = (c + 1) & 3; 

इसी अंतराल के अनुसार चार चैनल आउटपुट करता है, आउटपुट पर आवाज़ों को गुणा करता है।

बारह नोट आवृत्तियों सरणी में दिए गए हैं:

 unsigned int Scale[] = { 10973, 11626, 12317, 13050, 13826, 14648, 15519, 16442, 17419, 18455, 19552, 20715}; 

अन्य सप्तक के नोट आवृत्तियों को 2 ⁿ से विभाजित करके प्राप्त किया जाता है। उदाहरण के लिए, हम 10973 को 2 ^{4 से} विभाजित करते हैं और हमें 686 मिलते हैं। ऊपरी बिट Acc [c] 25000 / (65536/685) = 261.7 हर्ट्ज की आवृत्ति के साथ स्विच करेगा।

दो चर ध्वनि को प्रभावित करते हैं: आयतन - आयतन, 7 से 9 और क्षय - क्षीणन, 12 से 14. तक उच्चतर क्षय मान, क्षीणन धीमा।

सरलतम मिडी दुभाषिया केवल नोट, टेम्पो और डिवीजन गुणांक के मूल्यों पर ध्यान देता है, और अन्य डेटा को अनदेखा करता है। ReadIgnore () रूटीन फ़ाइल से प्राप्त सरणी में बाइट्स की निर्दिष्ट संख्या को छोड़ देता है:

 void readIgnore (int n) { Ptr = Ptr + n; } 

ReadNumber () दिनचर्या दी गई बाइट्स की संख्या से 4 की सटीकता के साथ एक संख्या पढ़ती है:

 unsigned long readNumber (int n) { long result = 0; for (int i=0; i<n; i++) result = (result<<8) + pgm_read_byte(&Tune[Ptr++]); return result; } 

ReadVariable () दिनचर्या MIDI चर परिशुद्धता के साथ एक संख्या पढ़ता है। इस मामले में बाइट्स की संख्या एक से चार हो सकती है:

 unsigned long readVariable () { long result = 0; uint8_t b; do { b = pgm_read_byte(&Tune[Ptr++]); result = (result<<7) + (b & 0x7F); } while (b & 0x80); return result; } 

प्रत्येक बाइट से सात बिट्स लिए जाते हैं, और आठवें एक के बराबर है यदि आपको किसी अन्य बाइट को आगे पढ़ने की आवश्यकता है, या शून्य नहीं तो।

दुभाषिया नोटऑन () रूटीन को निम्नलिखित उपलब्ध चैनल में नोट चलाने के लिए कहता है:

 void noteOn (uint8_t number) { uint8_t octave = number/12; uint8_t note = number%12; unsigned int freq = Scale[note]; uint8_t shift = 9-octave; Freq[Chan] = freq>>shift; Amp[Chan] = 1<<Decay; Chan = (Chan + 1) & 3; } 

Ptr चर पढ़ने के लिए अगले बाइट को इंगित करता है:

 void playMidiData () { Ptr = 0; // Begin at start of file 

MIDI फ़ाइल में पहला ब्लॉक एक हेडर है जो पटरियों, टेम्पो और डिवीजन अनुपात की संख्या को इंगित करता है:

 // Read header chunk unsigned long type = readNumber(4); if (type != MThd) error(1); unsigned long len = readNumber(4); unsigned int format = readNumber(2); unsigned int tracks = readNumber(2); unsigned int division = readNumber(2); // Ticks per beat TempoDivisor = (long)division*16000/Tempo; 

विभाजन गुणांक आमतौर पर 960 के बराबर होता है। अब हम दिए गए ब्लॉकों की संख्या पढ़ते हैं:

  // Read track chunks for (int t=0; t<tracks; t++) { type = readNumber(4); if (type != MTrk) error(2); len = readNumber(4); EndBlock = Ptr + len; 

ब्लॉक के अंत तक अनुक्रमिक घटनाओं को पढ़ें:

  // Parse track while (Ptr < EndBlock) { unsigned long delta = readVariable(); uint8_t event = readNumber(1); uint8_t eventType = event & 0xF0; if (delta > 0) Delay(delta/TempoDivisor); 

प्रत्येक घटना में, डेल्टा निर्दिष्ट किया जाता है - विभाजन गुणांक द्वारा निर्धारित समय की इकाइयों में देरी, जो इस घटना से पहले होनी चाहिए। यहां होने वाली घटनाओं के लिए, डेल्टा शून्य है।

मेटा-इवेंट्स प्रकार की घटनाएँ हैं 0xFF:

  // Meta event if (event == 0xFF) { uint8_t mtype = readNumber(1); uint8_t mlen = readNumber(1); // Tempo if (mtype == 0x51) { Tempo = readNumber(mlen); TempoDivisor = (long)division*16000/Tempo; // Ignore other meta events } else readIgnore(mlen); 

एकमात्र प्रकार की मेटा-घटना जो हमें रुचती है, टेंपो है, माइक्रोसेकंड में टेम्पो का मूल्य। डिफ़ॉल्ट रूप से, यह 500,000 है, यानी आधा सेकंड, जो प्रति मिनट 120 बीट्स से मेल खाती है।

शेष घटनाएं मिडी की घटनाओं को उनके प्रकार के पहले हेक्साडेसिमल अंक द्वारा परिभाषित किया गया है। हम केवल 0x90 में रुचि रखते हैं - नोट पर, निम्नलिखित उपलब्ध चैनल पर नोट्स खेल रहे हैं:

  // Note off - ignored } else if (eventType == 0x80) { uint8_t number = readNumber(1); uint8_t velocity = readNumber(1); // Note on } else if (eventType == 0x90) { uint8_t number = readNumber(1); uint8_t velocity = readNumber(1); noteOn(number); // Polyphonic key pressure } else if (eventType == 0xA0) readIgnore(2); // Controller change else if (eventType == 0xB0) readIgnore(2); // Program change else if (eventType == 0xC0) readIgnore(1); // Channel key pressure else if (eventType == 0xD0) readIgnore(1); // Pitch bend else if (eventType == 0xD0) readIgnore(2); else error(3); } } } 

हम वेग मान को अनदेखा करते हैं, लेकिन यदि आप चाहें, तो आप इस पर नोट का प्रारंभिक आयाम निर्धारित कर सकते हैं। हम बाकी घटनाओं को छोड़ देते हैं, उनकी लंबाई अलग हो सकती है। यदि मिडी फ़ाइल में कोई त्रुटि होती है, तो एलईडी चालू होता है।

माइक्रोकंट्रोलर 16 मेगाहर्ट्ज की आवृत्ति पर संचालित होता है, ताकि क्वार्ट्ज की आवश्यकता न हो, आपको अंतर्निहित PLL को ठीक से कॉन्फ़िगर करने की आवश्यकता है। Arduino- संगत बनने के लिए माइक्रोकंट्रोलर के लिए, स्पेंस कोंडे का यह अनुभव लागू होता है। बोर्ड मेनू में, ATtinyCore सबमेनू का चयन करें, और वहां - ATtiny25 / 45/85। निम्नलिखित मेनू में, चयन करें: टाइमर 1 क्लॉक: सीपीयू, बीओडी डिसेबल, एटीटिनी 85, 16 मेगाहर्ट्ज (पीएलएल)। फिर बर्न बूटलोडर चुनें, फिर प्रोग्राम में भरें। प्रोग्रामर का उपयोग SpinyFun के टिनी AVR प्रोग्रामर बोर्ड की तरह किया जाता है।

CC-BY 4.0 के लिए फर्मवेयर, जिसमें पहले से ही डी माइनर में एक बैच फ़ग्यू है, यहां मूल ओडीआई फ़ाइल ली गई है ।