🥇कई LTE मॉडेम पर एक साथ गति परीक्षण

संगरोध के दौरान, मुझे कई सेलुलर ऑपरेटरों के लिए एलटीई मॉडेम की गति को मापने के लिए एक उपकरण के विकास में भाग लेने की पेशकश की गई थी।

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

मैं तुरंत कहूंगा कि यह कार्य सबसे सरल और सबसे अधिक ज्ञान-गहन नहीं है; मैं आपको बताऊंगा कि मुझे किन समस्याओं का सामना करना पड़ा और मैंने उन्हें कैसे हल किया। तो चलते हैं।

नोट

एलटीई कनेक्शन की गति को मापना एक बहुत ही जटिल मामला है: आपको सही उपकरण और माप तकनीक का चयन करना होगा, और सेलुलर नेटवर्क की टोपोलॉजी और संचालन की भी अच्छी समझ होनी चाहिए। साथ ही, गति कई कारकों से प्रभावित हो सकती है: एक सेल पर ग्राहकों की संख्या, मौसम की स्थिति, यहां तक कि एक सेल से दूसरे सेल में नेटवर्क टोपोलॉजी के कारण गति नाटकीय रूप से भिन्न हो सकती है। सामान्य तौर पर, यह बड़ी संख्या में अज्ञात लोगों के साथ एक समस्या है, और केवल एक दूरसंचार ऑपरेटर ही इसे सही ढंग से हल कर सकता है।

प्रारंभ में, ग्राहक केवल ऑपरेटरों के फोन से कूरियर चलाना चाहता था, सीधे फोन पर माप लेना चाहता था और फिर गति माप परिणामों को एक नोटबुक में लिखना चाहता था। एलटीई नेटवर्क की गति को मापने के लिए मेरा समाधान, हालांकि आदर्श नहीं है, समस्या का समाधान करता है।

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

संदर्भ की शर्तें

जैसा कि लेख में कहा गया है तकनीकी विशिष्टताओं के बिना: ग्राहक इसे क्यों नहीं चाहता: तकनीकी विशिष्टताओं के बिना काम न करें! कभी नहीं, कहीं भी!

तकनीकी कार्य काफी सरल था, अंतिम उपयोगकर्ता की समझ के लिए मैं इसे थोड़ा विस्तारित करूंगा। तकनीकी समाधान और उपकरण का चुनाव ग्राहक द्वारा तय किया गया था। तो, तकनीकी विशिष्टता स्वयं, सभी अनुमोदनों के बाद:

एकल बोर्ड कंप्यूटर पर आधारित vim2 एच मॉडेम के माध्यम से एलटीई कनेक्शन के लिए एक गति परीक्षक बनाएंuawei e3372h - 153 कई दूरसंचार ऑपरेटर (एक से एन तक)। यूएआरटी के माध्यम से जुड़े जीपीएस रिसीवर से निर्देशांक प्राप्त करना भी आवश्यक है। सेवा का उपयोग करके गति मापें www.speedtest.net और उन्हें एक तालिका में रखें जैसे:

सीएसवी प्रारूप में तालिका. फिर यह साइन हर 6 घंटे में ई-मेल से भेजें। त्रुटियों के मामले में, GPIO से जुड़ी एलईडी को झपकाएं।

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

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

वास्तुकला और विकास

योजना सरल और स्पष्ट है. इसलिए, मैं इसे बिना किसी विशेष टिप्पणी के छोड़ दूँगा।

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

इसके अलावा इस प्रक्रिया में मुझे पता चला कि पायथन के दो संस्करण 2 और 3 चल रहे हैं, परिणामस्वरूप मैंने तीसरे पर फैसला किया।

हार्डवेयर नोड्स

सिंगल-प्लेट vim2

मुझे मेरी मुख्य मशीन के रूप में एक सिंगल-बोर्ड कंप्यूटर दिया गया vim2

स्मार्ट होम और स्मार्ट-टीवी के लिए एक उत्कृष्ट, शक्तिशाली मीडिया प्रोसेसर, लेकिन इस कार्य के लिए बेहद अनुपयुक्त, या कहें तो खराब रूप से उपयुक्त। उदाहरण के लिए, इसका मुख्य ओएस एंड्रॉइड है, और लिनक्स एक माध्यमिक ओएस है, और तदनुसार कोई भी लिनक्स के तहत सभी नोड्स और ड्राइवरों के उच्च-गुणवत्ता वाले संचालन की गारंटी नहीं देता है। और मेरा मानना है कि कुछ समस्याएँ इस प्लेटफ़ॉर्म के USB ड्राइवरों से संबंधित थीं, इसलिए मॉडेम इस बोर्ड पर अपेक्षा के अनुरूप काम नहीं करते थे। इसके दस्तावेज़ भी बहुत ख़राब और बिखरे हुए हैं, इसलिए प्रत्येक ऑपरेशन में गोदी को खंगालने में बहुत समय लगता है। यहां तक कि GPIO के साथ सामान्य काम में भी बहुत अधिक खून खर्च होता है। उदाहरण के लिए, एलईडी स्थापित करने में मुझे कई घंटे लग गए। लेकिन, वस्तुनिष्ठ होने के लिए, यह मौलिक रूप से महत्वपूर्ण नहीं था कि यह किस प्रकार का सिंगल-बोर्ड था, मुख्य बात यह थी कि यह काम करता था और इसमें यूएसबी पोर्ट थे।

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

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

फ़र्मवेयर के बारे में यहाँ कुटिलतापूर्वक बताया गया है. मैं अजीब से रूसी में अनुवाद करता हूं। बोर्ड को फ्लैश करने के लिए, मुझे हार्डवेयर यूएआरटी को कनेक्ट करना होगा। इसे कनेक्ट किया इस अनुसार।

टूल पिन जीएनडी: <—> वीआईएम के जीपीआईओ का पिन17
टूल पिन TXD: <—> VIMs के GPIO (Linux_Rx) का पिन18
टूल पिन आरएक्सडी: <—> वीआईएम के जीपीआईओ (लिनक्स_टीएक्स) का पिन19
टूल पिन वीसीसी: <—> वीआईएम के जीपीआईओ का पिन20

जिसके बाद, मैंने फर्मवेयर डाउनलोड किया अत:. विशिष्ट फ़र्मवेयर संस्करण VIM1_Ubuntu-server-bionic_Linux-4.9_arm64_EMMC_V20191231.

इस फ़र्मवेयर को अपलोड करने के लिए, मुझे उपयोगिताओं की आवश्यकता है। इसके बारे में अधिक जानकारी यहां. मैंने इसे विंडोज़ के अंतर्गत फ़्लैश करने का प्रयास नहीं किया है, लेकिन मुझे आपको लिनक्स के अंतर्गत फ़र्मवेयर के बारे में कुछ शब्द बताने की आवश्यकता है। सबसे पहले, मैं निर्देशों के अनुसार उपयोगिताएँ स्थापित करूँगा।

git clone https://github.com/khadas/utils
cd /path/to/utils
sudo ./INSTALL

आनंद... कुछ भी काम नहीं करता. मैंने इंस्टॉलेशन स्क्रिप्ट को संपादित करने में कुछ घंटे बिताए ताकि मेरे लिए सब कुछ सही ढंग से इंस्टॉल हो जाए। मुझे याद नहीं है कि मैंने वहां क्या किया था, लेकिन वहां घोड़ों वाला सर्कस भी था। तो सावधान रहो। लेकिन इन उपयोगिताओं के बिना vim2 को और अधिक कष्ट देने का कोई मतलब नहीं है। बेहतर होगा कि उसके साथ बिल्कुल भी खिलवाड़ न किया जाए!

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

UART टर्मिनल में VIM2 लोड करते समय, मैं लोडिंग रोकने के लिए स्पेसबार जैसी एक कुंजी दबाता हूं। लाइन दिखने के बाद

kvim2#

मैं कमांड दर्ज करता हूं:

kvim2# run update

जिस होस्ट से हम लोड कर रहे हैं, मैं निष्पादित करता हूं:

burn-tool -v aml -b VIM2 -i  VIM2_Ubuntu-server-bionic_Linux-4.9_arm64_EMMC_V20191231.img

बस इतना ही, उफ़. मैंने जाँच की, बोर्ड पर लिनक्स है। लॉगिन/पासवर्ड ख़ाडा:ख़ाडा।

उसके बाद, कुछ छोटी प्रारंभिक सेटिंग्स। आगे के काम के लिए, मैं sudo के लिए पासवर्ड अक्षम कर देता हूं (हां, सुरक्षित नहीं है, लेकिन सुविधाजनक है)।

sudo visudo

मैं प्रपत्र में पंक्ति संपादित करता हूं और सहेजता हूं

# Allow members of group sudo to execute any command
%sudo ALL=(ALL:ALL) NOPASSWD: ALL

फिर मैं वर्तमान स्थान बदल देता हूं ताकि समय मॉस्को में हो, अन्यथा यह ग्रीनविच में होगा।

sudo timedatectl set-timezone Europe/Moscow

या

ln -s /usr/share/zoneinfo/Europe/Moscow /etc/localtime

यदि आपको यह कठिन लगता है तो इस बोर्ड का उपयोग न करें; रास्पबेरी पाई बेहतर है। ईमानदारी से।

मॉडेम हुआवेई e3372h - 153

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

वास्तुकला की दृष्टि से, एक लिनक्स उपयोगकर्ता के दृष्टिकोण से, सभी सेटिंग्स के बाद, यह इस तरह दिखता है: मॉडेम कनेक्ट करने के बाद, मेरे पास एक एथ * नेटवर्क इंटरफ़ेस है, जो डीएचसीपी के माध्यम से आईपी एड्रेस 192.168.8.100 और डिफ़ॉल्ट गेटवे प्राप्त करता है 192.168.8.1 है.

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

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

अर्थात्, n नेटवर्क कार्ड, समान IP पते के साथ, प्रत्येक समान डिफ़ॉल्ट गेटवे के साथ। लेकिन वास्तव में, उनमें से प्रत्येक अपने स्वयं के ऑपरेटर से जुड़ा हुआ है।

प्रारंभ में, मेरे पास एक सरल समाधान था: ifconfig या ip कमांड का उपयोग करके, सभी इंटरफ़ेस बंद करें और बस बारी-बारी से एक को चालू करें और उसका परीक्षण करें। समाधान सभी के लिए अच्छा था, सिवाय इसके कि स्विचिंग क्षणों के दौरान मैं डिवाइस से कनेक्ट नहीं हो पाया। और चूँकि स्विचिंग बार-बार और तेज़ होती है, मुझे वास्तव में कनेक्ट करने का कोई अवसर नहीं मिला।

इसलिए, मैंने मॉडेम के आईपी पते को मैन्युअल रूप से बदलने और फिर रूटिंग सेटिंग्स का उपयोग करके ट्रैफ़िक चलाने का रास्ता चुना।

यह मॉडेम के साथ मेरी समस्याओं का अंत नहीं था: बिजली की समस्याओं के मामले में, वे गिर गए, और यूएसबी हब के लिए एक अच्छी स्थिर बिजली आपूर्ति की आवश्यकता थी। मैंने पावर को सीधे हब में हार्ड सोल्डरिंग करके इस समस्या को हल किया। एक और समस्या जिसका मुझे सामना करना पड़ा और जिसने पूरे प्रोजेक्ट को बर्बाद कर दिया: डिवाइस के रिबूट या कोल्ड स्टार्ट के बाद, सभी मॉडेम का पता नहीं चला और हमेशा नहीं, और मैं यह निर्धारित नहीं कर सका कि ऐसा क्यों हुआ और किस एल्गोरिदम द्वारा हुआ। लेकिन सबसे पहले चीज़ें.

मॉडेम के सही ढंग से काम करने के लिए, मैंने यूएसबी-मोडस्विच पैकेज स्थापित किया।

sudo apt update
sudo apt install -y usb-modeswitch

जिसके बाद, कनेक्ट करने के बाद, मॉडेम को udev सबसिस्टम द्वारा सही ढंग से पहचाना और कॉन्फ़िगर किया जाएगा। मैं बस मॉडेम को कनेक्ट करके और यह सुनिश्चित करके जांच करता हूं कि नेटवर्क दिखाई दे रहा है।
एक और समस्या जिसे मैं हल नहीं कर सका: मैं इस मॉडेम से उस ऑपरेटर का नाम कैसे प्राप्त कर सकता हूं जिसके साथ हम काम कर रहे हैं? ऑपरेटर का नाम मॉडेम वेब इंटरफ़ेस में 192.168.8.1 पर निहित है। यह एक गतिशील वेब पेज है जो अजाक्स अनुरोधों के माध्यम से डेटा प्राप्त करता है, इसलिए केवल पेज को भूल जाने और नाम को पार्स करने से काम नहीं चलेगा। इसलिए मैंने यह देखना शुरू किया कि वेब पेज कैसे विकसित किया जाए, इत्यादि, और मुझे एहसास हुआ कि मैं किसी प्रकार की बकवास कर रहा था। परिणामस्वरूप, उसने थूक दिया, और ऑपरेटर ने स्पीडटेस्ट एपीआई का उपयोग करके ही प्राप्त करना शुरू कर दिया।

यदि मॉडेम में एटी कमांड के माध्यम से पहुंच होती तो बहुत कुछ आसान होता। इसे पुन: कॉन्फ़िगर करना, पीपीपी कनेक्शन बनाना, आईपी असाइन करना, टेलीकॉम ऑपरेटर प्राप्त करना आदि संभव होगा। लेकिन अफ़सोस, मुझे जो दिया गया है मैं उसी से काम कर रहा हूँ।

जीपीएस

मुझे जो जीपीएस रिसीवर दिया गया था उसमें यूएआरटी इंटरफ़ेस और पावर था। यह सबसे अच्छा समाधान नहीं था, लेकिन फिर भी यह व्यावहारिक और सरल था। रिसीवर कुछ इस तरह दिखता था.

सच कहूँ तो, जीपीएस रिसीवर के साथ काम करने का यह मेरा पहला मौका था, लेकिन जैसा कि मुझे उम्मीद थी, सब कुछ हमारे लिए बहुत पहले ही सोच लिया गया था। इसलिए हम केवल तैयार समाधानों का उपयोग करते हैं।

सबसे पहले, मैं जीपीएस कनेक्ट करने के लिए uart_AO_B (UART_RX_AO_B, UART_TX_AO_B) को सक्षम करता हूं।

khadas@Khadas:~$ sudo fdtput -t s /dtb.img /serial@c81004e0 status okay

बाद में मैं ऑपरेशन की सफलता की जाँच करता हूँ।

khadas@Khadas:~$ fdtget /dtb.img /serial@c81004e0 status
okay

यह कमांड स्पष्ट रूप से डेवट्री को तुरंत संपादित करता है, जो बहुत सुविधाजनक है।

इस ऑपरेशन की सफलता के बाद, जीपीएस डेमॉन को रीबूट और इंस्टॉल करें।

khadas@Khadas:~$ sudo reboot

जीपीएस डेमॉन स्थापित करना. मैं सब कुछ स्थापित करता हूं और आगे की कॉन्फ़िगरेशन के लिए इसे तुरंत काट देता हूं।

sudo apt install gpsd gpsd-clients -y
sudo killall gpsd
 
/* GPS daemon stop/disable */
sudo systemctl stop gpsd.socket
sudo systemctl disable gpsd.socket

सेटिंग फ़ाइल का संपादन.

sudo vim /etc/default/gpsd

मैं एक यूएआरटी स्थापित कर रहा हूं जिस पर जीपीएस लटका रहेगा।

DEVICES="/dev/ttyS4"

और फिर हम सब कुछ चालू करते हैं और शुरू करते हैं।

/* GPS daemon enable/start */
sudo systemctl enable gpsd.socket
sudo systemctl start gpsd.socket

उसके बाद, मैं जीपीएस कनेक्ट करता हूं।

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

मैं जीपीएसमोन प्रोग्राम का उपयोग करके जीपीएस ऑपरेशन को रीबूट और जांचता हूं।

आप इस स्क्रीनशॉट में उपग्रहों को नहीं देख सकते हैं, लेकिन आप जीपीएस रिसीवर के साथ संचार देख सकते हैं, और इसका मतलब है कि सब कुछ ठीक है।

पायथन में, मैंने इस डेमॉन के साथ काम करने के लिए कई विकल्प आज़माए, लेकिन मैंने उस विकल्प पर समझौता किया जो पायथन 3 के साथ सही ढंग से काम करता था।

मैं आवश्यक लाइब्रेरी स्थापित करता हूं।

sudo -H pip3 install gps3

और मैं कार्य कोड को गढ़ता हूं।

from gps3.agps3threaded import AGPS3mechanism
...

def getPositionData(agps_thread):
	counter = 0;
	while True:
		longitude = agps_thread.data_stream.lon
		latitude = agps_thread.data_stream.lat
		if latitude != 'n/a' and longitude != 'n/a':
			return '{}' .format(longitude), '{}' .format(latitude)
		counter = counter + 1
		print ("Wait gps counter = %d" % counter)
		if counter == 10:
			ErrorMessage("Ошибка GPS приемника!!!")
			return "NA", "NA"
		time.sleep(1.0)
...
f __name__ == '__main__':
...
	#gps
	agps_thread = AGPS3mechanism()  # Instantiate AGPS3 Mechanisms
	agps_thread.stream_data()  # From localhost (), or other hosts, by example, (host='gps.ddns.net')
	agps_thread.run_thread()  # Throttle time to sleep after an empty lookup, default '()' 0.2 two tenths of a second

यदि मुझे निर्देशांक प्राप्त करने की आवश्यकता है, तो यह निम्नलिखित कॉल के साथ किया जाता है:

longitude, latitude = getPositionData(agps_thread)

और 1-10 सेकंड के भीतर मुझे या तो निर्देशांक मिल जाएगा या नहीं। हां, निर्देशांक प्राप्त करने के लिए मेरे पास दस प्रयास थे। इष्टतम नहीं, टेढ़ा और तिरछा, लेकिन यह काम करता है। मैंने ऐसा करने का निर्णय लिया क्योंकि जीपीएस का रिसेप्शन खराब हो सकता है और हमेशा डेटा प्राप्त नहीं हो पाता है। यदि आप डेटा प्राप्त करने के लिए प्रतीक्षा करते हैं, तो यदि आप किसी दूरस्थ कमरे में काम करते हैं, तो प्रोग्राम इस स्थान पर रुक जाएगा। इसलिए, मैंने इस असुंदर विकल्प को लागू किया।

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

प्रकाश उत्सर्जक डायोड

एलईडी को कनेक्ट करना एक ही समय में सरल और कठिन था। मुख्य कठिनाई यह है कि सिस्टम में पिन नंबर बोर्ड पर पिन नंबर के अनुरूप नहीं होता है और क्योंकि दस्तावेज़ बाएं हाथ से लिखा जाता है। OS में हार्डवेयर पिन नंबर और पिन नंबर की तुलना करने के लिए, आपको कमांड चलाने की आवश्यकता है:

gpio readall

सिस्टम और बोर्ड पर पिन पत्राचार की एक तालिका प्रदर्शित की जाएगी। जिसके बाद मैं पहले से ही ओएस में पिन को ऑपरेट कर सकता हूं। मेरे मामले में एलईडी से जुड़ा है जीपीआईओएच_5.

मैं GPIO पिन को आउटपुट मोड में स्विच करता हूँ।

gpio -g mode 421 out

मैं शून्य लिखता हूँ.

gpio -g write 421 0

मैं एक लिखता हूँ.

gpio -g write 421 1

"1" लिखने के बाद सब कुछ जल जाता है

#gpio subsistem
def gpio_init():
	os.system("gpio -g mode 421 out")
	os.system("gpio -g write 421 1")

def gpio_set(val):
	os.system("gpio -g write 421 %d" % val)
	
def error_blink():
	gpio_set(0)
	time.sleep(0.1)
	gpio_set(1)
	time.sleep(0.1)
	gpio_set(0)
	time.sleep(0.1)
	gpio_set(1)
	time.sleep(0.1)
	gpio_set(0)
	time.sleep(1.0)
	gpio_set(1)

def good_blink():
	gpio_set(1)

अब, त्रुटियों के मामले में, मैं error_blink() को कॉल करता हूं और एलईडी खूबसूरती से झपकेगी।

सॉफ्टवेयर नोड्स

स्पीडटेस्ट एपीआई

यह बहुत खुशी की बात है कि स्पीडटेस्ट.नेट सेवा का अपना पायथन-एपीआई है, आप देख सकते हैं Github.

अच्छी बात यह है कि ऐसे स्रोत कोड हैं जिन्हें देखा भी जा सकता है। इस एपीआई के साथ कैसे काम करें (सरल उदाहरण) यहां पाया जा सकता है प्रासंगिक खंड.

मैं निम्नलिखित कमांड के साथ पायथन लाइब्रेरी स्थापित करता हूं।

sudo -H pip3 install speedtest-cli

उदाहरण के लिए, आप सीधे सॉफ्टवेयर से उबंटू में स्पीड टेस्टर भी इंस्टॉल कर सकते हैं। यह वही पायथन एप्लिकेशन है, जिसे सीधे कंसोल से लॉन्च किया जा सकता है।

sudo apt install speedtest-cli -y

और अपनी इंटरनेट स्पीड मापें.

speedtest-cli Retrieving speedtest.net configuration... Testing from B***** (*.*.*.*)... Retrieving speedtest.net server list... Selecting best server based on ping... Hosted by MTS (Moscow) [0.12 km]: 11.8 ms Testing download speed................................................................................ Download: 7.10 Mbit/s Testing upload speed...................................................................................................... Upload: 3.86 Mbit/s

परिणामस्वरूप, जैसा मैंने किया। मुझे इस गति परीक्षण को अपने प्रोजेक्ट में पूरी तरह से लागू करने के लिए इसके स्रोत कोड को समझना पड़ा। सबसे महत्वपूर्ण कार्यों में से एक टेलीकॉम ऑपरेटर का नाम प्राप्त करना है ताकि उसे प्लेट में स्थानापन्न किया जा सके।

import speedtest
from datetime import datetime
...
#Указываем конкретный сервер для теста
#6053) MaximaTelecom (Moscow, Russian Federation)
servers = ["6053"]
# If you want to use a single threaded test
threads = None
s = speedtest.Speedtest()
#получаем имя оператора сотовой связи
opos = '%(isp)s' % s.config['client']
s.get_servers(servers)
#получаем текстовую строку с параметрами сервера
testserver = '%(sponsor)s (%(name)s) [%(d)0.2f km]: %(latency)s ms' % s.results.server
#тест загрузки
s.download(threads=threads)
#тест выгрузки
s.upload(threads=threads)
#получаем результаты
s.results.share()

#После чего формируется строка для записи в csv-файл.
#получаем позицию GPS
longitude, latitude = getPositionData(agps_thread)
#время и дата
curdata = datetime.now().strftime('%d.%m.%Y')
curtime = datetime.now().strftime('%H:%M:%S')
delimiter = ';'
result_string = opos + delimiter + str(curpos) + delimiter + 
	curdata + delimiter + curtime + delimiter + longitude + ', ' + latitude + delimiter + 
	str(s.results.download/1000.0/1000.0) + delimiter + str(s.results.upload / 1000.0 / 1000.0) + 
	delimiter + str(s.results.ping) + delimiter + testserver + "n"
#тут идет запись в файл логов

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

डायनेमिक सर्वर चुनते समय गति मापने का परिणाम।

गति परीक्षण का परिणाम, एक सख्ती से चयनित एक सर्वर के साथ।

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

मेल भेजना और त्रुटियाँ

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

लॉग शेड्यूलर के अनुसार भेजे गए थे, अगर कोई कनेक्शन है, हर 6 घंटे: 00 बजे, सुबह 06 बजे, दोपहर 12 बजे और शाम 18 बजे। इसे इस प्रकार भेजा।

from send_email import *
...
message_log = "Логи тестирования платы №1"
EmailForSend = ["[email protected]", "[email protected]"]
files = ["/home/khadas/modems_speedtest/csv"]
...
def sendLogs():
	global EmailForSend
	curdata = datetime.now().strftime('%d.%m.%Y')
	сurtime = datetime.now().strftime('%H:%M:%S')
	try:
		for addr_to in EmailForSend:
			send_email(addr_to, message_log, "Логи за " + curdata + " " + сurtime, files)
	except:
		print("Network problem for send mail")
		return False
	return True

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

फीडबैक सर्वर

हार्डवेयर के एक दूरस्थ टुकड़े तक पहुंच पाने और उसे अनुकूलित और पुन: कॉन्फ़िगर करने में सक्षम होने के लिए, मुझे एक बाहरी सर्वर की आवश्यकता थी। सामान्य तौर पर, निष्पक्ष होने के लिए, सभी डेटा को सर्वर पर भेजना और वेब इंटरफ़ेस में सभी सुंदर ग्राफ़ बनाना सही होगा। लेकिन एक बार में नहीं.

वीपीएस के लिए मैंने चुना ruvds.com. आप सबसे सरल सर्वर ले सकते हैं. और सामान्य तौर पर, मेरे उद्देश्यों के लिए यह पर्याप्त होगा। लेकिन चूंकि मैंने सर्वर के लिए अपनी जेब से भुगतान नहीं किया था, इसलिए मैंने इसे एक छोटे रिजर्व के साथ लेने का फैसला किया ताकि अगर हम एक वेब इंटरफ़ेस, अपना स्वयं का एसएमटीपी सर्वर, वीपीएन इत्यादि तैनात कर सकें तो यह पर्याप्त होगा। साथ ही, टेलीग्राम बॉट स्थापित करने में सक्षम हो और इसके अवरुद्ध होने की समस्या न हो। इसलिए, मैंने एम्स्टर्डम और निम्नलिखित मापदंडों को चुना।

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

मैं फ़ायरवॉल स्थापित करने, अधिकारों को प्रतिबंधित करने, रूट एसएसएच कनेक्शन को अक्षम करने और वीपीएस स्थापित करने की अन्य सच्चाइयों के विवरण में नहीं जाऊंगा। मैं विश्वास करना चाहूंगा कि आप पहले से ही सब कुछ जानते हैं। रिमोट कनेक्शन के लिए, मैं सर्वर पर एक नया उपयोगकर्ता बनाता हूं।

adduser vimssh

मैं अपने हार्डवेयर पर ssh कनेक्शन कुंजियाँ उत्पन्न करता हूँ।

ssh-keygen

और मैं उन्हें हमारे सर्वर पर कॉपी करता हूं।

ssh-copy-id [email protected]

हमारे हार्डवेयर पर मैं प्रत्येक बूट पर एक स्वचालित रिवर्स एसएसएच कनेक्शन बनाता हूं।

[Unit] Description=Auto Reverse SSH Requires=systemd-networkd-wait-online.service After=systemd-networkd-wait-online.service [Service] User=khadas ExecStart=/usr/bin/ssh -NT -o ExitOnForwardFailure=yes -o ServerAliveInterval=60 -CD 8080 -R 8083:localhost:22 [email protected] RestartSec=5 Restart=always [Install] WantedBy=multi-user.target

पोर्ट 8083 पर ध्यान दें: यह निर्धारित करता है कि मैं रिवर्स एसएसएच के माध्यम से कनेक्ट करने के लिए किस पोर्ट का उपयोग करूंगा। इसे स्टार्टअप में जोड़ें और प्रारंभ करें।

sudo systemctl enable autossh.service
sudo systemctl start autossh.service

आप स्थिति भी देख सकते हैं:

sudo systemctl status autossh.service

अब, हमारे VPS सर्वर पर, यदि हम चलाते हैं:

ssh -p 8083 khadas@localhost

फिर मैं हार्डवेयर के अपने परीक्षण टुकड़े पर पहुँचता हूँ। और हार्डवेयर से मैं एसएसएच के माध्यम से लॉग और कोई भी डेटा अपने सर्वर पर भेज सकता हूं, जो बहुत सुविधाजनक है।

यह सब एक साथ डालें

स्विच ऑन करते हुए, आइए विकास और डिबगिंग शुरू करें

ओह, ठीक है, बस इतना ही, मैंने सभी नोड्स का वर्णन किया है। अब यह सब एक साथ रखने का समय आ गया है। आप कोड देख सकते हैं यहां.

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

शुरुआत में, मैं जीपीएस, जीपीआईओ आरंभ करता हूं और एक अलग शेड्यूलर थ्रेड लॉन्च करता हूं।

#запуск потока планировщика
pShedulerThread = threading.Thread(target=ShedulerThread, args=(1,))
pShedulerThread.start()

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

#sheduler
def ShedulerThread(name):
	global ready_to_send
	while True:
		d = datetime.today()
		time_x = d.strftime('%H:%M')
		if time_x in time_send_csv:
			ready_to_send = True
		if error_status:
			error_blink()
		else:
			good_blink()
		time.sleep(1)

इस परियोजना का सबसे कठिन हिस्सा प्रत्येक परीक्षण के लिए रिवर्स एसएसएच कनेक्शन बनाए रखना है। प्रत्येक परीक्षण में डिफ़ॉल्ट गेटवे और DNS सर्वर को पुन: कॉन्फ़िगर करना शामिल है। चूंकि वैसे भी कोई नहीं पढ़ता है, तो जान लें कि ट्रेन लकड़ी की पटरियों पर नहीं चलती है। जो कोई भी ईस्टर अंडा पाता है उसे कुछ कैंडी मिलती है।

ऐसा करने के लिए, मैं एक अलग रूटिंग टेबल -सेट-मार्क 0x2 और ट्रैफ़िक को पुनर्निर्देशित करने के लिए एक नियम बनाता हूं।

def InitRouteForSSH():
	cmd_run("sudo iptables -t mangle -A OUTPUT -p tcp -m tcp --dport 22 -j MARK --set-mark 0x2")
	cmd_run("sudo ip rule add fwmark 0x2/0x2 lookup 102")

आप इसके बारे में और जान सकते हैं कि यह कैसे काम करता है इस लेख में पढ़ें.

जिसके बाद मैं एक अंतहीन लूप में चला जाता हूं, जहां हर बार हमें कनेक्टेड मॉडेम की एक सूची मिलती है (यह पता लगाने के लिए कि क्या नेटवर्क कॉन्फ़िगरेशन अचानक बदल गया है)।

network_list = getNetworklist()

नेटवर्क इंटरफेस की सूची प्राप्त करना काफी सरल है।

def getNetworklist():
	full_networklist = os.listdir('/sys/class/net/')
	network_list = [x for x in full_networklist if "eth" in x and x != "eth0"]
	return network_list

सूची प्राप्त करने के बाद, मैंने सभी इंटरफेस के लिए आईपी पते सेट किए, जैसा कि मैंने मॉडेम के बारे में अध्याय में चित्र में दिखाया था।

SetIpAllNetwork(network_list)

def SetIpAllNetwork(network_list):
	for iface in network_list:
		lastip = "%d" % (3 + network_list.index(iface))
		cmd_run ("sudo ifconfig " + iface + " 192.168.8." + lastip +" up")

फिर मैं बस एक लूप में प्रत्येक इंटरफ़ेस से गुजरता हूं। और मैं प्रत्येक इंटरफ़ेस को कॉन्फ़िगर करता हूं।

	for iface in network_list:
		ConfigNetwork(iface)

def ConfigNetwork(iface):
#сбрасываем все настройки
		cmd_run("sudo ip route flush all")
#Назначаем шлюз по умолчанию
		cmd_run("sudo route add default gw 192.168.8.1 " + iface)
#задаем dns-сервер (это нужно для работы speedtest)
		cmd_run ("sudo bash -c 'echo nameserver 8.8.8.8 > /etc/resolv.conf'")

मैं कार्यक्षमता के लिए इंटरफ़ेस की जांच करता हूं, यदि कोई नेटवर्क नहीं है, तो मैं त्रुटियां उत्पन्न करता हूं। यदि कोई नेटवर्क है, तो कार्रवाई करने का समय आ गया है!

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

if not NetworkAvalible():
....
#Здесь мы формируем ошибки
....
else: #Есть сеть, ура, работаем!
#Если у нас проблемный интерфейс, на котором ssh, то меняем его
  if (sshint == lastbanint or sshint =="free"):
    print("********** Setup SSH ********************")
    if sshint !="free":
      сmd_run("sudo ip route del default via 192.168.8.1 dev " + sshint +" table 102")
    SetupReverseSSH(iface)
    sshint = iface
#раз сетка работает, то давай срочно все отправим!!!
    if ready_to_send:
      print ("**** Ready to send!!!")
        if sendLogs():
          ready_to_send = False
        if error_status:
          SendErrors()
#и далее тестируем скорость и сохраняем логи.

रिवर्स एसएसएच स्थापित करने के कार्य का उल्लेख करना उचित है।

def SetupReverseSSH(iface):
	cmd_run("sudo systemctl stop autossh.service")
	cmd_run("sudo ip route add default via 192.168.8.1 dev " + iface +" table 102")
	cmd_run("sudo systemctl start autossh.service")

और निःसंदेह, आपको स्टार्टअप में यह सारी सुंदरता जोड़ने की आवश्यकता है। ऐसा करने के लिए मैं एक फ़ाइल बनाता हूँ:

sudo vim /etc/systemd/system/modems_speedtest.service

और मैं इसमें लिखता हूं:

[Unit] Description=Modem Speed Test Requires=systemd-networkd-wait-online.service After=systemd-networkd-wait-online.service [Service] User=khadas ExecStart=/usr/bin/python3.6 /home/khadas/modems_speedtest/networks.py RestartSec=5 Restart=always [Install] WantedBy=multi-user.target

मैं ऑटोलोडिंग चालू करता हूं और प्रारंभ करता हूं!

sudo systemctl enable modems_speedtest.service
sudo systemctl start modems_speedtest.service

अब मैं कमांड का उपयोग करके क्या हो रहा है उसके लॉग देख सकता हूं:

journalctl -u modems_speedtest.service --no-pager -f

निष्कर्ष

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

#! /usr/bin/gnuplot -persist
set terminal postscript eps enhanced color solid
set output "Rostelecom.ps"
 
#set terminal png size 1024, 768
#set output "Rostelecom.png"
 
set datafile separator ';'
set grid xtics ytics
set xdata time
set ylabel "Speed Mb/s"
set xlabel 'Time'
set timefmt '%d.%m.%Y;%H:%M:%S'
set title "Rostelecom Speed"

plot "Rostelecom.csv" using 3:6 with lines title "Download", '' using 3:7 with lines title "Upload"
 
set title "Rostelecom 2 Ping"
set ylabel "Ping ms"
plot "Rostelecom.csv" using 3:8 with lines title "Ping"

पहला अनुभव Tele2 ऑपरेटर के साथ था, जिसे मैंने कई दिनों तक संचालित किया।

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

बाद में मैंने अन्य टेलीकॉम ऑपरेटरों के लिए कई ग्राफ़ बनाए। इस मामले में, वहाँ पहले से ही एक परीक्षण सर्वर था, और परिणाम भी बहुत दिलचस्प थे।

जैसा कि आप देख सकते हैं, इस डेटा के अनुसंधान और प्रसंस्करण के लिए विषय बहुत व्यापक है, और स्पष्ट रूप से कुछ हफ़्ते के काम तक नहीं टिकता है। लेकिन…

कार्य का परिणाम

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

स्रोत: www.habr.com

कई एलटीई मॉडेम पर एक साथ स्पीडटेस्ट

नोट