🗽 🖥️ 🦉 मिडी वेवी: अरुडिनो और मिडी का उपयोग करके नियंत्रित संगीत संगीत बनाना 🕶️ 🐈 🎴

नमस्ते यह मैनुअल Arduino पर मिडी नियंत्रक (या किसी भी अनुक्रम में मिडी ट्रैक) के माध्यम से नियंत्रित रंग संगीत की विधानसभा प्रक्रिया का वर्णन करता है। प्रारंभ में, मैंने लाइव प्रदर्शन की कल्पना के लिए इस उपकरण को बनाया, ऑपरेशन के 2 मोड पेश किए गए हैं: मिडी ट्रैक का लाइव गेम और प्लेबैक।

लेख शुरुआती के लिए अभिप्रेत है - जो कुछ भी आवश्यक है उसे सुलभ तरीके से समझाया गया है, अधिक उन्नत लोग बस इस कार्यान्वयन विधि से खुद को परिचित कर सकते हैं, और, शायद, अपनी कला प्रतिष्ठानों को बनाने में इसका उपयोग करें या गतिशील प्रकाश नियंत्रण के लिए इसका उपयोग करें। प्रोग्रामिंग भाषाओं को जानना वैकल्पिक है।

सामग्री की तालिका

दृश्य मॉडल
घटकों
1. एलईडी रोशनी
2. एलईडी के साथ काम करने के लिए लाइब्रेरी
3. मिडी एमुलेटर और सीक्वेंसर
4. Arduino संचार - मिडी नियंत्रक
5. मिडी नियंत्रक
6. प्रोटोटाइप बोर्ड
रिफ्लेक्टर
सॉफ्टवेयर भाग
रिबन एनीमेशन उदाहरण
निष्कर्ष
डेमो वीडियो
फ़ाइलें

मिडी लहर में शामिल होंगे:

4 घर का बना एलईडी रोशनी,
संचार के लिए अलग-अलग लंबाई (50 और 30 सेमी) के 4 3-पिन कनेक्टर <-> माइक्रोकंट्रोलर,
माइक्रोकंट्रोलर (उदा। आर्डिनो),
ब्रेडबोर्ड (काफी छोटा)
किसी भी MIDI नियंत्रक
एमुलेटर (अर्थात् - एब्लेटन लाइव + लूप 1)

Model 1. दृश्य मॉडल

एक कुंजी दबाने से पथ एल ई डी प्रकाश अप करने के लिए:

मिडी नियंत्रक → एबलटन लाइव (ASIO के साथ) → लूपबी 1 → हेयरलेस मिडी <-> सीरियल ब्रिज → अरुडिनो → एलईडी टॉर्च

एक MIDI नियंत्रक के बजाय, आप कंप्यूटर कीबोर्ड को सीक्वेंसर में उपयोग कर सकते हैं।

§ 2. अवयव

§ 2.1। एलईडी रोशनी

टॉर्च 5050 एलईडी पट्टी के साथ एक WS2811 चिप , 5 डायोड प्रति टॉर्च से बना है। WS2811 आपको प्रत्येक एलईडी को अलग से नियंत्रित करने की अनुमति देता है, इसके अलावा, कैपेसिटर के साथ टेप कारखाने में पहले से ही सोल्डर किया गया है, और आउटपुट में हमारे पास 3 पिन डीआईएन , 5 वी , जीएनडी है । इसे बिना सुरक्षा के और पारदर्शी पारदर्शी सिलिकॉन केस के साथ बेचा जाता है। डिवाइस की एक प्रस्तुत करने योग्य उपस्थिति बनाने के लिए, 3-पिन कनेक्टर्स का उपयोग करना सबसे अच्छा है। वे उपयोग करने के लिए सुविधाजनक हैं, सिस्टम से एलईडी को हटाने को सरल करते हैं।

(उदाहरण के लिए, "इमदादी 15 सेमी जेआर 3 डीपी के लिए एक्सटेंशन कॉर्ड। स्वाद के लिए लंबाई चुनने के लिए)

§ 2.2। एलईडी के साथ काम करने के लिए लाइब्रेरी

Arduino के स्केच में, हम FastLED लाइब्रेरी को कनेक्ट करते हैं। दिलचस्प प्रलेखन के साथ खुद को परिचित करने की सिफारिश की जाती है, जहां आप रंग कोड और अन्य उपयोगी जानकारी पा सकते हैं।

पहली बार, मुझे नीचे दिखाए गए जैसे कुछ मिला। सभी रोशनी को मिलाते हुए, आपको काम के लिए हर एक को जांचना होगा:

एलईडी परीक्षण के लिए Arduino स्केच दिखाएं

#include "FastLED.h" #define NUM_LEDS 5 // 5  #define DATA_PIN 6 // 6-     DIN   ( ) //     CRGB leds[NUM_LEDS]; void setup() { FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS); //  } void loop() { FastLED.showColor(CHSV(190,255,255)); //      }

(यह एक जादू कनेक्टर के बिना टॉर्च का एक पुराना संस्करण है, बस Arduino सेट से तारों को मिलाया जाता है, लेकिन इसका अर्थ इससे नहीं बदलता है)

§ 2.3। मिडी एमुलेटर और सीक्वेंसर

जब हम वास्तविक समय में प्रकाश की तस्वीर में परिवर्तन को नियंत्रित करने के लिए या रिकॉर्ड किए गए परिवर्तन को वापस करने के लिए एक सीक्वेंसर (एबलटन लाइव) को कनेक्ट करना चाहते हैं, तो एक एमुलेटर की आवश्यकता होती है। कोई भी करेगा, लेकिन मैंने LoopBe1 (http://www.nerds.de/en/loopbe1.html) लिया। स्थापित करें, रिबूट करें, सीक्वेंसर खोलें। सीक्वेंसर स्थापित करने का सार यह है कि सीक्वेंसर से आउटपुट को एक वर्चुअल मिडी चैनल में बनाया जाए, ताकि बाद में इस चैनल को Arduino से जोड़ा जा सके।

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

सीक्वेंसर सेटिंग दिखाएं

सीक्वेंसर में हम 2 मिडी ट्रैक बनाते हैं। पहले पर - हम कोई भी सिंथेसाइज़र लगाते हैं (मैं ड्रम रैक की सलाह देता हूं, क्योंकि आप मुख्य नामों को आसानी से कॉन्फ़िगर कर सकते हैं, जो इस सब को आसानी से नेविगेट करने में मदद करेगा), फिर उस पर MUTE करें (आप इसे वास्तव में नहीं कर सकते हैं यदि आप इस ट्रैक पर सीधे काम करना चाहते हैं) , और दूसरा खाली छोड़ दें, निम्नलिखित सेटिंग करें:

हम I / O बटन को सक्रिय करते हैं (आकृति में चरण 2), दूसरे ट्रैक सेटिंग्स (चरण 1) सेट करें।

मिडी फ्रॉम: 1-ड्रम रैक (निर्दिष्ट करें कि पहले ट्रैक से "सिग्नल कहां ले जाएं")।
प्री एफएक्स (किसी भी मूल्य संभव है, लेकिन प्री एफएक्स का उपयोग किया जाता है ताकि पहले डॉर्क से प्रभाव एक साथ दूसरे के साथ जाए। इंटरनेट पर अधिक पढ़ना बेहतर होता है, इस कार्य में कोई फर्क नहीं पड़ता)।
मॉनिटर: ऑटो
मिडी टू: लूपबी इंटरनल मिडी (मिडी एमुलेटर का नाम चुनें)
Ch: 1. (डिफ़ॉल्ट रूप से, 1 (पहला) चैनल का उपयोग किया जाता है। कुल 16 चैनल उपलब्ध हैं, यानी मिडी संदेशों (नोट) की 16 परतों के रूप में। यह अधिक जटिल एलईडी नियंत्रण प्रणाली बनाते समय विभिन्न चैनलों का उपयोग करने के लिए उपयोगी है)।

CTRL बटन दबाए रखें और दोनों ट्रैक को सक्रिय करें (आकृति में बिंदु 3)। हो गया। आंकड़े में बिंदु 4 पर ध्यान दें, यह वही है जो मैंने बात की थी, फिर इसके साथ काम करना सुविधाजनक होगा। उदाहरण के लिए, नोट संपादक के माध्यम से।

ऊपर दिए गए चित्र में, क्षेत्र 4 में प्रस्तुत नोट मैप के समान, निम्नानुसार प्राप्त किया जा सकता है: ड्रम रैक सेल में किसी भी ऑडियो फ़ाइल को ड्रॉप करें (मैंने किकवॉव का उपयोग किया था), उस पर राइट-क्लिक करें, "नाम बदलें" (या CTRL) + आर)।

वैकल्पिक: ASIO ड्राइवर

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

आप इसे आधिकारिक वेबसाइट पर , सार्वजनिक डोमेन में पा सकते हैं।

मिडी ट्रैक बनाना

↑ चलो व्यवस्था मोड पर जाएं, आंकड़ा 2 में कोई भी विकल्प अधिक महंगी एलईडी पर नहीं होना चाहिए, अन्यथा मिडी क्लिप नहीं बनाई जा सकती है। ज़ोन का चयन करें और एक नई क्लिप बनाएं।

↑ नोट्स जोड़ें। उदाहरण के लिए, ऊपर का आंकड़ा LEFT_LONG टेप पर एल ई डी के वैकल्पिक सक्रियण को दर्शाता है। जैसे ही नोट समाप्त होता है, एलईडी तुरंत बंद हो जाता है। यह एक दिशा में टेप की एक तेज झिलमिलाहट को बदल देता है:

↑ नोटों को बढ़ाते हुए, आप एक लूप बना सकते हैं, जो केवल काम करने वाले एलईडी वैकल्पिक उपकरणों को बदलने की तुलना में आंख पर चिंतन करने के लिए अधिक सुखद है:

प्रति मिनट बीट्स के मूल्य को बदलकर, आप ट्रैक की गति को बदल सकते हैं:

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

Arduino संचार - मिडी नियंत्रक

हेयरलेस-मिडीसिरियल प्रोग्राम (http://projectgus.github.io/hairless-midiserial/) का उपयोग करके , एक सीरियल बनाएं <-> MIDI ब्रिज (एमुलेटर से कंट्रोलर / कंट्रोलर को सीरियल पोर्ट के माध्यम से प्रेषित किया जाएगा):

जैसा कि आप देख सकते हैं, मिडी इन पुल का प्रवेश द्वार है, सीरियल पोर्ट पुल से आर्डिनो तक का निकास है। इस सेटिंग में, आप किसी भी MIDI कंट्रोलर को सीधे कनेक्ट कर सकते हैं, उदाहरण के लिए एक MIDI कीबोर्ड, लेकिन ईमानदार होने के लिए, मैं सीधे कीबोर्ड के साथ काम नहीं करना चाहता, जाहिर है मुझे कुछ विशेष चाहिए। आवेदन, हम जल्द से जल्द इससे निपटेंगे, लेकिन मिडी + सीक्वेंसर के माध्यम से प्रकाश को नियंत्रित करना अधिक सुविधाजनक है। Minuses की - सीक्वेंसर प्रोग्राम काफी धीरे-धीरे लोड हो सकता है।

§ 2.4। मिडी नियंत्रक

बिल्कुल (आपके कार्यों के आधार पर, निश्चित रूप से) नियंत्रक जिसे एक संगीत की दुकान पर खरीदा जा सकता है या अपने आप से इकट्ठा किया जा सकता है (इंटरनेट पर निर्देश हैं कि यह कैसे किया जाए)। और अगर आप इलेक्ट्रॉनिक संगीत लिखते हैं, तो आपके पास शायद ऐसा कोई कीबोर्ड है। आप ट्विस्ट और चाबी दोनों का उपयोग कर सकते हैं। प्रत्येक कुंजी (नोट) कुछ कमांड्स के निष्पादन को "लटका", इसी तरह ट्विस्ट के साथ। इस उदाहरण में, 3 ट्विस्ट का उपयोग किया जाता है (मास्टर, रंग, विलंब द्वारा चिह्नित) और चार ऑक्टेव नोट।

एबलटन, एफएल स्टूडियो, आदि में। आप मिडी नियंत्रक के बिना कर सकते हैं। इन कार्यक्रमों में, आप पियानो की तरह एक नियमित पीसी कीबोर्ड का उपयोग कर सकते हैं।

§ 2.5। प्रोटोटाइप बोर्ड

एक प्रोटोटाइप डिवाइस के लिए, एक छोटे ब्रेडबोर्ड पर सब कुछ कनेक्ट करना पर्याप्त है। भविष्य में, ब्रेडबोर्ड को एक मुद्रित सर्किट बोर्ड (सभी मिलाप की जरूरत है - यह गिर नहीं होगा) के साथ बदलना मुश्किल नहीं होगा। डिवाइस के मामले आर्डिनो या रेडियो उपकरण, एल्यूमीनियम के साथ कुछ दुकानों में हैं, आकार के आधार पर ~ 300 आर से लागत।

सोल्डरलेस ब्रेडबोर्ड SYB-170 10x17 छेद 60 आर ; एल्यूमीनियम का मामला 100 * 76 * 35 मिमी, सोना। 300 पी ।

§ 3. रिफ्लेक्टर

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

विभिन्न बनावट वाले रिफ्लेक्टर हैं जो विकिरण के आकार को प्रभावित करते हैं, लेकिन हम उन पर विचार नहीं करेंगे।

§ 4. सॉफ्टवेयर भाग

आइए Arduino के स्केच का विश्लेषण करें

सबसे पहले, हम आवश्यक पुस्तकालयों को जोड़ेंगे, सभी प्रकारों के लिए बाइट प्रकार सेट करेंगे (0 से 255 तक स्टोर, हमें केवल मूल्यों की आवश्यकता है, हम बाकी का उपयोग नहीं कर सकते हैं):

शो कोड, भाग 1

 // MIDI Wavy // JVLNS.ORG 2014 //      #include "FastLED.h" //     ,    #define LEFT_LONG 7 #define LEFT_SHORT 6 #define RIGHT_SHORT 5 #define RIGHT_LONG 4 #define NUM_STRIPS 4 //   #define NUM_LEDS_PER_STRIP 5 //    1  //       CRGB leds[NUM_STRIPS][NUM_LEDS_PER_STRIP]; //     ,      byte colors[] = {0, 32, 64, 96, 128, 160, 192, 224, 239 }; //    Master () - byte ColorBasic = 0; byte Master = 255; byte commandByte; //   MIDI-,      (noteOn, noteOff, Controller) byte noteByte; //  ( ) byte velocityByte; //   —  (  noteOn/Off   velocity (https://www.ableton.com/en/manual/editing-midi-notes-and-velocities),   Controller —   ). byte velocityByte1; //   map()  0-127  0-255 byte noteOn = 144; //   byte noteOff = 128; //   byte faza = 0; //       delay(faza)

दीपक का पदनाम:

(नोट: 0, 1, 2, 3 - सरणी में सेल नंबर)

कोड, भाग 2. हम सेटअप () फ़ंक्शन सेट करते हैं :

 void setup() { //  Serial-   256000 Serial.begin(256000); FastLED.addLeds<NEOPIXEL, LEFT_LONG>(leds[0], NUM_LEDS_PER_STRIP); FastLED.addLeds<NEOPIXEL, LEFT_SHORT>(leds[1], NUM_LEDS_PER_STRIP); FastLED.addLeds<NEOPIXEL, RIGHT_SHORT>(leds[2], NUM_LEDS_PER_STRIP); FastLED.addLeds<NEOPIXEL, RIGHT_LONG>(leds[3], NUM_LEDS_PER_STRIP); }

एलईडी स्ट्रिप्स को नामित करने की इस पद्धति को एक साथ प्रत्येक पट्टी को स्वतंत्र रूप से नियंत्रित करने की आवश्यकता है। FastLED लाइब्रेरी के लिए प्रलेखन पृष्ठ पर और पढ़ें।

तथ्य यह है कि 8-बिट नियंत्रक मल्टीथ्रेडिंग का समर्थन नहीं करते हैं, कोड को क्रमिक रूप से निष्पादित किया जाता है। कोड का ढेर इसके निष्पादन को धीमा कर देता है। एल ई डी के साथ जुड़ने और काम करने की यह विधि (हम बाद में विचार करेंगे) इस समस्या को हल करती है, कार्यक्रम कम हो जाता है, और इसलिए, प्रत्येक कीस्ट्रोक को ध्यान में रखा जाएगा (अनुभव से मैं कहता हूं कि मैंने इसे पहले अलग किया था और नोट के पारित होने के साथ बहुत सारे जाम थे। गणना में देरी या कमी के कारण)। इसके अलावा, एल ई डी के गुणों को बदलना इस पद्धति के साथ बहुत अधिक सुविधाजनक है।

हम सीरियल पोर्ट लॉन्च करते हैं जिसके माध्यम से माइक्रोकंट्रोलर कंप्यूटर के साथ संचार करेगा। हम 256000 निर्दिष्ट करते हैं। हेयरलेस ब्रिज सेटिंग्स में हम उसी गति को निर्दिष्ट करते हैं।

आइए कुछ ऐसे फंक्शन्स बनाएं जो एल ई डी को कुछ सेटिंग्स के साथ चालू और बंद करेंगे:

कोड दिखाएं, भाग 3

 // pointer()           // num_strip =   ( 0  3,    [ ]) // num_led =       num_strip // master =   // color =  void pointer(byte num_strip, byte num_led, byte master, byte color) { leds[num_strip][num_led] = CHSV(color, 255, master); FastLED.show(); } // blackout()           void blackout(byte num_strip, byte num_led) { leds[num_strip][num_led] = CHSV(0, 0, 0); FastLED.show(); }

मिडी कमांड के साथ काम करने के कार्य को परिभाषित करें:

शो कोड, भाग 4

 void checkMIDI(){ do{ //   3   if (Serial.available()){ commandByte = Serial.read();//read first byte noteByte = Serial.read();//read next byte velocityByte1 = Serial.read();//read final byte velocityByte = map(velocityByte1, 0, 127, 0, 255); Master = velocityByte; //  Master   Velocity  //     if(noteByte == 96) ColorBasic = colors[0]; if(noteByte == 97) ColorBasic = colors[1]; if(noteByte == 98) ColorBasic = colors[2]; if(noteByte == 99) ColorBasic = colors[3]; if(noteByte == 100) ColorBasic = colors[4]; if(noteByte == 101) ColorBasic = colors[5]; if(noteByte == 102) ColorBasic = colors[6]; if(noteByte == 103) ColorBasic = colors[7]; if(noteByte == 104) ColorBasic = colors[8]; //  if (commandByte == 176 && noteByte == 22)ColorBasic = velocityByte; // Color if(commandByte == 176 && noteByte == 21) Master = velocityByte; // Master if(commandByte == 176 && noteByte == 23) faza = velocityByte; // Velocity // LEFT_LONG if(noteByte == 36) { //C1 if(commandByte == noteOn) pointer(0, 0, Master, ColorBasic); else if(commandByte == noteOff) blackout(0, 0); } if(noteByte == 38) { if(commandByte == noteOn) pointer(0, 1, Master, ColorBasic); else if(commandByte == noteOff) blackout(0, 1); } if(noteByte == 40) { if(commandByte == noteOn) pointer(0, 2, Master, ColorBasic); else if(commandByte == noteOff) blackout(0, 2); } if(noteByte == 41) { if(commandByte == noteOn) pointer(0, 3, Master, ColorBasic); else if(commandByte == noteOff) blackout(0, 3); } if(noteByte == 43) { if(commandByte == noteOn) pointer(0, 4, Master, ColorBasic); else if(commandByte == noteOff) blackout(0, 4); } // end left_long // LEFT_SHORT if(noteByte == 45) { if(commandByte == noteOn) pointer(1, 0, Master, ColorBasic); else if(commandByte == noteOff) blackout(1, 0); } if(noteByte == 47) { if(commandByte == noteOn) pointer(1, 1, Master, ColorBasic); else if(commandByte == noteOff) blackout(1, 1); } if(noteByte == 48) { if(commandByte == noteOn) pointer(1, 2, Master, ColorBasic); else if(commandByte == noteOff) blackout(1, 2); } if(noteByte == 50) { if(commandByte == noteOn) pointer(1, 3, Master, ColorBasic); else if(commandByte == noteOff) blackout(1, 3); } if(noteByte == 52) { if(commandByte == noteOn) pointer(1, 4, Master, ColorBasic); else if(commandByte == noteOff) blackout(1, 4); } // end left_short // RIGHT_SHORT if(noteByte == 53) { if(commandByte == noteOn) pointer(2, 0, Master, ColorBasic); else if(commandByte == noteOff) blackout(2, 0); } if(noteByte == 55) { if(commandByte == noteOn) pointer(2, 1, Master, ColorBasic); else if(commandByte == noteOff) blackout(2, 1); } if(noteByte == 57) { if(commandByte == noteOn) pointer(2, 2, Master, ColorBasic); else if(commandByte == noteOff) blackout(2, 2); } if(noteByte == 59) { if(commandByte == noteOn) pointer(2, 3, Master, ColorBasic); else if(commandByte == noteOff) blackout(2, 3); } if(noteByte == 60) { if(commandByte == noteOn) pointer(2, 4, Master, ColorBasic); else if(commandByte == noteOff) blackout(2, 4); } // end right_short // RIGHT_LONG if(noteByte == 62) if(commandByte == noteOn) pointer(3, 0, Master, ColorBasic); else if(commandByte == noteOff) blackout(3, 0); } if(noteByte == 64) { if(commandByte == noteOn) pointer(3, 1, Master, ColorBasic); else if(commandByte == noteOff) blackout(3, 1); } if(noteByte == 65) { if(commandByte == noteOn) pointer(3, 2, Master, ColorBasic); else if(commandByte == noteOff) blackout(3, 2); } if(noteByte == 67) { if(commandByte == noteOn) pointer(3, 3, Master, ColorBasic); else if(commandByte == noteOff) blackout(3, 3); } if(noteByte == 69) { if(commandByte == noteOn) pointer(3, 4, Master, ColorBasic); else if(commandByte == noteOff) blackout(3, 4); } // end right_long if(noteByte == 72) { //  C4,  LEFT_LONG   if(commandByte == noteOn) { for(byte i = 0; i < NUM_LEDS_PER_STRIP; i++) pointer(0, i, Master, ColorBasic); } else if(commandByte == noteOff) { //   —   for(byte i = 0; i < NUM_LEDS_PER_STRIP; i++) blackout(0, i); } } if(noteByte == 74) { //  LEFT_SHORT   if(commandByte == noteOn) { for(byte i = 0; i < NUM_LEDS_PER_STRIP; i++) pointer(1, i, Master, ColorBasic); } else if(commandByte == noteOff) { for(byte i = 0; i < NUM_LEDS_PER_STRIP; i++) blackout(1, i); } } if(noteByte == 76) { //  RIGHT_SHORT   if(commandByte == noteOn) { for(byte i = 0; i < NUM_LEDS_PER_STRIP; i++) pointer(2, i, Master, ColorBasic); } else if(commandByte == noteOff) { for(byte i = 0; i < NUM_LEDS_PER_STRIP; i++) blackout(2, i); } } if(noteByte == 77) { //  RIGHT_LONG   if(commandByte == noteOn) { for(byte i = 0; i < NUM_LEDS_PER_STRIP; i++) pointer(3, i, Master, ColorBasic); } else if(commandByte == noteOff) { for(byte i = 0; i < NUM_LEDS_PER_STRIP; i++) blackout(3, i); } } // ,    if(noteByte == 37) { for(byte x = 0; x < NUM_STRIPS; x++) { // This inner loop will go over each led in the current strip, one at a time for(byte i = 0; i < NUM_LEDS_PER_STRIP; i++) { leds[x][i] = CRGB::Black; FastLED.show(); } } } //   if(noteByte == 73){ if(commandByte == noteOn) { for(byte x = 0; x < NUM_STRIPS; x++) { for(byte i = 0; i < NUM_LEDS_PER_STRIP; i++) { leds[x][i] = CHSV(ColorBasic, 255, 255); FastLED.show(); leds[x][i] = CRGB::Black; delay(faza); //      Delay } } } // end Note ON else if(commandByte == noteOff) { for(byte i = 0; i < NUM_LEDS_PER_STRIP; i++) blackout(3, i); } }// end note On // end noteByte 73 //          faza  ,    i  . if(noteByte == 75 && commandByte == noteOn) { faza = map(faza, 0, 200, 0, 3); for(byte i = 255; i > 0; i--) { FastLED.showColor(CHSV(ColorBasic, 255, i)); delay(faza); } } }// end if }// end do while (Serial.available() > 2);//   3  }

कोड पर टिप्पणियाँ: जैसा कि आपने देखा, जब एक कुंजी को दबाया जाता है, तो एक निश्चित एलईडी लाइट्स, कई एक साथ परिभाषित कुंजी एक ठोस चमक देगी, उदाहरण के लिए, टेप में से एक, जब तक कि कुंजी जारी नहीं की जाती है। यह आपको एक एलईडी से दूसरे में चिकनी बदलाव बनाने की अनुमति देता है, एक लूप बनाता है।

ऐसा होता है कि एलईडी लटका हुआ है और बंद नहीं होता है, इसके लिए हमने 37 "RESET, TURN OFF ALL LED" नोट को सौंपा।

मिडी कमांडों में मान यहां से लिए जा सकते हैं (http://www.midi.org/techspecs/midimessages.php) , या सीधे हिरन-मिसेरीअल में दबाए गए कुंजी को ट्रैक करें:

आप (लेकिन जरूरी नहीं) एक और फ़ंक्शन जोड़ सकते हैं - रंग में सभी एल ई डी का एक सरल आधान। तब डिवाइस को एक रात के प्रकाश के रूप में इस्तेमाल किया जा सकता है:

 void Rainbow(int delay_time) { for(int hue = 0; hue < 255; hue++) { FastLED.showColor(CHSV(hue,255,255)); delay(delay_time); } }

कोड, भाग 5. और अंतिम स्पर्श, हम लूप सेट करते हैं () फ़ंक्शन:

 void loop(){ //     MIDI checkMIDI(); //      .    ,     .   - ,     ,      . delay(50); }

§ 5. टेप एनिमेशन का उदाहरण

लहर

MIDI फ़ाइल डाउनलोड करें

"लंबे समय तक" आप जो नोट दबाते / चिपकाते हैं, वह चित्र भूत प्रभाव के कारण अधिक धुंधला होता है:

एक उदाहरण पर विचार करें।

हम कई बार नोटों की नकल करते हैं, और हर बार वेलोसिटी नोट्स को एक निश्चित स्तर तक कम करते हैं, 25% कहते हैं। इस स्थिति में, आप पूंछ को अधिक सटीक रूप से निर्दिष्ट कर सकते हैं:

§ 6. निष्कर्ष

§ 6.1। मूल्य का मुद्दा

इस तरह के एक एलईडी की लागत लगभग 17 रूबल है, हमें इनमें से 20 => 340 आर की आवश्यकता है ।
Arduino (सबसे सस्ता में से एक चुना) 400 ~~आर।~~
कनेक्टर्स 4 पीसी - मुझे ठीक से याद नहीं है, लगभग 100 पी बाहर आया था।
विकास बोर्ड - 60 ~~आर।~~
कुल: 908 पी (Arduino सेट से तारों को छोड़कर)

सबसे महंगी एलईडी और एक माइक्रोकंट्रोलर हैं। सामान्य तौर पर, यदि आप विषय में हैं, तो आर्डिनो के संदर्भ में आप सस्ती चीजों का उपयोग कर सकते हैं।

§ 6.2। आवेदन का क्षेत्र

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

मैं अपनी बाइक की बैकलाइट में मिडी कंट्रोलर के बिना एक सरलीकृत नियंत्रण विकल्प का उपयोग करता हूं, लेकिन बाद में उस पर और अधिक।

आप पियानो बजाना सीखने के लिए इस मामले को मोड़ सकते हैं, या आप अपने बच्चे की प्रोग्रामिंग को रंग सकते हैं, या उसकी याददाश्त में सुधार कर सकते हैं (हालांकि इस तरह के खिलौने दुकानों में बेचे जाते हैं और वे बहुत अधिक कॉम्पैक्ट होते हैं, लेकिन हम आसान तरीके नहीं खोज रहे हैं)।

यदि आप रुचि रखते हैं, तो मैं आपके प्रयासों में आपको शुभकामनाएं देता हूं! अपने काम का लिंक ज़रूर भेजें।

मिडी वेवी: अरुडिनो और मिडी का उपयोग करके नियंत्रित संगीत संगीत बनाना