Samaaegne speedtest mitmete LTE-modemite peal

Karantiini ajal pakuti mulle osaleda LTE-modemite kiirus mõõteseadme arendamisel mitmete mobiilsideoperaatorite jaoks.

Tellija soovis hinnata erinevate sideoperaatorite kiirus erinevates geograafilistes punktides, et mõista, milline mobiilsideoperaator on tema jaoks sobivaim LTE-ühendust kasutava seadme paigaldamisel, näiteks videovoo jaoks. Selle ülesande pidi lahendama võimalikult lihtsalt ja odavalt, ilma kuluka varustuseta.

Tahan kohe öelda, et ülesanne ei ole kõige lihtsam ja tehnoloogiliselt nõudlik, räägin, millised probleemid mulle ette tulid ja kuidas ma neid lahendasin. Alustame.

Märkus

LTE-ühenduse kiirus mõõtmine on üsna keeruline: tuleb õigesti valida varustus ja mõõtmise meetod, samuti on oluline mõista mobiilside võrgu topoloogiat ja tööd. Lisaks võivad kiirus mõjutada mitmed tegurid: abonentide arv tornis, ilmastikutingimused, isegi tornide vahel võib kiirus drastiliselt erineda võrgu topoloogia tõttu. Ühesõnaga, see on ülesanne, kus on tohutult tundmatuid, ja selle õigesti lahendama suudab ainult sideoperaator.

Alguses soovis tellija lihtsalt edastada kullerit operaatorite telefonide kaudu, teha mõõtmisi otse telefonis ja seejärel märkida kiirusmõõtmiste tulemused vihikusse. Minu lahendus LTE-võrkude kiirusmõõtmiseks, kuigi mitte ideaalne, lahendab seatud ülesande.

Aja puudumise tõttu tegin otsuseid mitte mugavuse või praktilisuse, vaid arenduse kiirusarvestuse kasuks. Näiteks, kaugjuurdepääsu jaoks kasutati tagas SSH-d, selle asemel et kasutada praktilisemat VPN-i, et säästa aega serveri ja iga eraldi kliendi seadistamiseks.

Tehniline ülesanne

Kuidas on artiklis öeldud Ilma TSK-ta: miks klient ei taha seda: Ärge töötage ilma TSK-ta! Kunagi, kuskil!

Tehniline ülesanne oli piisavalt lihtne, laiendan seda veidi, et lõpptarbija saaks paremini aru. Tehniliste lahenduste ja seadmete valik oli tellija dikteeritud. Nii et siinkohal on TÖ, pärast kõiki kooskõlastusi:

Üheplaadise arvuti baasil vim2 luua LTE-ühenduse kiirusetester modemite kaudu Huawei e3372h — 153 mitme sideoperaatori (ühe kuni n). Samuti on vajalik saada koordinaadid GPS-vastuvõtjast, mis on ühendatud UART-i kaudu. Kiirus mõõta teenuse abil www.speedtest.net ja kokku koguda need tabeli kujul:

Tabel CSV-formaadis. Pärast seda saata e-kirjaga igal 6. tunnil antud tabel. Vigade korral vilkuma LED, mis on ühendatud GPIO-ga.

TÖ-d kirjeldasin vabamas vormis, pärast paljusid kooskõlastusi. Kuid ülesande sisu on juba nähtav. Kõikide toimingute täitmiseks oli antud nädal. Kuid tegelikkuses venis see kolme nädala peale. Arvestades, et tegelesin sellega ainult pärast põhitööd ja nädalavahetustel.

Siin tahan veel kord rõhutada, et tellija oli eelnevalt arutanud kiirusetesteenuse ja riistvara kasutamist, mis piiras mu võimalusi väga palju. Eelarve oli samuti piiratud, seega ei ostetud eriti midagi juurde. Nii et pidin neid reegleid järgima.

Arhitektuur ja arendus

Schéma on lihtne ja selge. Seetõttu jätan selle ilma eriliste kommentaarideta.

Kogu projekti otsustasin ellu viia Pythonis, hoolimata sellest, et mul polnud selle keele arenduses üldse kogemusi. Valisin selle, kuna oli palju valmis näiteid ja lahendusi, mis võisid arendust kiirendada. Seega palun kõiki professionaalseid programmeerijaid mitte kritiseerida mu esimest kogemust Pythonis ja olen alati rõõmuga valmis kuulama konstruktiivset kriitikat, et oma oskusi täiustada.

Samuti avastasin protsessi käigus, et Pythonil on kaks toimivat versiooni 2 ja 3, seega peatun kolmandal.

Riistvarakomponendid

Üheplaadine arvuti Vim2

Peamise masinana oli mul antud üheplaadine arvuti vim2

Suurepärane, võimas meediahiperlink nutikodu ja SMART-TV jaoks, kuid mingil moel sobimatu sellele ülesandele, või ütleme, et nõrgalt sobiv. Näiteks on selle peamine operatsioonisüsteem Android ja Linux on kaasne operaating, mis tähendab, et keegi ei garanteeri, et kõik ühendused ja draiverid Linuxi all töötavad hästi. Ma kahtlustan, et osa probleemidest oli seotud selle platvormi USB-draiveritega, seega modemid ei töötanud sellel emaplaadil ootuspäraselt. Samuti on dokumentatsioon väga kehv ja killustatud, mistõttu kõik toimingud võtsid palju aega, et dokumentidest süveneda. Ieven tavaline töö GPIO-dega oli kurnav. Näiteks, et seadistada LED-i töötamine, kulus mul mitu tundi. Ent objektiivselt öeldes ei olnud üldiselt oluline, milline on ühesilindriline arvuti, peamine on, et see töötaks ja et oleks USB-porte.

Esiteks pean installima Linuxi sellele emaplaadile. Et mitte ekselda dokumentatsiooni sügava metsa, ning ka nendele, kes selle ühesilindrilise arvutiga tegelevad, kirjutan selle peatüki.

Linuxi installimiseks on kaks varianti: väline SD-kaart või sisemine MMC. Kaardiga mängisin ma veidi, aga ei suutnud aru saada, kuidas see töötama panna, seega otsustasin installida MMC-le, kuigi kaardiga oleks kindlasti lihtsam töötada.

Ubuntu versioonist on siin vale info. Tõlgin kummalistest tõlgetest vene keelde. Et plaati vilkuda, pean ma ühendama riistvara UARTi. Ühendasin selle järgmiselt.

• Instrument Pin GND: <— Pin17 VIMi GPIO-st
• Instrument Pin TXD: <— Pin18 VIMi GPIO-st (Linux_Rx)
• Instrument Pin RXD: <— Pin19 VIMi GPIO-st (Linux_Tx)
• Instrument Pin VCC: <— Pin20 VIMi GPIO-st

Pärast seda allalaadisin ma firmware'i siit. Konkreetne versioon firmware'ist VIM1_Ubuntu-server-bionic_Linux-4.9_arm64_EMMC_V20191231.

Selle firmware'i installimiseks on mul vajalikud utiliidid. Täpsemalt selgitatakse seda siin. Windowsis ei proovinud ma vilkuda, kuid Linuxi all vilkumise kohta tuleb paar sõna öelda. Esiteks installin utiliidid vastavalt juhistele.

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

Eii... Mittegi ei tööta. Kulutasin paar tundi installatsiooniskriptide muutmise peale, et kõik õigesti paigaldada. Mis seal tegin, ei mäleta, aga see oli tõeline hobustega tsirkus. Olge ettevaatlikud. Kuid ilma nende utiliitideta ei ole mõtet VIM2-ga vaeva näha. Parim on temaga üldse mitte tegeleda!

Pärast seitse aktiivset ringi, skriptide konfigureerimist ja paigaldamist sain töötavate utiliidiga paketi. Ühendasin plaadi USB kaudu oma Linuxi arvutiga, ja samuti on UART ühendatud ülaltoodud skeemiga.
Seadistan oma lemmikterminali minicom kiirusel 115200, ilma riistvara- ja tarkvara veakontrollita. Ja alustame.

VIM2 laadimise ajal UART-terminalis vajutan mingit klahvi, näiteks tühikut, et laadimist peatada. Pärast seda, kui ilmub rida

kvim2# 

Sisestan käsku:

kvim2# run update

Hostis, kust laadime, täidan:

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

Kõik, uff. Flashisin, plaadil on Linux. Logi sisse/parool khadas:khadas.

Pärast seda teevad mõned esialgsed seadistused. Edasi töötamiseks deaktiveerin sudo parooli (jah, see ei ole ohutu, aga mugav).

sudo visudo

Muudan rida kujule ja salvestan

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

Seejärel muudan aktiivset keelt, et aeg oleks Moskva ajavööndis, muidu on see Greenwich'i ajavööndis.

sudo timedatectl set-timezone Europe/Moscow

või

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

Kui see tundub keeruline, siis ärge kasutage seda plaati, parem on Raspberry Pi. Ausalt.

Modem Huawei e3372h — 153

See modem on tõeliselt vereimeja olnud ja sisuliselt sai just tema kogu projekti kitsaskohaks. Üldiselt ei kajasta nimetus 'modem' nende seadmete tõelist olemust: see on äärmiselt võimas seade, see raudvara sisaldab komponenti, mis näib olevat CD-ROM, et draivereid installida, ja seejärel lülitub võrgukaardi režiimi.

Arhitektuuriliselt, kasutaja Linuxi perspektiivist pärast kõiki seadeid, näeb see välja nii: modemiga ühendamisel ilmub mulle võrgu liides eth*, mis saab dhcp kaudu ip-aadressi 192.168.8.100 ja vaikelüli 192.168.8.1.

Ja kõige olulisem punkt! See modemimudel ei oska töötada modemirežiimis, mida juhitakse AT-koodidega.. Kõik oleks palju lihtsam, kui luua iga modemi jaoks ppp-ühendus ja seejärel nendega tegutseda. Kuid minu puhul loob "ise" (täpsemalt Linuxi draiverid vastavalt udevi reeglitele) eth-liidese ja dhcp määrab sellele ip-aadressi.

Et mitte segadusse minna, soovitan unustada sõna "modem" ja rääkida võrgukaardist ja väravast, sest tegelikult on see nagu uue võrgukaardi ühendamine väravaga.
Kui on üks modem, siis see ei tekita erilisi probleeme, kuid kui neid on rohkem kui üks, nimelt n-tükki, siis tekib järgmine pildi võrk.

See tähendab n võrgukaarti, ühe IP-aadressiga, igaühel sama vaikevärav. Kuid tegelikult on igaühes neist ühendatud oma operaatoriga.

Alguses oli mul lihtne lahendus: kasutada ifconfig või ip käsku kõigi liideste kustutamiseks ja lihtsalt ükshaaval sisse lülitada ning teda testida. Lahendus oli kõigile hea, välja arvatud see, et vahetuse hetkedel ei saanud ma seadmele ühenduda. Kuna vahetused olid sagedased ja kiired, ei olnud mul tegelikult võimalik üldse sisse logida.

Seetõttu valisin käsitsi modemi IP-aadresside muutmise tee ja edasise liikluse suunamise seadistuste kaudu.

Kuid sellega mu modemi probleemid ei lõppenud: toiteprobleemide korral kukkusid nad välja ja vajalik oli hea stabiilne toide USB-hubi jaoks. Selle probleemi lahendasin, jootes toite otse hubile. Teine probleem, millega silmitsi seisinsin ja mis hävitas kogu projekti: pärast seadme taaskäivitamist või külma käivitamist ei tuvastatud kõiki modemeid ja mitte alati, ning ma ei suutnud välja selgitada, miks see juhtus ja millise algoritmi järgi. Kuid räägime kõigest järgemööda.

Modemi õige töö tagamiseks installisin usb-modeswitch'i paketi.

sudo apt update
sudo apt install -y usb-modeswitch

Pärast seda tuvastatakse modem pärast ühendamist õigesti ja seadistatakse udev'i alamsüsteemi poolt. Kontrollin, lihtsalt ühendades modemi ja veendudes, et võrk ilmub.
Veel üks probleem, mida ma lahendada ei saanud: kuidas saada sellest modemist operaatori nimi, millega me töötame? Operaatori nimi on modemi veebiliideses aadressil 192.168.8.1. See on dünaamiline veebileht, mis hankib andmeid ajax-päringute kaudu, seega ei saa lihtsalt wget'iga lehte alla laadida ja nime välja võtta. Seetõttu hakkasin vaatama, kuidas veebilehte töötlema hakata jne, ja mõistsin, et tegelen millegagi, mis pole mõttekas. Lõpuks andsin alla ja hakkasin operaatori nime hankima Speedtest'i API kaudu.

Palju asju oleks lihtsam, kui modemil oleks AT-käskude kaudu juurdepääs. Saaksin selle ümber seadistada, luua ppp-ühenduse, määrata IP, saadud operaatori nimi jne. Kuid kahjuks pean töötama selle, mis on antud.

GPS

GPS-vastuvõtja, mis mulle anti, oli UART-liidese ja toitega. See ei olnud parim lahendus, kuid siiski töötav ja lihtne. Vastuvõtja nägi umbes selline välja.

Ausalt öeldes töötasin esmakordselt GPS-vastuvõtjaga, kuid nagu ma eeldasin, on kõik ammu meie eest välja mõeldud. Nii et kasutame lihtsalt valmis lahendusi.

Alustan uart_AO_B (UART_RX_AO_B, UART_TX_AO_B) sisselülitamist GPS-i ühendamiseks.

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

See, I check the success of the operation.

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

This command seems to edit the devtree on-the-fly, which is quite convenient.

After the success of this operation, we will reboot and install the GPS daemon.

khadas@Khadas:~$ sudo reboot

Installing the GPS daemon. I install everything and immediately turn it off for further configuration.

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

Editing the configuration file.

sudo vim /etc/default/gpsd

I am setting up the UART on which the GPS will hang.

DEVICES="/dev/ttyS4"

And then we turn everything on and start it.

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

After that, I connect the GPS.

In my hands, the GPS cable, under my fingers, the UART debugger wires are visible.

I reboot and check the GPS operation using the gpsmon application.

In this screenshot, no satellites are visible, but communication with the GPS receiver is clear, indicating everything is fine.

I tried many options for working with this daemon in Python, but I settled on the one that worked correctly with Python 3.

I am installing the necessary library.

sudo -H pip3 install gps3 

And I am crafting the working code.

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 vastuvõtja tõrge!!!")
			return "NA", "NA"
		time.sleep(1.0)
...
f __name__ == '__main__':
...
	#gps
	agps_thread = AGPS3mechanism()  # Kutsu esile AGPS3 mehhanismid
	agps_thread.stream_data()  # Kohalikult (), või muudelt hostidelt, näiteks (host='gps.ddns.net')
	agps_thread.run_thread()  # Aeglane vahe pärast tühja otsingut, vaikimisi '()' 0,2 kaks kümnendikku sekundit

Kui mul on vaja saada koordinaate, siis tehakse seda järgmise kutsungiga:

longitude, latitude = getPositionData(agps_thread)

Ja 1-10 sekundi jooksul kas ma saan koordinaadi või mitte. Jah, mul oli kümme katset koordinaatide saamiseks. Mitte optimaalne, kohmakas, aga töötab. Otsustasin nii teha, sest GPS võib halvasti haarata ja mitte alati andmeid saada. Kui oodata andmete saamist, siis toimetades pimedas ruumis, programm jääb kinni sellesse kohta. Seetõttu rakendasin sellise mitte elegantse variandi.

Põhimõtteliselt, kui oleks rohkem aega, saaks otse UART kaudu GPS-andmeid saada, neid eraldi teemas töötlema panna ja nendega töötada. Kuid aega polnud üldse, seega nii koletu ja inetu kood. Ja jah, mul pole häbi.

LED

LEDi ühendamine oli korraga nii lihtne kui ka keeruline. Peamine keerukus seisneb selles, et pinge number süsteemis ei vasta plaadi pingega ja dokumentatsioon on kirjutatud vasaku jalaga. Et seostada riistvara pinge numbrit ja pinge numbrit operatsioonisüsteemis, tuleb täita käsk:

gpio readall

Kuvatakse pinge vastavustabel süsteemis ja plaadil. Pärast seda saan ma pingeid operatsioonisüsteemis kasutada. Minu puhul on LED ühendatud GPIOH_5.

Viin GPIO pinge väljundrežiimi.

gpio -g mode 421 out

Kirjutan nulli.

gpio -g write 421 0

Kirjutan ükshaaval.

gpio -g write 421 1

Kõik põleb, pärast kirjutamist '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)

Nüüd, vigade korral kutsun välja error_blink() ja LED vilgub kenasti.

Programmilised sõlmed

Speedtest API

Suurepärane, et speedtest.net-l on oma python-API, mida saab vaadata Github.

Hea on see, et on olemas ka lähtekoodid, mida saab vaadata. Kuidas selle API-ga töötada (lihtsaimad näited) on näha vastavas jaotises.

Installeerin python-teegi järgmise käsuga.

sudo -H pip3 install speedtest-cli

Näiteks võite spiditesteri Ubuntu-s otse repositooriumist installida. See on sama python-rakendus, mida saab otse terminalist jooksutada.

sudo apt install speedtest-cli -y

Ja mõõta oma internetiühenduse kiirus.

speedtest-cli
Laadimine speedtest.net konfiguratsioon...
Testimine B***** (*.*.*.*) asukohast...
Laadimine speedtest.net serverite loend...
Parima serveri valimine ping'i põhjal...
Majutatud MTS (Moskva) [0.12 km]: 11.8 ms
Laadimiskiirus testimine................................................................................
Laadimine: 7.10 Mbit/s
Üleslaadimiskiirus testimine......................................................................................................
Üleslaadimine: 3.86 Mbit/s

Tulemuseks, nagu mina seda tegin. Mul tuli süveneda sellele spiditesti lähtekoodidesse, et neid oma projekti paremini integreerida. Üks olulisemaid ülesandeid on saada ka teenusepakkuja nimi, et seda tabelisse sisestada.

import speedtest
from datetime import datetime
...
# Määrame testimiseks konkreetse serveri
#6053) MaximaTelecom (Moskva, Venemaa)
servers = ["6053"]
# Kui soovite kasutada ühe lõime testimist
threads = None
s = speedtest.Speedtest()
# saame mobiilioperaatori nime
opos = '%(isp)s' % s.config['client']
s.get_servers(servers)
# saame serveri parameetrite tekstirea
testserver = '%(sponsor)s (%(name)s) [%(d)0.2f km]: %(latency)s ms' % s.results.server
# allalaadimise test
s.download(threads=threads)
# üleslaadimise test
s.upload(threads=threads)
# saame tulemused
s.results.share()

# Pärast seda varustame csv-faili kirjutamiseks rea.
# saame GPS positsiooni
longitude, latitude = getPositionData(agps_thread)
# aeg ja kuupäev
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"
# siit toimub logifaili kirjutamine

Siin osutus ka kõik mitte nii lihtsaks, kuigi, näiliselt, võiks olla lihtsam. Alguses oli servers parameeter mul väärtuseks [], vaid vali parim server. Mul oli juhuslikult mitmeid servereid ja nagu arvata võib, kõikuv kiirus. See on piisavalt keeruline teema, et kasutada fikseeritud serverit; kui jah, siis staatiline või dünaamiline, vajab see uurimist. Siin on näide Beeline'i operaatori kiirusmõõtmisgraafikutest dünaamiliselt valitud testserveri ja staatiliselt fikseeritud serveri korral.

Kiirusmõõtmise tulemus dünaamilise serveri valimisel.

Kiiruskatse tulemus, kui valida rangelt üks ainsama server.

Testimisel esinev „müra” on nii seal kui seal ja see tuleb matemaatiliste meetoditega kõrvaldada. Kuid fikseeritud serveriga on seda veidi vähem ja amplituud on stabiilsem.
See on tõeliselt suurte uuringute koht. Isiklikult mõõdistaksin kiiruset oma serverile iperfi utiliidi abil. Kuid me peame kinni teostuse nõuetest.

Kohvikirjade saatmine ja vead

Kohvikirjade saatmiseks proovisin mitmeid erinevaid variante, kuid lõpuks peatusin järgmise peal. Registreerisin e-posti aadressi yandexis ja seejärel võtsin antud näite e-posti saatmisest. Olen selle kontrollinud ja programmi lisanud. Selles näites käsitletakse erinevaid variante, sealhulgas gmaili kasutamist jne. Oma postiserveri seadmist ei olnud mul ei soovi ega aega, kuid nagu selgus, oli see ka mõttetu.

Logide saatmine toimus ajakava alusel, kui ühendus on olemas, iga 6 tunni järel: kell 00:00, 06:00, 12:00 ja 18:00. Saatsin järgmiselt.

from send_email import *
...
message_log = "Testimise logid nr 1"
EmailForSend = ["dlinyj@trololo.ru", "pupkin@trololo.ru"]
files = ["/home/khadas/modems_speedtest/csv"]
...
def sendLogs():
	global EmailForSend
	curdata = datetime.now().strftime('%d.%m.%Y')
	curtime = datetime.now().strftime('%H:%M:%S')
	try:
		for addr_to in EmailForSend:
			send_email(addr_to, message_log, "Logid kuupäeval " + curdata + " kell " + curtime, files)
	except:
		print("Võrguprobleem e-kirja saatmisel")
		return False
	return True

Vigu veidi aega, et tegeleda teistega, kui aeg on käes, et tagasi minna töölauale. Saatke automaatsete teenuste kaudu. Probleem on see, et Yandexi kaudu ei saa uusi sõnumeid saata. Seetõttu pole see sugugi lihtne. Olen olnud siin kaua aega, vähemalt see on maru öelda. Samuti pole tõesti võimalik kõikide probleemide lahendamiseks, mida kõikides lõpuks saata tahtsid. Seega, peame meeles pidama, et automaatne saatmine on teenustel, mis selle probleemi sisse juhul.

Tagasiside server

Selleks, et saada ligipääs kaugseadmest ja selle seadistamiseks ja konfigureerimiseks vajasin välisseavet. Peab ütlema, et tegelikult oleks õiget andmeid saata serverisse ja kujundada kõik ilusad graafikud veebiliideses. Kuid mitte kõike korraga.

VPS-ina valisin ruvds.com. Ma oleks võinud võtta kõige lihtsama serveri. Ja minu vajaduste jaoks oleks sellest piisanud. Kuid kuna ma maksisin serveri eest mitte enda rahakotist, otsustasin võtta natuke suurema varu, et piisaks, kui hakkame käivitama veebiliidest, oma SMTP-serverit, VPN-i jne. Pluss on oluline seadistada Telegrami bot ja mitte kogeda selle blokeerimiste probleemidega. Seetõttu valisin Amsterdam ja järgmised parameetrid.

Seoses sideme loomisega seadmest vim2 valisin vastupidise SSH-ühenduse ja nagu praktika näitas — see ei ole kõige parem valik. Kui ühendus katke, hoiab server porti kinni ja sellele ei ole mõnda aega võimalik ühenduda. Seetõttu on ikkagi parem kasutada teisi suhtlusviise, näiteks VPN-i. Tulevikus lootsin minna üle VPN-ile, kuid ei jõudnud.

Ma ei süvenenud tulemüüri seadistamise, õiguste piirangute, root SSH ühenduse keelamise ja teiste VPS-i lihtsate seadistuste üksikasjadesse. Loodan, et te juba teate kõike seda. Kaugühenduse jaoks loon serveris uue kasutaja.

adduser vimssh

Meie seadmes genereerin SSH-ühenduse võtmepaarid.

ssh-keygen

Ja kopeerin need meie serverisse.

ssh-copy-id vimssh@host.com

Meie serveris loon automaatse tagasi ssh ühenduse iga käivituse korral.

[Unit]
Kirjeldus=Auto Tagasi SSH
Nõuab=systemd-networkd-wait-online.service
Pärast=systemd-networkd-wait-online.service
[Service]
Kasutaja=khadas
ExecStart=/usr/bin/ssh -NT -o ExitOnForwardFailure=yes -o ServerAliveInterval=60 -CD 8080 -R 8083:localhost:22 vimssh@host.com
RestartSec=5
Restart=always
[Install]
Tahab=multi-user.target

Pöörake tähelepanu pordile 8083: just see määrab, millisepordiga toimub tagasi ssh ühendus. Lisa automaatlaadimise ja käivita.

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

Võite isegi näha staatust:

sudo systemctl status autossh.service

Nüüd, meie VPS-serveris, kui käivitada:

ssh -p 8083 khadas@localhost

Siis pääsen oma testseadmest. Ja seadme kaudu saan samuti saata logisid ja kõiki andmeid ssh kaudu oma serverisse, mis on väga mugav.

Kogume kõik kokku

Käivitamine, alustame arendust ja silumist.

Uhh, tundub et olen kõik sõlmed kirjeldanud. Nüüd on aeg see kõik kokku koguda. Koodi saab vaadata. siit.

Oluline punkt koodiga: see projekt ei pruugi „niisama“ käivituda, kuna see on välja töötatud konkreetse ülesande ja arhitektuuri jaoks. Kuigi annan lähtekoodi, kirjeldan kõige väärtuslikumat siin, otse tekstis, muidu ei ole see üldse arusaadav.

Alguses toimub gps, gpio initsialiseerimine ja eraldi planeerija niidi käivitamine.

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

Plaani koostamine on piisavalt lihtne: see jälgib, kas on aeg sõnumeid saata ja mis on hetke viga. Kui on vigade lipp, siis vilgub LED.

#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)

Selle projekti kõige keerulisem osa on säilitada tagasipöörduv ssh-ühendus iga katse ajal. Igas katses seadistatakse vaikimisi värav ja dns-server uuesti. Kuna keegi ikka ei loe, siis teadke, et rong ei sõida puidust rööpaid pidi. Kes leidub munatootmine, sellele komm.

Selleks loon eraldi marsruudimise tabeli — set-mark 0x2 ja reegli liikluse suunamiseks.

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")

Kuidas see toimib, saab lugeda sellest artiklist.

Pärast seda lähen lõpmatusse tsüklisse, kus iga kord saame ühendatud MODEMITE nimekirja (et teada saada, kas võrgu konfiguratsioon on muutunud).

network_list = getNetworklist()

Võrgu liideste nimekirja saamine on piisavalt lihtne.

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

Pärast nimekirja saamist määran kõigile liidestele IP-aadressid, nagu ma näitasin pildil modemite peatükis.

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")

Jätkan lihtsalt silmusest läbi käimist igast liidesest. Ja konfigureerin iga liidese.

	for iface in network_list:
		ConfigNetwork(iface)

def ConfigNetwork(iface):
# lähtestame kõik seaded
		cmd_run("sudo ip route flush all")
# määrame vaikevärava
		cmd_run("sudo route add default gw 192.168.8.1 " + iface)
# määrame dns-serveri (see on vajalik speedtesti toimimiseks)
		cmd_run ("sudo bash -c 'echo nameserver 8.8.8.8 > /etc/resolv.conf'")

Kontrollin liidest töövõimekuse osas, kui võrku ei ole, vormistan vead. Kui võrk on olemas, on aeg tegutseda!

Siin seadistan ssh-marsruutimise antud liidese jaoks (kui see ei ole juba tehtud), saadan vead serverisse, ja kui aeg on kätte jõudnud, saadan logid ja lõpuks teen speedtesti ning salvestan logid csv-faili.

kui pole NetworkAvalible():
....
#Siin toome vormi vead
....
muul juhul: #On võrk, hurraa, töötame!
#Kui meil on probleeme SSH-liidese tõttu, muudame selle
  if (sshint == lastbanint or sshint =="free"):
    print("********** Installige SSH ********************")
    if sshint !="free":
      cmd_run("sudo ip route del default via 192.168.8.1 dev " + sshint +" table 102")
    SetupReverseSSH(iface)
    sshint = iface
#Kui võrk töötab, siis saadame kiiresti kõik!!!
    if ready_to_send:
      print ("**** Valmis saatmiseks!!!")
        if sendLogs():
          ready_to_send = False
        if error_status:
          SendErrors()
#ja seejärel testime kiirus ja salvestame logid. 

Võib-olla tasub mainida funktsiooni tagasi SSH seadistamiseks.

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")

Ja muidugi, on vajalik kogu see ilu autolaadimiseks lisada. Selleks loon faili:

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

Ja kirjutan sinna:

[Unit]
Kirjeldus=Modemi kiiruskatse
Nõuab=systemd-networkd-wait-online.service
Pärast=systemd-networkd-wait-online.service
[Service]
Kasutaja=khadas
ExecStart=/usr/bin/python3.6 /home/khadas/modems_speedtest/networks.py
RestartSec=5
Restart=always
[Install]
Tahab=multi-user.target

Luban autolaadimise ja käivitan!

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

Nüüd saan jälgida logisid, mis toimub, kasutades käsku:

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

Tulemused

Nüüd on kõige tähtsam, millised olid tulemused? Toon välja mõned graafikud, mida õnnestus mul välja töötamise ja silumise käigus jäädvustada. Graafikud koostati gnuplotiga järgmise skripti abil.

#! /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"

Esimene kogemus oli Tele2 operaatoriga, mida viisin läbi mitme päeva jooksul.

Siin kasutasin dünaamilist mõõteserverit. Kiirus mõõtmised toimivad, kuid kõikumised on väga suured, siiski on näha mingit keskmist väärtust, ja seda saab väljafiltreerida, näiteks liikuvate keskmiste abil.

Hiljem koostasin veel mitmeid graafikuid teiste teleoperaatorite jaoks. Testimisserver oli sel juhul juba üks, ja tulemusedki on väga huvitavad.

Nagu näha, on teema uurimiseks ja nende andmete töötlemiseks väga ulatuslik, ja see ei piira paar nädalat tööd. Kuid…

Töö tulemused

Töö lõpetati äkki minust sõltumatutel asjaoludel. Subjektiivselt arvan, et selle projekti nõrkuseks oli modem, mis ei tahtnud korralikult töötada koos teiste modemitega ning tegi igal käivitamisel selliseid trikke. Nende eesmärkide jaoks on saadaval tohutu hulk teisi modemimudeleid, mis on tavaliselt juba Mini PCI-e formaat ja paigaldatakse seadme sisse ning nende seadistamine on palju lihtsam. Kuid see on juba hoopis teine lugu. Projekt oli huvitav ja olin väga õnnelik, et sain selles osaleda.

Allikas: habr.com