Aplicația Android / iOS pentru a accesa de la distanță routerul OpenWrt: 11 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

Recent am cumpărat un nou router (Xiaomi Mi Router 3G). Și, bineînțeles, această piesă hardware nouă și minunată m-a inspirat să încep să lucrez la acest proiect;)

Pasul 1: Presupun că ai deja OpenWrt …

Mai întâi a trebuit să instalez OpenWrt … În principal, am urmat acest ghid (specific pentru acest model de router): https://dzone.com/articles/hacking-into-xiaomi-mi-… În timp ce lucram la acest lucru, am găsit acest videoclip minunat: Instalare Openwrt, rețea WiFi, Girlfriend Flashing. Wow am râs atât de tare!:)

Atenţie! Instalarea OpenWrt vă poate împiedica routerul. Dar, odată finalizat, deblochează puterea și controlul deplin. Nu sunt suficient de curajos pentru a oferi instrucțiuni aici, deoarece acestea pot fi diferite pentru fiecare model de router.

Dar dacă aveți deja OpenWrt pe router, veți putea începe cu acest tutorial în timp util

BTW, unele plăci de dezvoltare vin cu OpenWrt out-of-the-box, cum ar fi Onion Omega, VoCore, LinkIt Smart 7688 și altele. Acest tutorial explică, de asemenea, câteva idei de bază din spatele creării unor astfel de aplicații, astfel încât să îl puteți adapta cu ușurință pentru a lucra cu Raspberry Pi și like-uri.

Pentru acest proiect, voi folosi în cea mai mare parte software preinstalat (disponibil pe orice router compatibil OpenWrt). Dar pentru unele funcționalități avansate, a trebuit să instalez pachete suplimentare. Acest lucru se face în doar câteva clicuri, așa că voi include instrucțiunile aici.

De asemenea, presupun că știți deja:

• Cum să deschideți / utilizați terminalul SSH la routerul dvs. OpenWrt
• Cum să încărcați / editați fișiere pe router (utilizați FileZilla sau scp / sftp)
• Cum se lucrează cu consola Linux

Pasul 2: Software și instrumente

Pe partea de smartphone, folosesc Blynk. Oferă aplicații iOS și Android pentru a controla orice hardware. Puteți construi cu ușurință interfețe grafice frumoase pentru toate proiectele dvs. prin simpla glisare și plasare a widgeturilor, chiar pe telefonul dvs. smartphone. Blynk este utilizat în principal cu Arduino, Raspberry Pi etc. Dar de ce nu îl rulezi pe routerul însuși?;)

În ceea ce privește dispozitivul, voi folosi Lua pentru a scripta funcționalitatea necesară. Aș putea folosi și Python sau Node.js, dar din păcate aceste opțiuni nu sunt întotdeauna disponibile, din cauza lipsei de resurse pe unele routere. Sau C / C ++, dar nu este atât de convenabil să lucrați cu (recompilarea pentru fiecare modificare etc.) Pe de altă parte, Lua este preinstalat, este simplu de utilizat și de învățat. Este folosit de interfața web implicită, LuCI.

Pasul 3: Crearea unei aplicații minime

Noțiuni de bază cu Blynk și Lua sunt la fel de ușoare ca:

• Descărcați aplicația Blynk (din App Store, Google Play)
• Creați un proiect nou și obțineți jetonul de autentificare
• Urmați instrucțiunile de instalare Blynk Lua pentru OpenWrt.

Utilizați SSH pentru a accesa consola routerului. După rularea exemplului implicit:

lua./examples/client.lua

Ar trebui să vedem așa ceva:

Se conectează …

Strângere de mână SSL … Gata.

Ceea ce înseamnă că este stabilită conexiunea sigură și bidirecțională cu aplicația! DA!

Acum putem extinde cu ușurință exemplul furnizat, deci face ceva interesant. Am creat o copie a acestui exemplu pentru al edita:

cp./examples/client.lua./blynkmon.lua

Pasul 4: Adăugarea unor informații: număr de clienți, adresă IP WAN, timp de funcționare

Ideea de bază este să obțineți informațiile din sistemul de operare periodic, să efectuați câteva calcule simple dacă este necesar și apoi să trimiteți rezultatul la Blynk pentru afișare.

În Linux / OpenWrt, avem mai multe moduri de a obține datele de sistem:

• Rulați o comandă și analizați textul pe care îl scoate
• Rulați o comandă și urmăriți codul de ieșire pe care îl returnează
• Citiți un fișier de sistem, aflat în / proc / și / sys / class / directoare

Acum vreau să afișez numărul de dispozitive conectate.

Când rulez cat / proc / net / arp pe consolă, acesta afișează lista dispozitivelor cunoscute, împreună cu adresele lor MAC și IP:

Adresă IP Tip HW Steaguri Adresă HW Mască Dispozitiv

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

O putem analiza direct în Lua, dar este adesea mai ușor să folosiți utilitare specializate. Pe Linux, acestea sunt grep, head, tail, cut, wc, awk.

Pentru a obține numărul de clienți din ieșirea arp, trebuie să filtrez tabelul (să elimin elementele care nu au legătură) și să număr rândurile de tabel, ceea ce duce la următoarea comandă:

cat / proc / net / arp | grep br-lan | grep 0x2 | wc -l

Hai sa incercam:

root @ router: ~ / lua-blynk # cat / proc / net / arp | grep br-lan | grep 0x2 | wc -l

1

Grozav. Avem acum ideea cum putem colecta toate informațiile necesare. Să-l automatizăm. Pentru a face codul nostru curat și extensibil, să creăm câteva funcții de ajutor:

funcție exec_out (cmd)

local file = io.popen (cmd) if not file then return nil end local output = file: read ('* all') file: close () print ("Run:"..cmd.. "->".. ieșire) returnează ieșire funcție sfârșit read_file (cale) fișier local = io.open (cale, "rb") dacă nu fișier, atunci returnează nul sfârșit conținut local = fișier: citește "* a" fișier: închide () print ("Citește: „..path..” -> „..content) returnează conținutul

Folosind aceste utilitare, putem implementa acum funcțiile reale de preluare a datelor:

funcția getArpClients ()

return tonumber (exec_out ("cat / proc / net / arp | grep br-lan | grep 0x2 | wc -l")) funcție finală getUptime () return tonumber (exec_out ("cat / proc / uptime | awk '{print $ 1 } '")) funcția de sfârșit getWanIP () returnează exec_out (" ifconfig eth0.2 | grep' inet addr: '| cut -d: -f2 | awk' {print $ 1} '") end

Puteți rula părți din aceste comenzi shell, pentru a obține o înțelegere mai profundă a modului în care funcționează și pentru a o ajusta la nevoile dvs.

Cea mai ușoară parte este trimiterea datelor către aplicația Blynk. Exemplul implicit configurează deja cronometrul, care rulează un cod la fiecare 5 secunde, așa că îl reutilizăm:

local tmr1 = Timer: nou {interval = 5000, func = function ()

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

În aplicație, adăugăm 3 widgeturi pentru etichete și le atribuim în mod corespunzător pinilor virtuali 10, 11, 12.

În timp ce acest lucru funcționează, este destul de ineficient, deoarece IP-ul WAN sau numărul de clienți nu se actualizează atât de frecvent. Să remediem acest lucru

Pentru IP WAN, îl mutăm în handler conectat. Acesta va fi rulat de fiecare dată când routerul stabilește conexiunea la Blynk Cloud. Acest lucru ar trebui să fie suficient:

blynk: pornit („conectat”, funcție ()

print ("Ready".) blynk: virtualWrite (12, getWanIP ()) end)

Pentru Uptime și Clients Number, creăm un temporizator separat cu 5 min. interval:

local tmr2 = Timer: nou {interval = 5 * 60 * 1000, func = function ()

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

Pasul 5: Control WiFi: PORNIT / OPRIT

Până acum, primeam doar câteva informații de pe dispozitiv. Să încercăm să-l controlăm!

blynk: pornit ("V20", funcție (param)

if param [1] == "1" then os.execute ("wifi up") else os.execute ("wifi down") end end)

Pe partea aplicației, tocmai am adăugat un widget Button (mod: Comutare) și l-am atribuit V20.

Asta e. Uimitor.

Pasul 6: Diagrama statisticilor sistemului

funcția getCpuLoad ()

return tonumber (exec_out ("top -bn1 | grep 'CPU:' | head -n1 | awk '{print $ 2 + $ 4}'")) funcție finală getRamUsage () return tonumber (exec_out ("free | grep Mem | awk ' {print ($ 3- $ 7) / $ 2 * 100,0} '")) sfârșit

De asemenea, trebuie să trimitem datele către Blynk (să folosim din nou tmr1):

local tmr1 = Timer: nou {interval = 5000, func = function ()

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

Pe partea aplicației, adăugați widgetul SuperChart. Adăugați transmisii de date CPU, RAM și atribuiți V5, V6.

Pasul 7: Starea de filare a HDD-ului

Ruterul meu are o unitate HDD externă conectată ca un dispozitiv de stocare atașat la rețea. Chestia este că această unitate este configurată să înceapă să se rotească atunci când cineva îl accesează și să se suspende după un timeout.

Evident, ar fi minunat să știm de câte ori se aprinde pe parcursul unei zile. Așa că am adăugat un alt flux de date în diagrama mea de sistem.

Este puțin mai dificil să obțineți starea unității HDD, dar am găsit o cale! În primul rând, instalați smartmontools din consola SSH:

actualizare opkg

opkg instalează smartmontools

Apoi, în codul nostru, trebuie să executăm o comandă specială și să verificăm codul de ieșire:

funcție exec_ret (cmd)

local exit = os.execute (cmd) print ("Run:"..cmd.. "-> exit:".. exit) return exit function function getHddSpinning () if exec_ret ("smartctl --nocheck = standby --info / dev / sda> / dev / null ") == 0 apoi returnează altceva returnează 0 end end

Notă: HDD-ul meu este / dev / sda

Pasul 8: Diagrama activității în rețea

Creăm un alt widget SuperChart (similar cu cel anterior), adăugăm transmisii de date TX și RX și le atribuim V1 și V2. Notă: Vreau să afișez statisticile portului WAN, iar portul meu WAN este eth0.2

Funcții de ajutor:

funcția getWanRxBytes ()

return tonumber (read_file ("/ sys / class / net / eth0.2 / statistics / rx_bytes")) funcție finală getWanTxBytes () return tonumber (read_file ("/ sys / class / net / eth0.2 / statistics / tx_bytes")) Sfârșit

Apoi, adăugați un cod la același tmr1. Acest lucru este mai complicat, deoarece trebuie doar să calculăm și să afișăm diferența de octeți transmiși / primiți:

local prevTx, prevRx

local tmr1 = Timer: new {interval = 5000, func = function () local tx = getWanTxBytes () local rx = getWanRxBytes () if prevTx and prevTx ~ = tx then blynk: virtualWrite (1, tx - prevTx) end if prevRx and prevRx ~ = rx apoi blynk: virtualWrite (2, rx - prevRx) end prevTx = tx prevRx = rx blynk: virtualWrite (5, getCpuLoad ()) blynk: virtualWrite (6, getRamUsage ()) blynk: virtualWrite (7, getHddSpinning ()) Sfârșit}

Pasul 9: notificări

De asemenea, am vrut să fiu informat când routerul meu pierde curentul sau conexiunea la internet. Pentru aceasta, avem nevoie de widget de notificare.

În setările widgetului, activați „notificarea offline”. Nu este necesar cod. Dar putem trimite și notificări personalizate din codul nostru.

Pasul 10: Autorun în fundal

Deocamdată scriptul trebuie executat manual, dar vreau să-l fac să ruleze automat în fundal când routerul este pornit.

Acest lucru se realizează prin crearea unui serviciu. Creați un fișier /etc/init.d/blynkmon:

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

START = 99 STOP = pidfile = "/ var / run / blynkmon.pid" start () {if [-f $ pidfile]; then echo "blynkmon already running" exit 0 fi cd / root / lua-blynk lua blynkmon.lua your-auth-token> / dev / null & echo $! > $ pidfile} stop () {if [! -f $ pidfile]; apoi ecou "blynkmon not running" exit 0 fi kill -9 $ (cat $ pidfile) rm $ pidfile}

Notă: nu uitați să înlocuiți-to-auth-token

Apoi, activați serviciul blynkmon:

service blynkmon enable

Pasul 11: Concluzii și idei suplimentare

Puteți scana acest QR pentru a obține clona Proiectului meu Blynk. Este nevoie de câteva puncte de energie (4600), deoarece folosește o mulțime de widget-uri!

Găsiți codul Lua complet aici:

Până acum, bine, dar iată câteva idei pe care aș dori să le adaug în viitorul apropiat.

• Adăugați comanda Reboot. Evitați să faceți clic pe acesta accidental.
• Adăugați un widget Terminal pentru a rula orice comandă Linux.

• Adăugați diagrama temperaturii procesorului.

  UPD: Din păcate, OpenWrt nu are în prezent unele drivere pentru modelul meu de router. Dar este disponibil pentru multe alte routere

• Adăugați o notificare când un anumit dispozitiv se alătură / iese din rețea. Avem deja informații despre arp, acum verificați doar adresa MAC.

În acest fel, putem monitoriza și controla imprimante 3D, roboți, un PC / laptop obișnuit, chestii Arduino / ESP8266 / ESP32 / RaspberryPi, dispozitive Smart Home și practic orice altceva din jur. Spuneți-mi dacă aveți alte idei interesante. Ce părere aveți despre toate acestea?