"क्रीपिंग लाइन" - एलईडी मैट्रिक्स RL-M2388 और Arduino Mega के उदाहरण पर गतिशील संकेत

यह आलेख एलईडी मैट्रिक्स पर जानकारी प्रदर्शित करने और स्क्रॉल करने के लिए एकमात्र संभव विधि के रूप में व्याख्या किए जाने का दावा नहीं करता है। विधि / कार्यों में सुधार के लिए आपकी टिप्पणियों और सुझावों को सुनकर मुझे खुशी होगी। यह लेख व्यक्तिगत अनुभव और मेरे द्वारा प्राप्त किए गए परिणाम का विवरण है।

सिद्धांत की बिट

इस एलईडी मैट्रिक्स में 64 लाल एलईडी शामिल हैं। यदि आप प्रत्येक एलईडी के संपर्कों को अलग-अलग प्रदर्शित करते हैं, तो आपको मैट्रिक्स आवास पर 64 संपर्कों और 65 डिजिटल इनपुट / आउटपुट पोर्ट के साथ एक माइक्रोकंट्रोलर की आवश्यकता होगी। यह अव्यावहारिक और नुकसानदेह है। इसलिए, कारखाने में, एल ई डी को विभिन्न आकारों के मैट्रीस (हमारे मामले में, 8x8) में जोड़ दिया जाता है, जो कि पंक्तियों और स्तंभों के अनुसार 8 समूहों में निम्नानुसार है:


इस मामले में, हमें केवल 16 डिजिटल इनपुट / आउटपुट की आवश्यकता है। उदाहरण के लिए, ऊपरी बाएं कोने में एलईडी को प्रकाश में लाने के लिए, हमें pin13 पर 1 (चित्र देखें) पर लॉग इन करना होगा, और pin9 पर 0 लॉग इन करना होगा। इस प्रदर्शन विधि को स्थैतिक संकेत कहा जाता है।

"ठीक है, और यदि, उदाहरण के लिए, हमें मैट्रिक्स के विभिन्न पदों में कई एलईडी को प्रकाश में लाने की आवश्यकता है, और बाकी सभी को छोड़ दें?" - आप पूछें एक स्थिर प्रदर्शन के साथ, यह संभव नहीं है। ऐसा करने के लिए, गतिशील प्रदर्शन का उपयोग करें।

गतिशील संकेत

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

डायनेमिक डिस्प्ले मैट्रिसेस को प्रोग्रामिंग करते समय देखी जाने वाली परिस्थितियाँ:
1. प्रत्येक स्तंभ / पंक्ति ("पिक्सेल" मेरे मामले में) के प्रदर्शन की अवधि स्थिर है, सभी कॉलम / पंक्तियों (मेरे मामले में "पिक्सेल") के लिए समान है।
2. बदलते कॉलम / पंक्तियों की आवृत्ति ("पिक्सेल" मेरे मामले में) नहीं बदलती है।

माइक्रोकंट्रोलर फर्मवेयर के संचालन का सिद्धांत

मैं मानता हूं, जब मुझे एटमेगा 1280 एमके और एक एलईडी मैट्रिक्स पर एक डिबग बोर्ड मिला, तो मुझे नहीं पता था कि एक गतिशील प्रदर्शन क्या है और इसके लिए क्या है। मुझे परीक्षण विधि और "भाला" विधि द्वारा इसके उपयोग की आवश्यकता की समझ में आया।

फर्मवेयर के संचालन का सिद्धांत:

1. स्क्रीन पर एक चरित्र प्रदर्शित करें

आइए कल्पना करें कि हमारा एलईडी मैट्रिक्स जे पर आयाम का एक दो आयामी सरणी है, जो हमारे मैट्रिक्स के आयाम के साथ मेल खाता है। हमारे मामले में, यह 8 से 8 पिक्सेल है। तो, टाइप बूलियन का एक दो आयामी सरणी है। उदाहरण के लिए:

boolean A[8][8] = {0,0,1,1,1,1,0,0, 0,1,0,0,0,0,1,0, 0,1,0,0,0,0,1,0, 0,1,0,0,0,0,1,0, 0,1,1,1,1,1,1,0, 0,1,0,0,0,0,1,0, 0,1,0,0,0,0,1,0, 0,1,0,0,0,0,1,0} 

लूप में, हम जांचते हैं कि एरे तत्व ए [i] [जे] = 1 है, तो स्थिति में स्थित मैट्रिक्स पर एलईडी चालू करें (I; J), एलईडी डिस्प्ले को रोकें और एलईडी को स्थिति में बंद करें (I; J)। इस एल्गोरिथ्म का उपयोग करते हुए कार्यक्रम के परिणामस्वरूप, प्रतीक "ए" मैट्रिक्स स्क्रीन पर प्रदर्शित किया जाएगा (यह प्रतीक दो आयामी सरणी में प्रदर्शित किया गया है)। हम इस एल्गोरिथ्म को "स्क्रीन आउटपुट" कहते हैं । तो, एक गतिशील प्रदर्शन का उपयोग कर स्क्रीन पर जानकारी के प्रदर्शन के साथ लगा।

2. स्क्रीन पर स्क्रॉल करने की जानकारी

बेशक, यह स्क्रीन पर अभी भी जानकारी प्रदर्शित करने के लिए अच्छा है, लेकिन इसे स्थानांतरित करने के लिए - इसे "पुनर्जीवित" करना अधिक दिलचस्प होगा। चलती जानकारी के लिए एल्गोरिथ्म पर विचार करें:

एक अनंत लूप में, निष्पादित करें:
1. हम "स्क्रीन डिस्प्ले" एल्गोरिथ्म कहते हैं।
2. हम मैट्रिक्स ए के 1 कॉलम को लेते हैं और इसे बफर (दो-आयामी सरणी BUFFER [8] [1]) पर लिखते हैं।
3. हम मैट्रिक्स की सामग्री को A [i] [j + 1] से स्थिति A [i] [j] से लिखते हैं। यही है, हम अनिवार्य रूप से एक कॉलम द्वारा बाईं ओर मैट्रिक्स को "स्थानांतरित" करते हैं।
4. हम मैट्रिक्स A के अंतिम कॉलम में BUFFER बफर की सामग्री लिखते हैं (फ्री कॉलम में, क्योंकि हमने मैट्रिक्स को बाईं ओर एक कॉलम में स्थानांतरित किया है)। हम इस एल्गोरिथ्म को "स्क्रॉलिंग सूचना" कहेंगे।

यह पूरी स्क्रीन स्क्रॉलिंग एल्गोरिथ्म है। अब, गतिशील संकेतकों का उपयोग करके जानकारी प्रदर्शित करने और स्क्रॉल करने के लिए एल्गोरिदम को जानना, हम अभ्यास करना शुरू कर सकते हैं।

मैट्रिक्स को डीबग बोर्ड से कनेक्ट करना

मैट्रिक्स के 16 पिंस में से प्रत्येक को गिना जाता है। इन संख्याओं के अनुसार, पंक्तियों के लिए जिम्मेदार 8 संपर्क और स्तंभों के लिए जिम्मेदार 8 संपर्क मिलाप और आउटपुट थे। उदाहरण के लिए, मेरे पास इस तरह से जुड़ा हुआ एक मैट्रिक्स है:

निष्कर्ष जो लाइनों के लिए जिम्मेदार हैं 23,25,27,29,31,33,35,37, माइक्रोकंट्रोलर के पैरों के निष्कर्षों की संख्या हैं;
जो निष्कर्ष 39,41,43,45,47,49,51,53 कॉलम के लिए जिम्मेदार हैं, वे माइक्रोकंट्रोलर के पैरों के निष्कर्षों की संख्या हैं।

प्रोग्रामिंग

माइक्रोकंट्रोलर को Arduino IDE विकास वातावरण में क्रमादेशित और फ्लैश किया जाता है।

नीचे लिखे प्रोग्राम कोड को समझने के लिए आपको क्या जानना चाहिए:

पिनमोड () फ़ंक्शन
इनपुट या आउटपुट के रूप में किसी दिए गए इनपुट / आउटपुट (पिन) के ऑपरेशन मोड को सेट करता है।
pinMode (पिन, मोड), जहां पिन: इनपुट / आउटपुट (पिन) की संख्या जिसे आप सेट करना चाहते हैं; मोड: दो मानों में से एक मोड - INPUT या OUTPUT, क्रमशः इनपुट या आउटपुट सेट करता है।

DigitalWrite () फ़ंक्शन
एक डिजिटल इनपुट / आउटपुट (पिन) के लिए एक उच्च या कम मूल्य भेजता है।
digitalWrite (पिन, मान), जहां पिन: इनपुट / आउटपुट नंबर (पिन); मूल्य: उच्च या कम

DelayMicroseconds () फ़ंक्शन
पैरामीटर में निर्दिष्ट माइक्रोसेकंड की संख्या के लिए स्टॉप प्रोग्राम निष्पादन (1 सेकंड में 1,000,000 माइक्रोसेकंड)।
देरीमाइक्रोसेकंड (हमें), जहां हमें: कार्यक्रम को रोका गया माइक्रोसेकंड की संख्या। (अहस्ताक्षरित int)

किसी भी प्रोग्राम की संरचना (स्केच, चूंकि एक arduino प्रोग्राम के विकास के माहौल में उस तरह से कहा जाता है) में निम्न रूप है:

 void setup() { … } void loop() { … } 

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

चलो माइक्रोकंट्रोलर के आउटपुट को कॉन्फ़िगर करते हैं। I / O पोर्ट स्टेटस दो प्रकार के होते हैं: इनपुट या आउटपुट के लिए कॉन्फ़िगर किया गया। हमारे मामले में, आपको आउटपुट कॉन्फ़िगर करने की आवश्यकता है।

 const int row[8]={23,25,27,29,31,33,35,37}; //  8 ,     const int col[8]={39,41,43,45,47,49,51,53}; // ?    . void setup() { for (int i=0; i<8; i++) { pinMode(row[i],OUTPUT); //        « » pinMode(col[i],OUTPUT); //    } for (int i=0; i<8; i++) { digitalWrite(row[i],HIGH); } } 

आइए अब ऊपर वर्णित एल्गोरिदम को लागू करें। तो हमारे पास दो आयामी सरणी है:

 boolean A[8][8] = {0,0,1,1,1,1,0,0, 0,1,0,0,0,0,1,0, 0,1,0,0,0,0,1,0, 0,1,0,0,0,0,1,0, 0,1,1,1,1,1,1,0, 0,1,0,0,0,0,1,0, 0,1,0,0,0,0,1,0, 0,1,0,0,0,0,1,0} 

हम एक फ़ंक्शन लिखेंगे जो "स्क्रीन डिस्प्ले" एल्गोरिदम को लागू करता है।

 int v=3; //  .             int dms=400; //  «».   ,      .   ,        void paint(boolean screen[8][8], int v) //       v { int i, j; for (int c=0; c <v; c ++) //       { for (i=0; i<8; i++) for (j=0; j<8; j++) { if (screen[i][j]= =1) //    = 1 { digitalWrite(row[i], LOW); digitalWrite(col[j], HIGH); delayMicroseconds(dms); digitalWrite(row[i], HIGH); digitalWrite(col[j], LOW); //      ,  ,  . } else { digitalWrite(row[i], HIGH); digitalWrite(col[j], LOW); delayMicroseconds(dms); digitalWrite(row[i], HIGH); digitalWrite(col[j], LOW); } //      ,  ,  . (        ,      «»  ,          .    1 –   ,    0 –    -    ,      ) } } } 

हम एक फ़ंक्शन लिखेंगे जो "सूचना स्क्रॉलिंग" एल्गोरिथ्म को लागू करता है।

 void scroll(boolean screen[8][8]) //        { boolean buf[8][1]; for (int i=0; i<8; i++) { buf[i][0]=screen[i][0]; //  1    } for (int i=0; i<8; i++) for (int j=0; j<8; j++) { screen[i][j]=screen[i][j+1]; //       } for (int i=0; i<8; i++) { screen[i][8-1]=buf[i][0]; //    ( )    } } 

अब मैं पूरा कार्यक्रम कोड दूंगा:

 const int row[8]={23,25,27,29,31,33,35,37}; const int col[8]={39,41,43,45,47,49,51,53}; int v=3; int dms=400; boolean A[8][8] = {0,0,1,1,1,1,0,0, 0,1,0,0,0,0,1,0, 0,1,0,0,0,0,1,0, 0,1,0,0,0,0,1,0, 0,1,1,1,1,1,1,0, 0,1,0,0,0,0,1,0, 0,1,0,0,0,0,1,0, 0,1,0,0,0,0,1,0}; void setup() { for (int i=0; i<8; i++) { pinMode(row[i],OUTPUT); pinMode(col[i],OUTPUT); } for (int i=0; i<8; i++) { digitalWrite(row[i],HIGH); } } void loop() { paint(A, v); scroll(A); } void paint(boolean screen[8][8], int v) { int i, j; for (int c=0; c <v; c ++) { for (i=0; i<8; i++) for (j=0; j<8; j++) { if (screen[i][j]==1) { digitalWrite(row[i], LOW); digitalWrite(col[j], HIGH); delayMicroseconds(dms); digitalWrite(row[i], HIGH); digitalWrite(col[j], LOW); } else { digitalWrite(row[i], HIGH); digitalWrite(col[j], LOW); delayMicroseconds(dms); digitalWrite(row[i], HIGH); digitalWrite(col[j], LOW); } } } } void scroll(boolean screen[8][8]) { boolean buf[8][1]; for (int i=0; i<8; i++) { buf[i][0]=screen[i][0]; } for (int i=0; i<8; i++) for (int j=0; j<8; j++) { screen[i][j]=screen[i][j+1]; } for (int i=0; i<8; i++) { screen[i][8-1]=buf[i][0]; } } 

वह सब है। इस कार्यक्रम को अपने माइक्रोकंट्रोलर में डालें और देखें कि बाईं ओर "ए" अक्षर "कैसे" चलेगा। मैं यह जोड़ना चाहूंगा कि आपको 8 तत्वों वाले 8 तक सीमित नहीं होना चाहिए। उदाहरण के लिए, मैंने 86 द्वारा आकार 8 की एक सरणी का उपयोग किया। मैंने इसमें एक पूरा वाक्यांश लिखा, जैसा कि इस वीडियो में देखा गया है।

सौभाग्य है