👩🏾‍🤝‍👩🏽 💙 🏇🏼 हम मिडी-कीबोर्ड का उपयोग करके लिलीपोंड में टाइप करते हैं 🏘️ ⛴️ ⚒️

मैंने पहले से ही लिलिपंड के बारे में एक दो बार लिखा था, और अब मैंने मिडी कीबोर्ड खरीदा।

फिनाले और सिबेलियस सहित कई नोट संपादकों में मिडी कीबोर्ड से दो तरह से नोट्स टाइप करने की क्षमता है: या तो आप किसी मेट्रोनोम के साथ कुछ खेल सकते हैं, और इसे तुरंत नोट्स के साथ रिकॉर्ड किया जाएगा, या आप केवल इसमें और ताल से नोट्स दर्ज कर सकते हैं। बाकी सब कुछ सामान्य तरीके से दर्ज किया गया है।

मैंने फैसला किया कि इसी तरह का अवसर मेरे पसंदीदा लिलिपंड के लिए दुख नहीं होगा। चूंकि एक मिडी फ़ाइल लिखने की क्षमता और फिर इसे मिडी 2 का उपयोग करके परिवर्तित करना मुझे शोभा नहीं देता है - सिर्फ टाइपिंग प्रकार की बहुत अधिक जानकारी मिडी फ़ाइल में परिलक्षित नहीं हो सकती है (हमने पहले से ही इस पर चर्चा की ) - मैंने एक कार्यक्रम लिखने का फैसला किया ताकि दबाया जाए चाबियाँ और तार तुरंत आवश्यक प्रारूप में परिवर्तित हो गए।

UPD: निम्नलिखित में से लगभग आधे हिस्से के लिए नोट की आवश्यकता होती है

\ सापेक्ष कमांड का उपयोग करके लिलीपॉन्ड में टाइप करने से आप प्रत्येक नोट के लिए एक ओक्टेव निर्दिष्ट नहीं कर सकते हैं, लेकिन केवल उस दिशा को इंगित करने के लिए जिसमें ऑक्टेव बदलता है। इस तरह के संकेत के बिना, प्रत्येक बाद के नोट (एक राग के मामले में, पहले संकेत दिया गया ध्वनि) एक क्वार्ट से आगे नहीं है। यही है, पहले वाले के बाद का स्कोर उच्चतर होगा, भले ही एफ तेज हो, और पहले वाला सपाट (दोगुना, लेकिन एक चौथाई, हाँ)।

एक कार्यक्रम लिखने से मुझे दो प्रकार की जटिलताओं का सामना करना पड़ा: वास्तव में मिडी कीबोर्ड के साथ काम करना और प्राप्त संकेतों को वांछित रूप में परिवर्तित करना।

मिडी-डॉट-नेट: मिडी के साथ काम करना

सबसे पहले मैंने मिडी-डॉट-नेट लाइब्रेरी डाउनलोड की थी। यह इनपुट और आउटपुट दोनों की संभावना प्रदान करता है, लेकिन हम अब इनपुट में रुचि रखते हैं।

उपकरणों की सूची, खोलना और बंद करना

उपलब्ध इनपुट उपकरणों की सूची, मैंने इसे कॉम्बो बॉक्स में भर दिया।

using Midi; // ....... private void LoadMidiDevices() { foreach (InputDevice d in InputDevice.InstalledDevices) { DeviceList.Items.Add(d.Name); } DeviceList.SelectedIndex = 0; UpdateDevice(); }

डिवाइस के नाम के अलावा, आप निर्माताआईड, प्रोडक्टआईड और इन सभी को एक साथ एक फील्ड स्पेस में भी देख सकते हैं।

ओपन () और क्लोज़ () विधियाँ उपकरण को खोलती और बंद करती हैं, राज्य को सूचना प्राप्त करने के लिए जिम्मेदार IsOpen, StartReceiving (), StopReceiving (), IsReceiving फ़ील्ड से क्रमशः प्राप्त किया जा सकता है। पुस्तकालय सुविधाजनक C # -स्टाइल इवेंट बाइंडिंग प्रदान करता है।

StartReceiving () विधि वैकल्पिक रूप से क्लॉक के ऑब्जेक्ट को स्वीकार करती है, जिसका उद्देश्य मुख्य रूप से MIDI आउटपुट के लिए होता है। यदि आप अशक्त हो जाते हैं, तो घटनाओं में टाइमस्टैम्प्स की गणना उस क्षण से की जाएगी जब StartReceiving () कहा जाता है।

 private void UpdateDevice() { if (d != null) { if (d.IsReceiving) d.StopReceiving(); if (d.IsOpen) d.Close(); } d = InputDevice.InstalledDevices[DeviceList.SelectedIndex]; if (!d.IsOpen) d.Open(); if (d.IsReceiving) d.StopReceiving(); d.StartReceiving(null); if (d != null) { d.NoteOn += new InputDevice.NoteOnHandler(this.NoteOn); d.NoteOff += new InputDevice.NoteOffHandler(this.NoteOff); d.ControlChange += new InputDevice.ControlChangeHandler(this.ControlChange); } }

बाहर निकलते समय डिवाइस को बंद करना न भूलें

 private void SettingsWindow_FormClosing(object sender, FormClosingEventArgs e) { d.StopReceiving(); d.Close(); }

प्रसंस्करण पर क्लिक करें

मैंने ऑपरेशन एल्गोरिथ्म को इस तरह चुना: जब आप सभी कुंजी जारी करते हैं, तो जिन्हें 50 से अधिक एमएस के लिए दबाया गया है उन्हें कनवर्टर में थोक में स्थानांतरित किया जाता है और SendKeys का उपयोग करके सक्रिय विंडो में भेजा जाता है। यह व्यक्तिगत नोट्स और कॉर्ड दोनों को डायल करना संभव बनाता है।

अपमान को लागू करना सरल है:

नोटऑन // नोटऑफ

 private List<Pitch> notes; private Dictionary<Pitch, float> events; //.... public void NoteOn(NoteOnMessage msg) { lock (this) { events[msg.Pitch] = msg.Time; } } public void NoteOff(NoteOffMessage msg) { lock (this) { if (events.ContainsKey(msg.Pitch)) { if (msg.Time - events[msg.Pitch] > 0.05) { notes.Add(msg.Pitch); } events.Remove(msg.Pitch); if ((events.Count == 0) && (notes.Count > 0)) { SendKeys.SendWait(" " + cons.Convert(notes)); notes.Clear(); } } } }

मैंने निरंतर पेडल (और, मेरे मामले में, बटन) का उपयोग करके लीग (कोष्ठक सिंटैक्स में कोष्ठक) स्थापित करने की क्षमता को भी जोड़ा। चूंकि मेरा कीबोर्ड दो टुकड़ों में कंट्रोलचेंज भेजता है, इसलिए मैंने एक अतिरिक्त चेक जोड़ा।

 bool sustain; // ....... public void ControlChange(ControlChangeMessage msg) { if (msg.Control == Midi.Control.SustainPedal) { if ((msg.Value > 64) && !sustain) { sustain = true; SendKeys.SendWait("{(}"); } if ((msg.Value < 64) && sustain) { sustain = false; SendKeys.SendWait("{)}"); } } return; }

लाइब्रेरी आपको ProgramChange और PitchBend ईवेंट्स को संभालने की भी अनुमति देती है।

हम संगीत के प्राथमिक सिद्धांत के पागल काटते हैं

दूसरा कार्य पहले की तुलना में अधिक कठिन था। मैंने वर्णों की संख्या और एक प्रमुख-मामूली स्विच को इंगित करने के लिए विंडो में एक काउंटर जोड़ा और सोचने लगा।

सबसे पहले, मैंने मिडी. पिच मूल्य और निष्कर्ष के बीच एक मध्यवर्ती लिंक बनाया - गामा स्टेप क्लास (शब्दकोश में देखने के लिए बहुत आलसी, पहले इसे ग्रेड कहा जाता था, लेकिन डिग्री आवश्यक थी)। कुंजी के आधार पर, हम Midi.Pitch को डिग्री में बदल देंगे।
Arrays 7-चरण पैमाने के चरण और इसके परिवर्तन (वृद्धि या कमी) के लिए रंगीन (12-चरण) पैमाने में संख्या को परिवर्तित करने के लिए सेटिंग्स को संग्रहीत करता है।

पिचकोर्ड्रेड ()

 private static int[] majorScale = { 0, 1, 1, 2, 2, 3, 3, 4, 5, 5, 6, 6 }; private static int[] majorAcc = { 0, -1, 0, -1, 0, 0, 1, 0, -1, 0, -1, 0 }; private static int[] minorScale = { 0, 1, 1, 2, 2, 3, 3, 4, 5, 5, 6, 6 }; private static int[] minorAcc = { 0, -1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1 }; private Degree PitchToGrade(Pitch p) { //      int keybase = (keys * 7) % 12 - (isMajor?0:3); //          int offset = ((int)p - keybase) % 12; //     7-  int octave = (((int)p - keybase) / 12) * 7; int num, acc; if (offset < 0) offset += 12; if (isMajor) { num = majorScale[offset] + octave; acc = majorAcc[offset]; } else { num = minorScale[offset] + octave; acc = minorAcc[offset]; } return new Degree(num, acc); }

उसके बाद, सबसे अप्रिय बात शुरू होती है: यह पता लगाने के लिए कि कौन सा नोट और किस संकेत के साथ इस संख्या के साथ कदम को इंगित करेगा और दिए गए टन में इस परिवर्तन के साथ।

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

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

समाधान ()

 private static String[] Naturals = { "c", "d", "e", "f", "g", "a", "h" }; private static String[] Sharps = { "cis", "dis", "eis", "fis", "gis", "ais", "his" }; private static String[] Flats = { "ces", "des", "es", "fes", "ges", "as", "b" }; private static String[] DoubleSharps = { "cisis", "disis", "eisis", "fisis", "gisis", "aisis", "bisis" }; private static String[] DoubleFlats = { "ceses", "deses", "eses", "feses", "geses", "ases", "beses" }; public String resolveIn(int keys, bool isMajor) { int fAcc = Acc; int fs; int fNum; int numMod = Number % 7; fs = isMajor ? 6 : 3; fs = (fs - 2*numMod) % 7; if (fs <= 0) fs += 7; if (keys < 0) fs = 8 - fs; if (fs <= Math.Abs(keys)) fAcc += keys / Math.Abs(keys); fNum = (numMod + keys*4 - (isMajor ? 0 : 2)) % 7; if (fNum < 0) fNum += 7; switch (fAcc) { case -2: return DoubleFlats[fNum]; case -1: return Flats[fNum]; case 0: return Naturals[fNum]; case 1: return Sharps[fNum]; case 2: return DoubleSharps[fNum]; default: return ""; } }

बाकी सरल है: टॉन्सिलिटी को बदलने के संकेतों को जोड़ने की आवश्यकता को स्टेप सबट्रैक्शन ऑपरेटर द्वारा गणना की जाती है, और अंतिम ऊंचाई को लास्ट में रखा जाता है:

कन्वर्ट () और बाकी सब

 // class Degree public static String operator -(Degree a, Degree g) { int o; o = a.Number - g.Number; o = (int)Math.Round((double)o / 7.0); if (o > 0) return new String('\'', o); if (o < 0) return new String(',', -o); return ""; } // class PitchConsumer public String Convert(List<Pitch> pitches) { Pitch localLast = lastPitch; String accum; if ((int)lastPitch == 0) lastPitch = pitches[0]; pitches.Sort(); if (pitches.Count == 1) { accum = PitchToString(pitches[0], lastPitch); lastPitch = pitches[0]; } else { lastPitch = pitches[0]; accum = "<"; foreach (Pitch p in pitches) { if (accum.Length > 1) accum += " "; accum += PitchToString(p, localLast); localLast = p; } accum += ">"; } return accum; } private String PitchToString(Pitch p, Pitch last) { Degree g, glast; String note; g = PitchToGrade(p); glast = PitchToGrade(last); note = g.resolveIn(keys, isMajor); return note + (g - glast); }

निष्कर्ष

जटिलता मेरे इंतजार में थी, उस क्षेत्र में नहीं जहां मुझे यकीन नहीं था, लेकिन मेरी विशेषता का विषय क्या था। लेकिन अब मैं बेहतर तरीके से समझता हूं कि एक संगीत स्कूल में बच्चों के लिए यह कितना मुश्किल है :-)। और नोट मिलना वास्तव में तेज़ हो गया।

https://github.com/m0003r/LilyInput

हम मिडी-कीबोर्ड का उपयोग करके लिलीपोंड में टाइप करते हैं

मिडी-डॉट-नेट: मिडी के साथ काम करना

उपकरणों की सूची, खोलना और बंद करना

प्रसंस्करण पर क्लिक करें

हम संगीत के प्राथमिक सिद्धांत के पागल काटते हैं

निष्कर्ष

More articles: