अपने OpenWrt राउटर को दूरस्थ रूप से एक्सेस करने के लिए Android/iOS ऐप: 11 कदम

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:21

मैंने हाल ही में एक नया राउटर (Xiaomi Mi Router 3G) खरीदा है। और निश्चित रूप से, हार्डवेयर के इस नए, भयानक टुकड़े ने मुझे इस परियोजना पर काम करना शुरू करने के लिए प्रेरित किया;)

चरण 1: मुझे लगता है, कि आपके पास पहले से ही OpenWrt है…।

मुझे पहले OpenWrt इंस्टॉल करना था… अधिकतर, मैंने इस गाइड का पालन किया (इस राउटर मॉडल के लिए विशिष्ट):https://dzone.com/articles/hacking-into-xiaomi-mi-…इस पर काम करते हुए, मुझे यह भयानक वीडियो मिला: ओपनराइट इंस्टालेशन, वाईफाई बेंचमार्क, गर्लफ्रेंड फ्लैशिंग। वाह मैं बहुत जोर से हंसा!:)

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

लेकिन अगर आपके राउटर पर पहले से ही OpenWrt है, तो आप इस ट्यूटोरियल को कुछ ही समय में शुरू कर पाएंगे।

BTW, कुछ विकास बोर्ड OpenWrt आउट-ऑफ़-द-बॉक्स के साथ आते हैं, जैसे कि Onion Omega, VoCore, LinkIt Smart 7688 और अन्य। यह ट्यूटोरियल ऐसे ऐप बनाने के पीछे कुछ बुनियादी विचार भी बताता है, ताकि आप इसे रास्पबेरी पाई और पसंद के साथ काम करने के लिए आसानी से अनुकूलित कर सकें।

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

साथ ही, मुझे लगता है कि आप पहले से ही जानते हैं:

• अपने OpenWrt राउटर में SSH टर्मिनल कैसे खोलें / उपयोग करें
• अपने राउटर पर फ़ाइलें कैसे अपलोड/संपादित करें (FileZilla या scp/sftp का उपयोग करें)
• लिनक्स कंसोल के साथ कैसे काम करें

चरण 2: सॉफ्टवेयर और उपकरण

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

डिवाइस की तरफ मैं आवश्यक कार्यक्षमता को स्क्रिप्ट करने के लिए लुआ का उपयोग करूंगा। मैं पायथन या नोड.जेएस का भी उपयोग कर सकता था, लेकिन दुर्भाग्य से कुछ राउटर पर संसाधनों की कमी के कारण ये विकल्प हमेशा उपलब्ध नहीं होते हैं। या सी/सी ++, लेकिन इसके साथ काम करना इतना सुविधाजनक नहीं है (प्रत्येक परिवर्तन के लिए पुन: संकलन, आदि) दूसरी ओर, लुआ पूर्व-स्थापित है, उपयोग करने और सीखने में आसान है। इसका उपयोग डिफ़ॉल्ट वेब इंटरफ़ेस, LuCI द्वारा किया जाता है।

चरण 3: एक न्यूनतम ऐप बनाना

Blynk और Lua के साथ शुरुआत करना उतना ही आसान है जितना:

• Blynk ऐप डाउनलोड करें (App Store, Google Play से)
• एक नया प्रोजेक्ट बनाएं और प्रामाणिक टोकन प्राप्त करें
• OpenWrt के लिए Blynk Lua इंस्टॉलेशन निर्देशों का पालन करें।

राउटर कंसोल तक पहुंचने के लिए एसएसएच का प्रयोग करें। डिफ़ॉल्ट उदाहरण चलाने के बाद:

लुआ./examples/client.lua

हमें कुछ इस तरह देखना चाहिए:

कनेक्ट हो रहा है…

एसएसएल हैंडशेक… तैयार।

जिसका मतलब है कि ऐप से सुरक्षित, द्वि-दिशात्मक कनेक्शन स्थापित हो गया है! YAY!

अब हम दिए गए उदाहरण को आसानी से बढ़ा सकते हैं, इसलिए यह कुछ दिलचस्प करता है। मैंने इसे संपादित करने के लिए इस उदाहरण की एक प्रति बनाई है:

सीपी./examples/client.lua./blynkmon.lua

चरण 4: कुछ जानकारी जोड़ना: ग्राहकों की संख्या, WAN IP पता, अपटाइम

मूल विचार यह है कि समय-समय पर OS से जानकारी प्राप्त करें, यदि आवश्यक हो तो कुछ सरल गणनाएँ करें, और फिर परिणाम को प्रदर्शन के लिए Blynk को भेजें।

Linux/OpenWrt में, हमारे पास सिस्टम डेटा प्राप्त करने के कई तरीके हैं:

• एक कमांड चलाएँ, और उसके द्वारा आउटपुट किए गए टेक्स्ट को पार्स करें
• एक कमांड चलाएँ, और उसके द्वारा लौटाए गए निकास कोड को देखें
• /proc/ और /sys/class/ निर्देशिकाओं में स्थित एक सिस्टम फ़ाइल पढ़ें

अब मैं जुड़े उपकरणों की संख्या प्रदर्शित करना चाहता हूं।

जब मैं कंसोल पर कैट/प्रोक/नेट/एआरपी चलाता हूं, तो यह ज्ञात उपकरणों की सूची को उनके मैक और आईपी पते के साथ आउटपुट करता है:

आईपी एड्रेस एचडब्ल्यू टाइप फ्लैग्स एचडब्ल्यू एड्रेस मास्क डिवाइस

192.168.10.206 0x1 0x2 78:02:f8:fb:d6:bf * br-lan 194.---------- 0x1 0x2 4c:5e:0c:14:e0:5c * eth0.2 192.168.10.162 0x1 0x0 04:b1:67:2f:e3:74 * br-lan

हम इसे सीधे लुआ में पार्स कर सकते हैं, लेकिन विशेष उपयोगिताओं का उपयोग करना अक्सर आसान होता है। लिनक्स पर, ये grep, head, tail, cut, wc, awk हैं।

एआरपी आउटपुट से ग्राहकों की संख्या प्राप्त करने के लिए, मुझे तालिका को फ़िल्टर करने की आवश्यकता है (असंबंधित आइटम हटाएं) और तालिका पंक्तियों की गणना करें, जिसके परिणामस्वरूप निम्न आदेश होता है:

बिल्ली / खरीद / नेट / एआरपी | ग्रेप बीआर-लैन | ग्रेप 0x2 | डब्ल्यूसी-एल

चलो यह कोशिश करते हैं:

रूट@राउटर:~/लुआ-ब्लींक# कैट/प्रोक/नेट/एआरपी | ग्रेप बीआर-लैन | ग्रेप 0x2 | डब्ल्यूसी-एल

1

महान। अब हमें इस बात का अंदाजा हो गया है कि हम सभी आवश्यक जानकारी कैसे एकत्र कर सकते हैं। आइए इसे स्वचालित करें। हमारे कोड को साफ और एक्स्टेंसिबल बनाने के लिए, आइए कुछ सहायक कार्य बनाएं:

फ़ंक्शन exec_out (cmd)

स्थानीय फ़ाइल = io.popen (cmd) यदि फ़ाइल नहीं है तो शून्य अंत स्थानीय आउटपुट = फ़ाइल: पढ़ें ('* सभी') फ़ाइल: बंद करें () प्रिंट ("रन:"..cmd.." -> ".. आउटपुट) रिटर्न आउटपुट एंड फंक्शन read_file (पथ) लोकल फाइल = io.open (पथ, "आरबी") अगर फाइल नहीं है तो nil एंड लोकल कंटेंट = फाइल: रीड "* ए" फाइल: क्लोज () प्रिंट ("पढ़ें:) "..path.." -> "..content) वापसी सामग्री अंत

इन उपयोगिताओं का उपयोग करके, हम अब वास्तविक डेटा लाने वाले कार्यों को लागू कर सकते हैं:

फ़ंक्शन getArpClients ()

वापसी tonumber(exec_out("cat /proc/net/arp | grep br-lan | grep 0x2 | wc -l")) एंड फंक्शन getUptime() रिटर्न tonumber(exec_out("cat /proc/uptime | awk '{print $1) }'")) एंड फंक्शन getWanIP() रिटर्न exec_out("ifconfig eth0.2 | grep 'inet addr:' | cut -d: -f2 | awk '{print $1}'") end

आप इन शेल कमांड के कुछ हिस्सों को चला सकते हैं, यह समझने के लिए कि यह कैसे काम करता है, और इसे अपनी आवश्यकताओं के अनुसार समायोजित करने के लिए।

सबसे आसान हिस्सा डेटा को Blynk ऐप पर भेज रहा है। डिफ़ॉल्ट उदाहरण पहले से ही टाइमर सेट करता है, जो हर 5 सेकंड में कुछ कोड चलाता है, इसलिए हम इसका पुन: उपयोग करते हैं:

स्थानीय tmr1 = टाइमर: नया {अंतराल = 5000, func = फ़ंक्शन ()

blynk:virtualWrite(10, getArpClients()) blynk:virtualWrite(11, string.format("%.1f h", getUptime()/60/60)) blynk:virtualWrite(12, getWanIP()) end}

ऐप में, हम 3 लेबल विजेट जोड़ते हैं, और उन्हें वर्चुअल पिन 10, 11, 12 के अनुसार असाइन करते हैं।

जबकि यह काम करता है, यह काफी अक्षम है, क्योंकि WAN IP या क्लाइंट्स की संख्या इतनी बार अपडेट नहीं होती है। चलो इसे ठीक करते हैं।

WAN IP के लिए, हम इसे कनेक्टेड हैंडलर में ले जाते हैं। यह हर बार चलाया जाएगा जब राउटर Blynk क्लाउड से कनेक्शन स्थापित करता है। यह पर्याप्त होना चाहिए:

ब्लिंक: ऑन ("कनेक्टेड", फंक्शन ()

प्रिंट ("तैयार।") ब्लिंक: वर्चुअलवाइट (12, getWanIP ()) अंत)

अपटाइम और क्लाइंट नंबर के लिए, हम 5 मिनट के साथ एक अलग टाइमर बनाते हैं। मध्यान्तर:

स्थानीय tmr2 = टाइमर: नया {अंतराल = 5 * 60 * 1000, func = फ़ंक्शन ()

blynk:virtualWrite(10, getArpClients()) blynk:virtualWrite(11, string.format("%.1f h", getUptime()/60/60)) end}

चरण 5: वाईफाई नियंत्रण: चालू / बंद

अब तक, हमें डिवाइस से केवल कुछ जानकारी ही मिल रही थी।आइए इसे नियंत्रित करने का प्रयास करें!

ब्लिंक: ऑन ("वी 20", फ़ंक्शन (परम)

अगर परम [1] == "1" तो os.execute ("वाईफाई अप") और os.execute ("वाईफाई डाउन") एंड एंड)

ऐप की तरफ, मैंने अभी एक बटन विजेट (मोड: स्विच) जोड़ा है और इसे V20 को सौंपा है।

बस, इतना ही। अद्भुत।

चरण 6: सिस्टम आँकड़े चार्ट

फ़ंक्शन getCpuLoad ()

वापसी tonumber(exec_out("top -bn1 | grep 'CPU:' | head -n1 | awk '{print $2+$4}'")) end function getRamUsage() वापसी tonumber(exec_out("free | grep Mem | awk ' {प्रिंट ($3-$7)/$2 * 100.0}'")) अंत

हमें Blynk को डेटा भेजने की भी आवश्यकता है (चलो फिर से tmr1 का उपयोग करें):

स्थानीय tmr1 = टाइमर: नया {अंतराल = 5000, func = फ़ंक्शन ()

blynk: virtualWrite(5, getCpuLoad()) blynk:virtualWrite(6, getRamUsage()) end}

ऐप साइड पर, सुपरचार्ट विजेट जोड़ें। CPU, RAM डेटास्ट्रीम जोड़ें और V5, V6 को असाइन करें।

चरण 7: एचडीडी स्पिनिंग स्थिति

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

जाहिर है, यह जानना अच्छा होगा कि यह पूरे दिन में कितनी बार चालू होता है। इसलिए मैंने अपने सिस्टम चार्ट में एक और डेटास्ट्रीम जोड़ा।

एचडीडी ड्राइव की स्थिति प्राप्त करना थोड़ा मुश्किल है, लेकिन मुझे एक रास्ता मिल गया है! सबसे पहले, SSH कंसोल से स्मार्टमोंटूल स्थापित करें:

opkg अद्यतन

opkg स्मार्टमोंटूल स्थापित करें

फिर, हमारे कोड में, हमें एक विशेष कमांड चलाने और निकास कोड की जांच करने की आवश्यकता है:

फ़ंक्शन exec_ret (cmd)

स्थानीय निकास = os.execute (cmd) प्रिंट ("रन:"..cmd.." -> बाहर निकलें: ".. बाहर निकलें) वापसी निकास अंत फ़ंक्शन getHddSpinning () if exec_ret ("smartctl --nocheck = स्टैंडबाय --info) /dev/sda > /dev/null") == 0 फिर 1 और वापस लौटें 0 अंत अंत

नोट: मेरा HDD है /dev/sda

चरण 8: नेटवर्क गतिविधि चार्ट

हम एक और सुपरचार्ट विजेट बनाते हैं (पिछले एक के समान), TX और RX डेटास्ट्रीम जोड़ें, और V1 और V2 को असाइन करें। नोट: मैं WAN पोर्ट स्टेट प्रदर्शित करना चाहता हूं, और मेरा WAN पोर्ट eth0.2 है

सहायक कार्य:

फ़ंक्शन getWanRxBytes ()

वापसी tonumber(read_file("/sys/class/net/eth0.2/statistics/rx_bytes")) एंड फंक्शन getWanTxBytes() रिटर्न टूनंबर(read_file("/sys/class/net/eth0.2/statistics/tx_bytes")) समाप्त

इसके बाद, उसी tmr1 में कुछ कोड जोड़ें। यह अधिक जटिल है, क्योंकि हमें केवल प्रेषित/प्राप्त बाइट्स में अंतर की गणना और प्रदर्शन करने की आवश्यकता है:

स्थानीय prevTx, prevRx

स्थानीय tmr1 = टाइमर: नया {अंतराल = 5000, func = फ़ंक्शन () स्थानीय tx = getWanTxBytes () स्थानीय rx = getWanRxBytes () यदि prevTx और prevTx ~ = tx तो blynk: VirtualWrite (1, tx - prevTx) समाप्त होता है यदि prevRx और prevRx ~= rx फिर blynk:virtualWrite(2, rx - prevRx) end prevTx = tx prevRx = rx blynk:virtualWrite(5, getCpuLoad()) blynk:virtualWrite(6, getRamUsage()) blynk:, getHddSpinning(7)) समाप्त}

चरण 9: सूचनाएं

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

विजेट सेटिंग्स में, "ऑफ़लाइन अधिसूचना" सक्षम करें। किसी कोड की आवश्यकता नहीं है। लेकिन हम अपने कोड से कस्टम नोटिफिकेशन भी भेज सकते हैं।

चरण 10: पृष्ठभूमि में ऑटोरन

अभी के लिए स्क्रिप्ट को मैन्युअल रूप से निष्पादित किया जाना है, लेकिन जब राउटर संचालित होता है तो मैं इसे स्वचालित रूप से पृष्ठभूमि में चलाना चाहता हूं।

यह एक सेवा बनाकर किया जाता है। एक फ़ाइल बनाएँ /etc/init.d/blynkmon:

#!/bin/sh /etc/rc.common

START=99 STOP= pidfile="/var/run/blynkmon.pid" start() { अगर [-f $pidfile]; फिर गूंज "blynkmon पहले से चल रहा है" बाहर निकलें 0 fi cd /root/lua-blynk lua blynkmon.lua your-auth-token > /dev/null & echo $! > $pidfile} रोकें() { अगर [! -एफ $ पिडफाइल]; फिर इको "ब्लींकमोन नहीं चल रहा है" बाहर निकलें 0 फाई किल -9 $ (कैट $ पिडफाइल) आरएम $ पिडफाइल}

नोट: अपना-प्रमाण-टोकन बदलना न भूलें

फिर, ब्लिंकमोन सेवा सक्षम करें:

सेवा ब्लिंकमोन सक्षम

चरण 11: निष्कर्ष और आगे के विचार

आप मेरे Blynk प्रोजेक्ट का क्लोन प्राप्त करने के लिए इस QR को स्कैन कर सकते हैं। इसके लिए कुछ ऊर्जा बिंदुओं (4600) की आवश्यकता होती है, क्योंकि यह बहुत सारे विजेट का उपयोग करता है!

पूरा लुआ कोड यहां पाएं:https://gist.github.com/vshymanskyy/3d3388a4e17f44…

अब तक बहुत अच्छा है, लेकिन यहां कुछ विचार दिए गए हैं जिन्हें मैं निकट भविष्य में जोड़ना चाहूंगा।

• रिबूट कमांड जोड़ें। गलती से उस पर क्लिक करने से रोकें।
• किसी भी लिनक्स कमांड को चलाने के लिए टर्मिनल विजेट जोड़ें।

• सीपीयू तापमान चार्ट जोड़ें।

  UPD: दुर्भाग्य से OpenWrt में वर्तमान में मेरे राउटर मॉडल के लिए कुछ ड्राइवरों की कमी है। लेकिन यह कई अन्य राउटर के लिए उपलब्ध है

• जब कोई विशेष उपकरण नेटवर्क से जुड़ता/छोड़ता है तो अधिसूचना जोड़ें। हमारे पास पहले से ही एआरपी जानकारी है, अब केवल मैक पते की जांच करें।

इस तरह, हम 3D प्रिंटर, रोबोट, एक नियमित पीसी/लैपटॉप, Arduino/ESP8266/ESP32/RaspberryPi सामान, स्मार्ट होम डिवाइस, और वस्तुतः किसी भी चीज़ की निगरानी और नियंत्रण कर सकते हैं। मुझे बताएं कि क्या आपके पास कोई अन्य दिलचस्प विचार है।आप इस सब के बारे में क्या सोचते हैं?