🥇Samaaegne kiirustest mitmel LTE-modemil

Karantiini ajal tehti mulle ettepanek osaleda mitme mobiilsideoperaatori jaoks mõeldud LTE modemi kiirust mõõtva seadme väljatöötamises.

Klient soovis hinnata erinevate sideoperaatorite kiirust erinevates geograafilistes asukohtades, et saada aru, milline mobiilsideoperaator on tema jaoks kõige optimaalsem LTE-ühendust kasutavate seadmete paigaldamisel, näiteks videoülekannete jaoks. Samas tuli probleem lahendada võimalikult lihtsalt ja odavalt, ilma kallite seadmeteta.

Ütlen kohe, et ülesanne pole just kõige lihtsam ja teadmistemahukam; räägin teile, milliste probleemidega kokku puutusin ja kuidas need lahendasin. Nii et lähme.

Märkus

LTE-ühenduse kiiruse mõõtmine on väga keeruline asi: peate valima õiged seadmed ja mõõtmistehnika ning omama head arusaama mobiilsidevõrgu topoloogiast ja toimimisest. Lisaks võivad kiirust mõjutada mitmed tegurid: abonentide arv kärjes, ilmastikutingimused, isegi kärjeti võib kiirus võrgu topoloogia tõttu järsult erineda. Üldiselt on see probleem suure hulga tundmatutega ja ainult sideoperaator saab selle õigesti lahendada.

Esialgu soovis klient lihtsalt operaatorite telefonidega kulleriga sõita, mõõta otse telefonist ja seejärel kiiruse mõõtmise tulemused märkmikusse kirja panna. Minu lahendus lte-võrkude kiiruse mõõtmiseks, kuigi mitte ideaalne, lahendab probleemi.

Ajapuuduse tõttu tegin otsuseid mitte mugavuse või praktilisuse, vaid arengukiiruse kasuks. Näiteks kasutati kaugjuurdepääsuks vastupidist ssh-d praktilisema VPN-i asemel, et säästa aega serveri ja iga üksiku kliendi seadistamisel.

Tehniline ülesanne

Nagu artiklis öeldud Ilma tehniliste näitajateta: miks klient seda ei soovi: Ärge töötage ilma tehniliste näitajateta! Mitte kunagi, mitte kuskil!

Tehniline ülesanne oli üsna lihtne, laiendan seda veidi, et lõppkasutaja mõistaks. Tehniliste lahenduste ja seadmete valiku dikteeris tellija. Niisiis, tehniline kirjeldus ise, pärast kõiki kinnitusi:

Põhineb ühel pardaarvutil vim2 tehke kiiruse tester lte-ühenduste jaoks H-modemite kauduuawei e3372h - 153 mitu sideoperaatorit (ühest n-ni). Samuti on vaja saada koordinaate UART-i kaudu ühendatud GPS-vastuvõtjalt. Tee teenust kasutades kiiruse mõõtmisi www.speedtest.net ja pange need sellisesse tabelisse:

Tabel csv-vormingus. Seejärel saatke see märk e-postiga iga 6 tunni järel. Vigade korral vilgutage GPIO-ga ühendatud LED-tuli.

Tehnilised näitajad kirjeldasin vabas vormis, pärast paljusid kooskõlastusi. Kuid ülesande mõte on juba nähtav. Kõige jaoks anti nädal. Kuid tegelikkuses kestis see kolm nädalat. See on tingitud asjaolust, et tegin seda ainult pärast põhitööd ja nädalavahetustel.

Siinkohal tahan veel kord juhtida tähelepanu asjaolule, et klient leppis kiirusmõõtmisteenuse ja riistvara kasutamises eelnevalt kokku, mis piiras oluliselt minu võimalusi. Ka eelarve oli piiratud, nii et midagi erilist ei ostetud. Seega pidime nende reeglite järgi mängima.

Arhitektuur ja arendus

Skeem on lihtne ja ilmne. Seetõttu jätan selle ilma eriliste kommentaarideta.

Otsustasin kogu projekti pythonis ellu viia, hoolimata sellest, et mul polnud selles keeles arendamise kogemust. Valisin selle, sest seal oli hunnik valmis näiteid ja lahendusi, mis võiksid arengut kiirendada. Seetõttu palun kõigil professionaalsetel programmeerijatel mitte kiruda minu esimest pythonis arendamise kogemust ja mul on alati hea meel kuulda konstruktiivset kriitikat oma oskuste parandamiseks.

Samuti avastasin selle käigus, et pythonil on kaks jooksvat versiooni 2 ja 3, mille tulemusena leppisin kolmandaga.

Riistvara sõlmed

Ühe plaadiga vim2

Põhimasinaks anti mulle ühe pardaarvuti vim2

Suurepärane võimas meediumiprotsessor targa kodu ja SMART-TV jaoks, kuid selle ülesande jaoks äärmiselt sobimatu või, ütleme, halvasti. Näiteks selle peamine OS on Android ja Linux on teisene OS ning seetõttu ei garanteeri keegi Linuxi all olevate sõlmede ja draiverite kvaliteetset tööd. Ja ma eeldan, et mõned probleemid olid seotud selle platvormi USB-draiveritega, nii et modemid ei töötanud sellel plaadil ootuspäraselt. Sellel on ka väga kehv ja laialivalguv dokumentatsioon, nii et iga toiming võttis palju aega dokkides kaevates. Isegi tavaline töö GPIO-ga võttis palju verd. Näiteks LED-i seadistamine võttis mul mitu tundi. Aga kui olla objektiivne, siis põhimõtteliselt ei olnud oluline, mis tüüpi ühe plaadiga on tegu, peaasi, et töötas ja USB-pesad olid.

Esiteks pean ma sellele tahvlile installima Linuxi. Kirjutan seda peatükki, et mitte kõigi ja ka nende jaoks, kes selle ühe tahvli süsteemiga tegelema hakkavad, dokumentide metsikuid otsi.

Linuxi installimiseks on kaks võimalust: välisele SD-kaardile või sisemisele MMC-le. Üritasin ühe õhtu välja mõelda, kuidas see kaardiga tööle panna, mistõttu otsustasin selle MMC-le installida, kuigi kahtlemata oleks välise kaardiga palju lihtsam töötada.

Püsivara kohta siin viltu öeldud. Tõlgin kummalisest keelest vene keelde. Tahvli välgutamiseks pean ühendama riistvara UART. Ühendas selle järgmiselt.

Tööriista PIN GND: <—> VIMi GPIO pin17
Tööriista PIN-kood TXD: <—> VIMi GPIO (Linux_Rx) pin18
Tööriista PIN RXD: <—> VIMi GPIO (Linux_Tx) pin19
Tööriista PIN VCC: <—> VIMi GPIO pin20

Pärast seda laadisin püsivara alla siit. Konkreetne püsivara versioon VIM1_Ubuntu-server-bionic_Linux-4.9_arm64_EMMC_V20191231.

Selle püsivara üleslaadimiseks vajan utiliite. Lisateavet selle kohta siin. Ma pole proovinud seda Windowsis vilkuda, kuid pean teile paar sõna rääkima Linuxi püsivara kohta. Esiteks installin utiliidid vastavalt juhistele.

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

Aaand... Miski ei tööta. Paar tundi redigeerisin installiskripte, et kõik minu jaoks õigesti installiks. Ma ei mäleta, mida ma seal tegin, aga seal oli ka hobustega tsirkus. Nii et ole ettevaatlik. Kuid ilma nende utiliitideta pole mõtet vim2-d edasi piinata. Parem mitte temaga üldse jamada!

Pärast seitset põrguringi, skripti konfigureerimist ja installimist sain kätte paketi töötavaid utiliite. Ühendasin plaadi USB kaudu oma Linuxi arvutiga ja ühendasin ka UART-i vastavalt ülaltoodud skeemile.
Seadistan oma lemmikminicomi terminali kiiruseks 115200 XNUMX, ilma riist- ja tarkvara veakontrollita. Ja alustame.

VIM2 laadimisel UART terminalis vajutan laadimise peatamiseks klahvi, näiteks tühikuklahvi. Pärast joone ilmumist

kvim2#

Sisestan käsu:

kvim2# run update

Hostis, millest laadime, käivitan:

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

See on kõik, fu. Kontrollisin, tahvlil on Linux. Sisselogimine/parool khadas:khadas.

Pärast seda mõned väikesed algseaded. Edasiseks tööks keelan sudo parooli (jah, mitte turvaline, aga mugav).

sudo visudo

Redigeerin rea vormile ja salvestan

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

Siis muudan praeguse lokaadi nii, et kellaaeg on Moskvas, muidu on see Greenwichis.

sudo timedatectl set-timezone Europe/Moscow

või

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

Kui teil on see raske, ärge seda tahvlit kasutage; Raspberry Pi on parem. Ausalt öeldes.

Modem Huawei e3372h – 153

See modem oli minu jaoks märkimisväärne vereallikas ja tegelikult sai sellest kogu projekti kitsaskoht. Üldiselt ei peegelda nende seadmete nimetus “modem” üldse töö olemust: see on võimas kombain, sellel riistvaral on komposiitseade, mis teeskleb draiverite installimiseks CD-ROM-i, ja seejärel lülitub võrgukaardi režiimi.

Arhitektuuriliselt näeb see Linuxi kasutaja seisukohalt pärast kõiki seadistusi välja selline: pärast modemi ühendamist on mul eth* võrguliides, mis dhcp kaudu saab IP-aadressi 192.168.8.100 ja vaikelüüsi. on 192.168.8.1.

Ja kõige tähtsam hetk! See modemi mudel ei saa töötada modemi režiimis, mida juhivad AT-käsud. Kõik oleks palju lihtsam, luua iga modemi jaoks PPP ühendused ja seejärel nendega opereerida. Aga minu puhul loob “ise” (täpsemalt Linuxi sukelduja udev-reeglite järgi) eth-liidese ja määrab sellele dhcp kaudu IP-aadressi.

Edasise segaduse vältimiseks soovitan unustada sõna “modem” ja öelda võrgukaart ja lüüs, sest sisuliselt on see nagu uue võrgukaardi ühendamine lüüsiga.
Kui modem on üks, siis see erilisi probleeme ei tekita, aga kui neid on rohkem kui üks, nimelt n-tükki, siis tekib järgmine võrgupilt.

See tähendab, n võrgukaarti, millel on sama IP-aadress ja millel kõigil on sama vaikelüüs. Kuid tegelikult on igaüks neist ühendatud oma operaatoriga.

Algselt oli mul lihtne lahendus: kasutades ifconfig või ip käsku lülitage kõik liidesed välja ja lülitage üks kordamööda lihtsalt sisse ja testige seda. Lahendus oli kõigile hea, välja arvatud see, et lülitushetkedel ei saanud ma seadmega ühendust. Ja kuna ümberlülitamine on sagedane ja kiire, polnud mul tegelikult üldse võimalust ühendust luua.

Seetõttu valisin modemite IP-aadresside käsitsi muutmise ja seejärel liikluse suunamise marsruudiseadete abil.

Sellega minu probleemid modemitega ei lõppenud: toiteprobleemide korral kukkusid need välja ja USB-jaoturile oli vaja head stabiilset toiteallikat. Lahendasin selle probleemi, jootsin toite otse jaoturisse. Veel üks probleem, millega ma kokku puutusin ja mis rikkus kogu projekti: pärast seadme taaskäivitamist või külmkäivitamist ei tuvastatud kõiki modemeid ja mitte alati ning ma ei suutnud kindlaks teha, miks see juhtus ja millise algoritmi järgi. Aga kõigepealt asjad kõigepealt.

Et modem korralikult töötaks, installisin usb-modeswitchi paketi.

sudo apt update
sudo apt install -y usb-modeswitch

Pärast seda, pärast ühendamist, tuvastab ja konfigureerib udev-i alamsüsteem modemi õigesti. Kontrollin, ühendades lihtsalt modemi ja veendudes, et võrk ilmub.
Veel üks probleem, mida ma ei suutnud lahendada: kuidas ma saan sellelt modemist operaatori nime, kellega me töötame? Operaatori nimi sisaldub modemi veebiliideses aadressil 192.168.8.1. See on dünaamiline veebileht, mis saab andmeid Ajaxi päringute kaudu, nii et lihtsalt lehe loomine ja nime sõelumine ei toimi. Hakkasin siis uurima, kuidas veebilehte vms arendada ja sain aru, et ajasin mingit jama. Selle tulemusel ta sülitas ja operaator hakkas vastu võtma Speedtest API enda abil.

Palju lihtsam oleks, kui modemil oleks juurdepääs AT-käskude kaudu. Oleks võimalik ümber seadistada, luua ppp ühendus, määrata IP, hankida sideoperaator jne. Aga paraku töötan sellega, mis mulle on antud.

GPS

GPS-vastuvõtjal, mis mulle anti, oli UART-liides ja toide. See ei olnud parim lahendus, kuid siiski toimiv ja lihtne. Vastuvõtja nägi välja umbes selline.

Ausalt öeldes töötasin esimest korda GPS-vastuvõtjaga, aga nagu ma eeldasin, oli meie jaoks kõik juba ammu välja mõeldud. Seega kasutame lihtsalt valmislahendusi.

Esiteks luban uart_AO_B (UART_RX_AO_B, UART_TX_AO_B) GPS-i ühendamiseks.

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

Pärast kontrollin operatsiooni edukust.

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

Ilmselt redigeerib see käsk devtree käigu pealt, mis on väga mugav.

Pärast selle toimingu õnnestumist taaskäivitage ja installige GPS-deemon.

khadas@Khadas:~$ sudo reboot

GPS-deemoni installimine. Installin kõik ja lõikan selle edasiseks seadistamiseks kohe ära.

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

Seadete faili redigeerimine.

sudo vim /etc/default/gpsd

Paigaldan UART-i, millele GPS ripub.

DEVICES="/dev/ttyS4"

Ja siis lülitame kõik sisse ja alustame.

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

Peale seda ühendan GPS-i.

GPS-juhe on käes, UART siluri juhtmed paistavad näppude all.

Taaskäivitan ja kontrollin GPS-i tööd programmi gpsmon abil.

Sellel ekraanipildil te satelliite ei näe, kuid näete sidet GPS-vastuvõtjaga ja see tähendab, et kõik on korras.

Pythonis proovisin selle deemoniga töötamiseks palju võimalusi, kuid otsustasin ühe, mis python 3-ga õigesti töötas.

Installin vajaliku raamatukogu.

sudo -H pip3 install gps3

Ja ma kujundan töökoodi.

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

Kui mul on vaja koordinaate hankida, tehakse seda järgmise kõnega:

longitude, latitude = getPositionData(agps_thread)

Ja 1-10 sekundi jooksul saan koordinaadi kätte või mitte. Jah, mul oli kümme katset koordinaate saada. Pole optimaalne, viltu ja viltu, aga töötab. Otsustasin seda teha, kuna GPS-il võib olla halb vastuvõtt ja see ei saa alati andmeid vastu võtta. Kui ootate andmete vastuvõtmist, siis kui töötate kauges ruumis, hangub programm selles kohas. Seetõttu rakendasin selle ebaelegantse võimaluse.

Põhimõtteliselt, kui aega oleks rohkem, siis oleks võimalik GPS-ist otse UART-i kaudu andmeid vastu võtta, eraldi lõimesse sõeluda ja sellega töötada. Aga aega polnud üldse, sellest ka jõhkralt inetu kood. Ja jah, ma ei häbene.

Valgusdiood

LED-i ühendamine oli lihtne ja keeruline samal ajal. Peamine raskus seisneb selles, et süsteemi pin number ei vasta tahvlil olevale pin numbrile ja kuna dokumentatsioon on kirjutatud vasaku käega. Riistvara PIN-koodi ja OS-i PIN-koodi võrdlemiseks peate käivitama käsu:

gpio readall

Kuvatakse tihvtide vastavustabel süsteemis ja tahvlil. Pärast mida saan PIN-koodiga juba operatsioonisüsteemis endas kasutada. Minu puhul on LED ühendatud GPIOH_5.

Lülitan GPIO viigu väljundrežiimi.

gpio -g mode 421 out

Kirjutan nulli.

gpio -g write 421 0

Panen ühe kirja.

gpio -g write 421 1

Kõik põleb pärast "1" kirjutamist

#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 kutsun vigade korral error_blink() ja LED vilgub ilusti.

Tarkvara sõlmed

Speedtest API

On suur rõõm, et speedtest.net teenusel on oma python-API, võite vaadata Github.

Hea on see, et on olemas lähtekoodid, mida saab ka vaadata. Selle API-ga töötamise (lihtsad näited) leiate siit asjakohane jaotis.

Installin pythoni teegi järgmise käsuga.

sudo -H pip3 install speedtest-cli

Näiteks saate isegi otse tarkvarast installida Ubuntu kiirustesti. See on sama pythoni rakendus, mille saab seejärel otse konsoolist käivitada.

sudo apt install speedtest-cli -y

Ja mõõta oma Interneti kiirust.

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

Selle tulemusena täpselt nagu mina. Pidin tutvuma selle kiirustesti lähtekoodidega, et neid oma projektis täielikumalt rakendada. Üks tähtsamaid ülesandeid on hankida sideoperaatori nimi, et see plaadile asendada.

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"
#тут идет запись в файл логов

Ka siin ei osutus kõik nii lihtsaks, kuigi tunduks palju lihtsam. Algselt oli serveri parameeter võrdne [], nad ütlevad, et vali parim server. Selle tulemusena olid mul juhuslikud serverid ja, nagu võite arvata, muutuva kiirusega. See on üsna keeruline teema, fikseeritud serveri kasutamine, kui jah, siis staatiline või dünaamiline, nõuab uurimist. Kuid siin on näide Beeline'i operaatori kiiruse mõõtmise graafikutest testserveri ja staatiliselt fikseeritud serveri dünaamilisel valimisel.

Dünaamilise serveri valimisel kiiruse mõõtmise tulemus.

Kiirustestimise tulemus, ühe rangelt valitud ühe serveriga.

Katsetamise ajal on mõlemas kohas “karusnahk” ja see tuleb matemaatiliste meetodite abil eemaldada. Kuid fikseeritud serveriga on seda veidi vähem ja amplituud on stabiilsem.
Üldiselt on see suure uurimistöö koht. Ja ma mõõdaksin oma serveri kiirust iperf utiliidi abil. Kuid me jääme tehniliste kirjelduste juurde.

Kirjade saatmine ja vead

Kirja saatmiseks proovisin mitukümmend erinevat võimalust, kuid lõpuks leppisin järgmisega. Registreerisin Yandexis postkasti ja võtsin siis See on näide kirja saatmisest. Kontrollisin seda ja juurutasin programmi. See näide uurib erinevaid võimalusi, sealhulgas gmailist saatmist jne. Ma ei tahtnud oma meiliserveri seadistamisega vaeva näha ega olnud aega, aga nagu hiljem selgus, oli see ka asjata.

Logid saadeti ajakava järgi, kui on seos, iga 6 tunni järel: kell 00, 06, 12 ja 18. Saatis selle järgmiselt.

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

Esialgu saadeti ka vead. Alustuseks koguti need loendisse ja seejärel saadeti ühenduse olemasolul ka ajakava abil. Siis aga tekkisid probleemid sellega, et Yandexil on päevas saadetavate sõnumite arvu piirang (see on valu, kurbus ja alandus). Kuna vigu võis esineda tohutult isegi minutis, pidime vigade posti teel saatmisest loobuma. Nii et pidage meeles, kui saadate automaatselt teavet sellise probleemi kohta Yandexi teenuste kaudu.

Tagasiside server

Selleks, et pääseda juurde kaugriistvarale ning saaksin seda kohandada ja ümber konfigureerida, vajasin välist serverit. Üldiselt, ausalt öeldes oleks õige saata kõik andmed serverisse ja ehitada kõik ilusad graafikud veebiliidesesse. Kuid mitte kõik korraga.

VPS-i jaoks valisin ruvds.com. Võite võtta kõige lihtsama serveri. Ja üldiselt minu eesmärkidel piisaks sellest. Aga kuna ma serveri eest omast taskust ei maksnud, otsustasin selle väikese varuga võtta, et piisaks sellest, kui kasutusele võtame veebiliidese, oma SMTP-serveri, VPN-i jne. Lisaks saate seadistada Telegrami robotit ja teil pole probleeme selle blokeerimisega. Seetõttu valisin Amsterdami ja järgmised parameetrid.

Riistvaraga suhtlemise meetodiks valis vim2 vastupidise ssh-ühenduse ja nagu praktika on näidanud, pole see kõige parem. Kui ühendus katkeb, hoiab server porti ja selle kaudu ei saa mõnda aega ühendust luua. Seetõttu on siiski parem kasutada muid suhtlusviise, näiteks VPN-i. Tulevikus tahtsin VPN-ile üle minna, kuid mul polnud aega.

Ma ei hakka üksikasjalikult kirjeldama tulemüüri seadistamist, õiguste piiramist, juur-ssh-ühenduste keelamist ja muid VPS-i seadistamise fakte. Tahaks uskuda, et sa juba tead kõike. Kaugühenduse jaoks loon serverisse uue kasutaja.

adduser vimssh

Loon meie riistvaras ssh-ühendusvõtmed.

ssh-keygen

Ja ma kopeerin need meie serverisse.

ssh-copy-id [email protected]

Meie riistvaras loon igal alglaadimisel automaatse vastupidise ssh-ühenduse.

[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

Pöörake tähelepanu pordile 8083: see määrab, millist porti ma pöörd-ssh-i kaudu ühenduse loomiseks kasutan. Lisage see käivitamisse ja käivitage.

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

Näete isegi olekut:

sudo systemctl status autossh.service

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

ssh -p 8083 khadas@localhost

Siis jõuan oma riistvara proovitüki juurde. Ja riistvarast saan ka logisid ja suvalisi andmeid ssh kaudu oma serverisse saata, mis on väga mugav.

Kogu see kokku

Sisselülitamisel alustame arendust ja silumist

Pheh, see on kõik, ma kirjeldasin kõiki sõlme. Nüüd on aeg see kõik kokku panna. Saate koodi näha siin.

Oluline punkt koodiga: see projekt ei pruugi nii alata, kuna see oli kohandatud konkreetse ülesande, konkreetse arhitektuuri jaoks. Kuigi ma annan lähtekoodi, selgitan ma ikkagi kõige väärtuslikumad asjad siin, otse tekstis, muidu on see täiesti arusaamatu.

Alguses initsialiseerin gps-i, gpio ja käivitan eraldi planeerija lõime.

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

Ajastaja on üsna lihtne: vaatab, kas on saabunud aeg sõnumite saatmiseks ja milline on hetkel veateade. Kui on vealipp, vilgutame LED-i.

#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 iga testi jaoks vastupidise ssh-ühenduse säilitamine. Iga test hõlmab vaikelüüsi ja DNS-serveri uuesti konfigureerimist. Kuna keegi nagunii ei loe, siis teadke, et rong ei sõida puurööpadel. Kes lihavõttemuna leiab, saab kommi.

Selleks koostan eraldi marsruutimistabeli -set-mark 0x2 ja reegli liikluse ümbersuunamiseks.

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

Saate selle toimimise kohta lisateavet loe sellest artiklist.

Pärast seda lähen lõputusse ahelasse, kus iga kord saame ühendatud modemite loendi (et teada saada, kas võrgu konfiguratsioon on ootamatult muutunud).

network_list = getNetworklist()

Võrguliideste loendi hankimine on üsna 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

Peale nimekirja kättesaamist seadsin kõikidele liidestele IP-aadressid, nagu modemit käsitlevas peatükis pildil näitasin.

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

Siis ma lihtsalt läbin iga liidese tsüklina. Ja ma konfigureerin iga liidese.

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

Kontrollin liidese funktsionaalsust, kui võrku pole, genereerin vigu. Kui võrk on olemas, siis on aeg tegutseda!

Siin seadistan sellele liidesele ssh-marsruutimise (kui seda pole tehtud), saadan vead serverisse, kui aeg on käes, saadan logid ja lõpuks käivitan kiirustesti ja salvestan logid csv-faili.

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()
#и далее тестируем скорость и сохраняем логи.

Tasub mainida reverse ssh seadistamise funktsiooni.

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 peate kogu selle ilu käivitamisse lisama. Selleks loon faili:

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

Ja ma kirjutan sellesse:

[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

Lülitan automaatse laadimise sisse ja alustan!

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

Nüüd näen toimuvate logisid, kasutades käsku:

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

Järeldused

Noh, nüüd on kõige tähtsam, mis selle tulemusel juhtus? Siin on mõned graafikud, mis mul õnnestus arendus- ja silumisprotsessi käigus jäädvustada. Graafikud koostati gnuploti abil järgmise skriptiga.

#! /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 mitu päeva läbi.

Siin kasutasin dünaamilist mõõteserverit. Kiiruse mõõtmised töötavad, kuid kõiguvad väga palju, kuid mõni keskmine väärtus on siiski näha ja seda saab andmete filtreerimisel näiteks liikuva keskmisega.

Hiljem koostasin hulga graafikuid teistele sideoperaatoritele. Antud juhul oli juba üks testimisserver ja ka tulemused olid väga huvitavad.

Nagu näete, on teema nende andmete uurimiseks ja töötlemiseks väga mahukas ning ilmselgelt ei kesta paarinädalast tööd. Aga…

Töö tulemus

Töö sai minust sõltumatutel asjaoludel ootamatult valmis. Selle projekti üks nõrkus oli minu subjektiivse hinnangu kohaselt modem, mis tegelikult ei tahtnud teiste modemitega samaaegselt töötada ja tegi selliseid nippe iga kord, kui seda laaditi. Nendel eesmärkidel on palju muid modemimudeleid, tavaliselt on need juba Mini PCI-e formaadis ja installitud seadmesse ning neid on palju lihtsam konfigureerida. Aga see on hoopis teine lugu. Projekt oli huvitav ja mul oli väga hea meel, et sain selles osaleda.

Allikas: www.habr.com

Samaaegne kiirustest mitmel LTE-modemil