आउटडोर विज्ञापन और Arduino के लिए एक एलईडी मॉड्यूल से एक बहुत ही ध्यान देने योग्य मुखबिर कैसे बनाया जाए

कैसे P10 और Arduino एलईडी मॉड्यूल से एक बहुत ही ध्यान देने योग्य विजेट बनाने के लिए।

उद्देश्य : एक बड़े P10 एलईडी मैट्रिक्स (16x32cm) को एक पीसी या अन्य डिवाइस से कनेक्ट करें, यह सब प्रदर्शित जानकारी के गतिशील परिवर्तन के साथ एक बहुत ही ध्यान देने योग्य और उज्ज्वल मुखबिर में बदल जाता है। ऐसी चीज़ के लिए बहुत सारे अनुप्रयोग हैं, और जैसा कि अभ्यास से पता चलता है, यह ध्यान आकर्षित करता है। जरा सोचिए, अब सभी को पता चल जाएगा कि आपका एयर कंडीशनर काम कर रहा है और दरवाजा बंद होना चाहिए!

बैकलाइट खिड़की से नहीं है, लेकिन पैनल से;)

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

सभी ने साधारण रेंगने वाली लाइनों से लेकर विशाल टीवी तक आउटडोर विज्ञापन की उज्ज्वल स्क्रीन देखी। इन स्क्रीन को ऐसे एलईडी मॉड्यूल की एक श्रृंखला से इकट्ठा किया जाता है और विशेष नियंत्रकों द्वारा नियंत्रित किया जाता है, जिसकी कीमत स्क्रीन के आकार के प्रत्यक्ष अनुपात में बढ़ती है।

ये एलईडी मॉड्यूल काफी सस्ते हैं। लगभग $ 6, कीमत आकार और रंग पर निर्भर करती है। यह नियंत्रकों के साथ अधिक जटिल है। कीमत में सबसे सरल एकल एलईडी पैनल के लिए तुलनीय है। हालांकि, उनमें से अधिकांश पूर्व-तैयार "प्रस्तुतियों" को प्रदर्शित करने के मोड में काम करने के लिए "अनुरूप" हैं और प्रदर्शित जानकारी को गतिशील रूप से बदलने में सक्षम नहीं हैं। मैं मानता हूं कि मैं केवल सबसे सरल नियंत्रकों की कार्यक्षमता से परिचित हुआ, लेकिन यह समझने के लिए पर्याप्त था - सार्वभौमिक Arduino नियंत्रक पर आवश्यक चीजों को करने के लिए यह सस्ता और तेज है। यह आपको काफी शांति से कई मॉड्यूल कनेक्ट करने की अनुमति देगा। लेकिन हम एक के साथ शुरू करेंगे।

एलईडी मॉड्यूल (P10) कुछ इस तरह दिखता है:

http://digital-wizard.net/avr_projects/p10_led_display_panel_interface

वास्तव में, यह केवल एलईड का एक मैट्रिक्स है जो शिफ्ट रजिस्टरों के आउटपुट के लिए टांका लगाया जाता है, हम सर्किटरी के जंगल में नहीं जाएंगे, मॉड्यूल सभी मानक हैं और केवल आकार में भिन्न हैं। P10 का मतलब है कि दो आसन्न डायोड के बीच 10 मिमी। मोनोक्रोमैटिक, दो-रंग और यहां तक ​​कि आरजीबी पैनल भी हैं। विवरण में रुचि रखने वालों के लिए पहले से ही एक समान लेख है, लेकिन पूर्वाग्रह से निचले स्तर तक।

हार्डवेयर हिस्सा

और उन लोगों के लिए जो जल्दी से एक परिणाम प्राप्त करना चाहते हैं जिसे आप "महसूस" कर सकते हैं, आपको आवश्यकता होगी:

1. एक एलईडी मैट्रिक्स।
2. Arduino। (मैंने मिनी का उपयोग किया, लेकिन यह एक पीसी के साथ संचार के लिए अतिरिक्त एडेप्टर का उपयोग नहीं करने के लिए अधिक सुविधाजनक नैनो होगा)।
3. 5 वी / 3 ए के लिए बिजली की आपूर्ति। मैट्रिक्स जोरदार है, यदि आप सभी डायोड को हल्का करते हैं तो आपको बहुत अधिक शक्ति की आवश्यकता होती है।
4. कनेक्शन केबल (आमतौर पर यह एक मैट्रिक्स के साथ आता है।)
5. काम खत्म करने की इच्छा।

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

मैट्रिक्स से लूप लेना आवश्यक है, इसे एक साधारण सर्किट में आधा मिलाप में काटकर Arduino के लिए।

यदि आप Arduino Mini या UNO का उपयोग करते हैं, तो आपको सादृश्य द्वारा संबंधित पिंस को मिलाप करने की आवश्यकता है।

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

लेकिन 10 मिनट में मुझे निम्नलिखित डिज़ाइन मिला, एक अतिरिक्त USBtoUART एडॉप्टर के खतरे जो कि आपके पास नहीं होंगे यदि आप Arduino Mini का उपयोग नहीं करते हैं।

हार्डवेयर तैयार है, आपको मैट्रिक्स को पावर करने के लिए बस एक अतिरिक्त 5V / 3A PSU कनेक्ट करना होगा। ऐसा करने के लिए, इसमें एक अलग कनेक्टर, प्लस से प्लस, माइनस से माइनस है। इसके विपरीत, यह हो सकता है, लेकिन यह काम नहीं करेगा। हालांकि यह अजीब है, क्योंकि हर कोई जानता है कि इलेक्ट्रॉनों, हमेशा की तरह, प्लस से माइनस तक प्रवाह करते हैं। और अगर हम इस बात को ध्यान में रखते हैं कि इलेक्ट्रॉनों को नकारात्मक रूप से चार्ज किया जाता है, तो यह बिल्कुल स्पष्ट नहीं है कि वे नकारात्मक ध्रुव पर क्यों प्रवाह करते हैं ...?) उन्होंने सोचा कि छोटी चीजें हैं।

मुझे आशा है कि आप बिजली की आपूर्ति को अधिक मज़बूती से जोड़ते हैं, और मेरी विधि केवल तभी उपयुक्त है जब आपके पास बहुत अधिक बिजली की आपूर्ति हो। Arduin बोल्ट किया जा सकता है ( एक टैपिंग पेंच नहीं! ) पैनल के लिए, पैनल में बढ़ते थ्रेडेड छेद हैं।

यह सब है, चलो देवता मुझे माफ कर दें, लेकिन आज कोई नीली टेप नहीं थी। इस तरह के बेकार चीजों पर इतना मूल्यवान संसाधन खर्च करने लायक नहीं है।

सॉफ्टवेयर हिस्सा है

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

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

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

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

कमांड प्रारूप:

1. 0x1B (ESC) + 0x40 ("@") // पहचान, डिवाइस का स्ट्रिंग ID "P10_DISPLAY_V01 \ r \ n" लौटाता है
2. 0xOC (CLR) // स्क्रीन को साफ़ करें।
3. 0x1F (US) + 0x58 ("X") + 0x80 // स्क्रीन की चमक सेट करें, 0x80 + चमक।
4. 0x1F (यूएस) + 0x52 ("बी") + स्ट्रिंग // नीचे की रेखा सेट करें जो स्क्रॉल करेगी।
5. 0x1F (US) + 0x0A ("LF") + 0x31, 0x32, 0x33, 0x34, 0x35 // शीर्ष पर प्रदर्शित पांच अंकों की संख्या पास करें "12345"

मुझे समाप्त एक नहीं मिला और मुझे रूसी फ़ॉन्ट 5 * 7 खींचना पड़ा। शायद एक साइकिल, लेकिन क्या हम हमेशा सब कुछ तर्कसंगत रूप से करते हैं?

स्केच:

//====================== OneWire ==================================== #include <OneWire.h> OneWire ds2 (2); String res = ""; byte type_s; byte data[12]; byte addr_ds2[8]; bool temp_sensor_2_found = false; float temp1 = 999; //=================================================================== #include <SPI.h> #include "DMD.h" #include "TimerOne.h" #include "SystemFont5x7rus.h" #define CLR 0x0C #define US 0x1F #define ESC 0x1B #define LF 0x0A static const char ID[] = "P10_DISPLAY_V01\r\n"; // Device ID #define DISPLAYS_ACROSS 1 #define DISPLAYS_DOWN 1 DMD dmd(DISPLAYS_ACROSS, DISPLAYS_DOWN); //  ,     . #define max_char1 6 #define max_char2 176 unsigned char message1[max_char1] = {0x20,0x30,0x30,0x30,0x30,0x00}; // stores you message unsigned char message2[max_char2]; // stores you message unsigned char r_char; byte index1 = 4; byte index2 = 176; int i; long scrollSpeed = 25; char test[] = { 0x84,0x80,0x20,0x87,0x84,0x90,0x80,0x82,0x91,0x92,0x82,0x93,0x85,0x92,0x20,0x92, 0x8E,0x20,0x81,0x8B,0x80,0x83,0x8E,0x84,0x80,0x90,0x9F,0x20,0x97,0x85,0x8C,0x93, 0x20,0x8C,0x9B,0x20,0x8D,0x85,0x91,0x8C,0x8E,0x92,0x90,0x9F,0x20,0x8D,0x88,0x20, 0x8D,0x80,0x20,0x97,0x92,0x8E,0x20,0x88,0x20,0x82,0x8E,0x8F,0x90,0x85,0x8A,0x88, 0x20,0x82,0x91,0x85,0x8C,0x93,0x21,0x00}; //============================================================================= bool get_sensor(byte addr[8], OneWire ds) { //    if (! ds.search (addr)) { ds.reset_search (); delay (250); return false; } //        if (OneWire::crc8(addr, 7) != addr[7]) { Serial.println("get_sensor:CRC is not valid!"); return false; } //    switch (addr[0]) { case 0x10: //Chip = DS18S20 type_s = 1; break; case 0x28: //Chip = DS18B20 type_s = 0; break; case 0x22: //Chip = DS1822 type_s = 0; break; default: Serial.println("get_sensor:Device is not a DS18x20 family device."); return false; } return true; } //============================================================================= double get_temp(byte addr[8], OneWire ds) { double celsius; ds.reset (); ds.select (addr); //   ds.write (0x44, 1); //  ,     delay (750); ds.reset (); ds.select (addr); ds.write (0xBE); //     for (int i = 0; i < 9; i++) { //     data[i] = ds.read (); } //        ,           int raw = (data[1] << 8) | data[0]; if (type_s) { raw = raw << 3; // 9 bit resolution default if (data[7] == 0x10) { raw = (raw & 0xFFF0) + 12 - data[6]; } } else { byte cfg = (data[4] & 0x60); if (cfg == 0x00) raw = raw << 3; else if (cfg == 0x20) raw = raw << 2; else if (cfg == 0x40) raw = raw << 1; } celsius = (double)raw / 16.0; return celsius; }; //============================================================================= void massage2BufClear () { for(i=0; i<max_char2; i++) { message2[i] = '\0'; } index2=0; } //-------------------------------------------------------------- void massage1BufClear () { message1[0] = 0x20; message1[1] = 0x30; message1[2] = 0x30; message1[3] = 0x30; message1[4] = 0x30; message1[5] = 0x00; index1=0; } //-------------------------------------------------------------- void massage1Normalization () { char buf[5]; buf[0] = 0x20; buf[1] = 0x30; buf[2] = 0x30; buf[3] = 0x30; buf[4] = 0x30; int char_count = index1; for(i = char_count - 1; i >= 0; i--) { buf[i] = message1[i]; } massage1BufClear(); for(i = char_count - 1; i >= 0; i--) { message1[i+5-char_count] = buf[i]; } } //------------------------------------------------------------------ void ScanDMD() { dmd.scanDisplayBySPI(); } //------------------------------------------------------------------ void setup(void) { Timer1.initialize( 500 ); Timer1.attachInterrupt( ScanDMD ); dmd.clearScreen( true ); Serial.begin(9600); strcpy(message2,test); dmd.brightness = 70; temp_sensor_2_found = get_sensor(addr_ds2, ds2); dmd.selectFont(SystemFont5x7); } //------------------------------------------------------------------ void loop(void) { dmd.drawMarquee(message2 ,index2,(32*DISPLAYS_ACROSS)-1 ,8); if (temp_sensor_2_found) // !!!!!!! { // !!!!!!! res = String(get_temp(addr_ds2, ds2)); // !!!!!!! res.toCharArray(message1, 5); // !!!!!!! message1[4] = 0xF8; // !!!!!!! } // !!!!!!! long start=millis(); long timer=start; boolean ret=false; while(!ret) { if ((timer + scrollSpeed) < millis()) { dmd.drawFilledBox( 0,0,31,7, GRAPHICS_INVERSE); ret=dmd.stepMarquee(-1,0); timer=millis(); dmd.drawString( 1, 0, message1, 5, GRAPHICS_NORMAL ); if(Serial.available()) break; } } } //----------------------------------------------------------------------------------- void serialEvent() { delay(25); // Wait all data r_char = Serial.read(); if(r_char < 0x20) { switch (r_char) { case ESC: r_char = Serial.read(); if(r_char=='@') { Serial.write(ID); } break; case CLR: massage1BufClear(); massage2BufClear(); break; case US: r_char = Serial.read(); if(r_char=='X') { dmd.brightness = Serial.read(); } if(r_char=='B'){ massage2BufClear(); while(Serial.available() > 0) { r_char = Serial.read(); if(index2 < (max_char2-1)) { if(r_char > 0x1F) { message2[index2] = r_char; index2++; } } } } if(r_char==LF){ massage1BufClear(); while(Serial.available() > 0) { r_char = Serial.read(); if(index1 < (max_char1-1)) { if((r_char > 0x29) and (r_char < 0x3A)) { message1[index1] = r_char; index1++; } } } massage1Normalization(); } dmd.drawFilledBox( 0,8,31,15, GRAPHICS_INVERSE); break; default: break; } } while (Serial.available()) Serial.read(); dmd.writePixel(0,0,GRAPHICS_NORMAL,1); } 

पूर्ण चमक ऑपरेशन:

मानव चमक के साथ काम करें:

पायथन स्क्रिप्ट का उपयोग करते हुए पीसी से समय के गतिशील लोडिंग के साथ काम करना:

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

यह ध्यान देने योग्य है कि यह श्रृंखला में कई मॉड्यूल कनेक्ट करने के लिए पूरी तरह से स्वतंत्र है और बस इसे एक बड़ी स्क्रीन प्राप्त करने के लिए स्केच में इंगित करें। सीमाएं एक निश्चित संख्या में पैनलों के बाद ही शुरू होती हैं और वे Arduino और इसके SPI इंटरफ़ेस के सीमित प्रदर्शन से जुड़ी होती हैं। पैनल और अधिक के विस्तृत और विस्तृत अवलोकन के लिए धन्यवाद ElectricFromUfa !

शायद भविष्य में मैं एसटीएम 32 एफ 103 सी 8 टी 6 और ईएसपी -12 एफ पर भी ऐसा ही करूंगा, वहां सब कुछ तेजी से आगे बढ़ना चाहिए।

संदर्भ:

1. एक स्केच और संबंधित के साथ संग्रह से लिंक करें।
2. BitBucket का एक और लिंक