🎅🏽 ✊🏾 📥 बड़ी संख्या में वस्तुओं की दृश्य निगरानी (उदाहरण के लिए, IPTV चैनल) Arduino का उपयोग करके 🙋 👨🏾‍🤝‍👨🏻 💢

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

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

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

स्पष्टता के लिए, एक कार्यक्रम है जो मोज़ेक के रूप में चैनलों के माध्यम से चलता है, या एक निश्चित रखता है
स्क्रीन पर चैनलों का हिस्सा (आप समझते हैं कि एक स्क्रीन पर सभी 160 चैनल फिट नहीं होते हैं, लेकिन कंप्यूटर पर 4x6 = 24 एसडी चैनल एक अच्छी प्रक्रिया / वीडियो कार्ड / नेटवर्क कार्ड के साथ काफी यथार्थवादी हैं)।

सामान्य तौर पर, प्रोग्रामेटिक रूप से, यह सब पहले से ही मौजूद है, लेकिन इतना है कि कंप्यूटर के बिना और एल ई डी के रूप में - यह नहीं होगा ...
और फिर मैं Arduino से मिला।
आप खुद समझ सकते हैं कि यह किस वजह से हुआ।

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

इसलिए, मैंने 16x10 एलईड के एक मैट्रिक्स को तैयार प्रोटोटाइप बोर्ड में मिलाया, उन्हें 4 शिफ्ट रजिस्टर 74HC595 के माध्यम से जोड़ा। उसके लिए enc28j60 पर arduino और ethershield द्वारा उपयोग किया जाता है।
यह इस तरह से निकला (चित्र क्लिक करने योग्य हैं)

संस्करण 0.22 और इथरशील्ड लाइब्रेरी संस्करण 1.1 के साथ विकास पर्यावरण के लिए कोड।
पहले से ही मुझे पता है कि निश्चित रूप से नया है, अगर आप अचानक दोहराना चाहते हैं - तो आपको अनुकूलित करना पड़ सकता है

 #include "etherShield.h" static uint8_t mymac[6] = {0x00,0x80,0x48,0x2d,0xf7,0x25}; //  mac-  static uint8_t myip[4] = {10,20,30,40}; // ip- 10.20.30.40 #define MYPORT 5555 #define BUFFER_SIZE 500 static uint8_t buf[BUFFER_SIZE+1]; static char number[7]; const byte clockPin = 7; // const byte latchPin = 8; //         const byte dataPin = 9; // const byte NumRegs = 4; //    const byte NumCols=10; const byte NumRows=16; //      -       , //       //    4 ,       , //   //     ()   1  32 //     26  (10+16) -      byte Col_bits[NumCols] = {3,5,7,11,13,15,19,21,23,27}; //         //    , .. 1-  //    3    .. byte Row_bits[NumRows] = {32,30,28,26,24,22,20,18,16,14,12,10,8,6,4,2}; //      //      byte Regs[NumRegs]; int reg_n, bit_n, in_r, in_c; // , . //       2! ;) // -   byte matrix[NumRows][NumCols]={{1,0,1,0,0,0,1,1,1,1}, {1,0,1,0,0,0,0,0,0,1}, {1,0,1,0,0,0,0,0,0,1}, {1,0,1,0,0,0,0,0,1,0}, {1,0,1,0,0,0,0,0,1,0}, {1,0,1,1,0,0,0,0,1,0}, {1,0,1,0,1,0,0,1,0,0}, {1,0,1,0,1,0,0,1,0,0}, {1,0,1,0,1,0,0,1,0,0}, {1,0,1,0,1,0,1,0,0,0}, {1,0,1,0,1,0,1,0,0,0}, {1,0,1,1,0,0,1,1,1,1}, {0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0}}; EtherShield es=EtherShield(); void setup() { pinMode(latchPin, OUTPUT); pinMode(dataPin, OUTPUT); pinMode(clockPin, OUTPUT); es.ES_enc28j60Init(mymac); //   es.ES_init_ip_arp_udp_tcp(mymac,myip, MYPORT); //   } void loop() { uint16_t plen, dat_p, ptr; while(1) { burn_matrix(); //          //        ( ).    //       ,     //     -      //   - read packet, handle ping and wait for a tcp packet: dat_p=es.ES_packetloop_icmp_tcp(buf,es.ES_enc28j60PacketReceive(BUFFER_SIZE, buf)); /* dat_p will be unequal to zero if there is a valid request */ if(dat_p == 0) { // no request continue; } //             :) //        "IbZ " if (strncmp("IbZ ",(char *)&(buf[dat_p]),4)==0) { //   4-       ptr = dat_p+4; for(in_r=0; in_r < NumRows; in_r++) { for(in_c=0; in_c < NumCols; in_c++) { matrix[in_r][in_c] = 0; //    ( ,    ;) ) } } //    -   -   //   ,   - 0 while(buf[ptr] != 0) { in_r = (buf[ptr]-1) % 16; in_c = (buf[ptr]-1) / 16; matrix[in_r][in_c] = 1; //     ptr++; } } } } void burn_matrix() { //     -  1- ,  , //  2- ,       10-  for(int c = 0; c < NumCols; c++) { for(int i = 0; i < NumRegs; i++) { Regs[i]=255; } reg_n = (Col_bits[c]-1) / 8; bit_n = (Col_bits[c]-1) % 8; bitWrite(Regs[reg_n], bit_n, 0); for(int r = 0; r < NumRows; r++) { reg_n = (Row_bits[r]-1) / 8; bit_n = (Row_bits[r]-1) % 8; bitWrite(Regs[reg_n], bit_n, matrix[r][c]); } registerWrite(); delay(1); } } //      -     void registerWrite() { digitalWrite(latchPin, LOW); for(int cur_reg = NumRegs-1; cur_reg >= 0; cur_reg-- ) { shiftOut(dataPin, clockPin, MSBFIRST, Regs[cur_reg]); } digitalWrite(latchPin, HIGH); }

#include "etherShield.h" static uint8_t mymac[6] = {0x00,0x80,0x48,0x2d,0xf7,0x25}; // mac- static uint8_t myip[4] = {10,20,30,40}; // ip- 10.20.30.40 #define MYPORT 5555 #define BUFFER_SIZE 500 static uint8_t buf[BUFFER_SIZE+1]; static char number[7]; const byte clockPin = 7; // const byte latchPin = 8; // const byte dataPin = 9; // const byte NumRegs = 4; // const byte NumCols=10; const byte NumRows=16; // - , // // 4 , , // // () 1 32 // 26 (10+16) - byte Col_bits[NumCols] = {3,5,7,11,13,15,19,21,23,27}; // // , .. 1- // 3 .. byte Row_bits[NumRows] = {32,30,28,26,24,22,20,18,16,14,12,10,8,6,4,2}; // // byte Regs[NumRegs]; int reg_n, bit_n, in_r, in_c; // , . // 2! ;) // - byte matrix[NumRows][NumCols]={{1,0,1,0,0,0,1,1,1,1}, {1,0,1,0,0,0,0,0,0,1}, {1,0,1,0,0,0,0,0,0,1}, {1,0,1,0,0,0,0,0,1,0}, {1,0,1,0,0,0,0,0,1,0}, {1,0,1,1,0,0,0,0,1,0}, {1,0,1,0,1,0,0,1,0,0}, {1,0,1,0,1,0,0,1,0,0}, {1,0,1,0,1,0,0,1,0,0}, {1,0,1,0,1,0,1,0,0,0}, {1,0,1,0,1,0,1,0,0,0}, {1,0,1,1,0,0,1,1,1,1}, {0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0}}; EtherShield es=EtherShield(); void setup() { pinMode(latchPin, OUTPUT); pinMode(dataPin, OUTPUT); pinMode(clockPin, OUTPUT); es.ES_enc28j60Init(mymac); // es.ES_init_ip_arp_udp_tcp(mymac,myip, MYPORT); // } void loop() { uint16_t plen, dat_p, ptr; while(1) { burn_matrix(); // // ( ). // , // - // - read packet, handle ping and wait for a tcp packet: dat_p=es.ES_packetloop_icmp_tcp(buf,es.ES_enc28j60PacketReceive(BUFFER_SIZE, buf)); /* dat_p will be unequal to zero if there is a valid request */ if(dat_p == 0) { // no request continue; } // :) // "IbZ " if (strncmp("IbZ ",(char *)&(buf[dat_p]),4)==0) { // 4- ptr = dat_p+4; for(in_r=0; in_r < NumRows; in_r++) { for(in_c=0; in_c < NumCols; in_c++) { matrix[in_r][in_c] = 0; // ( , ;) ) } } // - - // , - 0 while(buf[ptr] != 0) { in_r = (buf[ptr]-1) % 16; in_c = (buf[ptr]-1) / 16; matrix[in_r][in_c] = 1; // ptr++; } } } } void burn_matrix() { // - 1- , , // 2- , 10- for(int c = 0; c < NumCols; c++) { for(int i = 0; i < NumRegs; i++) { Regs[i]=255; } reg_n = (Col_bits[c]-1) / 8; bit_n = (Col_bits[c]-1) % 8; bitWrite(Regs[reg_n], bit_n, 0); for(int r = 0; r < NumRows; r++) { reg_n = (Row_bits[r]-1) / 8; bit_n = (Row_bits[r]-1) % 8; bitWrite(Regs[reg_n], bit_n, matrix[r][c]); } registerWrite(); delay(1); } } // - void registerWrite() { digitalWrite(latchPin, LOW); for(int cur_reg = NumRegs-1; cur_reg >= 0; cur_reg-- ) { shiftOut(dataPin, clockPin, MSBFIRST, Regs[cur_reg]); } digitalWrite(latchPin, HIGH); }

एल्गोरिथ्म सरल है: यदि चैनल काम करना बंद कर देता है - यह तुरंत दिखाई देता है - एलईडी प्रकाश करना शुरू कर देता है और एलईडी बाहर नहीं जाता है।
जब चैनल की जांच की जाती है, तो एलईडी चालू होता है; यदि सब कुछ ठीक है, तो एलईडी बाहर चला जाता है, अर्थात। आप देख सकते हैं कि स्क्रिप्ट कैसे चैक चैनल चलाती है। यह निगरानी सर्वर पर हर आधे घंटे में एक बार चलता है (यह प्रति चैनल 8 सेकंड से थोड़ा अधिक समय लेता है), निजी संघीय सर्वर को अलग से जांचा जाता है और यहां प्रदर्शित नहीं किया जाता है - यह योजनाओं में है (दुर्भाग्य से सच्चाई शायद संभव नहीं है :() एल ई डी की एक बड़ी संख्या के लिए एक मैट्रिक्स बनाते हैं, कई सर्वर शुरू करते हैं। निगरानी (प्रक्रिया को समानांतर करें ताकि सभी चैनल हर 5-10 मिनट में जांचे जा सकें)।

यहाँ एक छोटा वीडियो है:

खैर, जैसा कि प्रथागत है, मुख्य सामग्री का अनुमानित लागत (मूल रूप से सब कुछ ईबे / चीनी दुकानों पर खरीदा गया था):

ब्रेडबोर्ड प्रोटोटाइप पीसीबी प्रिंट सर्किट बोर्ड 18 x 30	~ $ 4
160 हरे 3 मिमी एलईडी	$ 5 से कम पाया जा सकता है
Arduino	~ $ 16
ENC28J60 ईथरनेट शील्ड Arduino Duemilanove / Uno के लिए	~ $ 16
4 रजिस्टर 74HC595	~ $ 3
कुल में	~ $ 45-50

बड़ी संख्या में वस्तुओं की दृश्य निगरानी (उदाहरण के लिए, IPTV चैनल) Arduino का उपयोग करके

More articles: