სიჩქარის ერთდროული ტესტირება რამდენიმე LTE მოდემზე

კარანტინის დროს შემომთავაზეს მონაწილეობა მიმეღო LTE მოდემის სიჩქარის საზომი მოწყობილობის შემუშავებაში რამდენიმე ფიჭური ოპერატორისთვის.

მომხმარებელს სურდა შეეფასებინა სხვადასხვა სატელეკომუნიკაციო ოპერატორის სიჩქარე სხვადასხვა გეოგრაფიულ ადგილას, რათა გაეგო, რომელი ფიჭური ოპერატორი იყო მისთვის ყველაზე ოპტიმალური LTE კავშირის გამოყენებით აღჭურვილობის დაყენებისას, მაგალითად, ვიდეო მაუწყებლობისთვის. ამავდროულად, პრობლემა უნდა მოგვარებულიყო რაც შეიძლება მარტივად და იაფად, ძვირადღირებული აღჭურვილობის გარეშე.

მაშინვე ვიტყვი, რომ ამოცანა არ არის უმარტივესი და ცოდნის ინტენსიური, გეტყვით რა პრობლემებს წავაწყდი და როგორ მოვაგვარე ისინი. მაშ, წავიდეთ.

შენიშვნა

LTE კავშირის სიჩქარის გაზომვა ძალიან რთული საკითხია: თქვენ უნდა აირჩიოთ სწორი აღჭურვილობა და გაზომვის ტექნიკა, ასევე კარგად გესმოდეთ ფიჭური ქსელის ტოპოლოგია და ფუნქციონირება. გარდა ამისა, სიჩქარეზე შეიძლება გავლენა იქონიოს რამდენიმე ფაქტორმა: აბონენტების რაოდენობა უჯრედზე, ამინდის პირობები, თუნდაც უჯრედიდან უჯრედამდე, სიჩქარე შეიძლება მკვეთრად განსხვავდებოდეს ქსელის ტოპოლოგიის გამო. ზოგადად, ეს არის პრობლემა დიდი რაოდენობით უცნობებთან და მხოლოდ ტელეკომის ოპერატორს შეუძლია მისი სწორად გადაჭრა.

თავდაპირველად მომხმარებელს მხოლოდ ოპერატორების ტელეფონებით სურდა კურიერის მართვა, პირდაპირ ტელეფონზე გაზომვები და შემდეგ სიჩქარის გაზომვის შედეგები ნოუთბუქში ჩაწერა. lte ქსელების სიჩქარის გაზომვის ჩემი გამოსავალი, თუმცა იდეალური არ არის, პრობლემას აგვარებს.

დროის უქონლობის გამო მივიღე გადაწყვეტილებები არა მოხერხებულობის ან პრაქტიკულობის, არამედ განვითარების სიჩქარის სასარგებლოდ. მაგალითად, საპირისპირო ssh გამოიყენებოდა დისტანციური წვდომისთვის, უფრო პრაქტიკული VPN-ის ნაცვლად, სერვერის და თითოეული ინდივიდუალური კლიენტის დაყენებაზე დროის დაზოგვის მიზნით.

ტექნიკური დავალება

როგორც სტატიაშია ნათქვამი ტექნიკური მახასიათებლების გარეშე: რატომ არ სურს კლიენტს ეს: არ იმუშაოთ ტექნიკური მახასიათებლების გარეშე! არასოდეს, არსად!

ტექნიკური დავალება საკმაოდ მარტივი იყო, ცოტას გავაფართოვებ საბოლოო მომხმარებლის გასაგებად. ტექნიკური გადაწყვეტილებებისა და აღჭურვილობის არჩევანი მომხმარებლის მიერ იყო ნაკარნახევი. ასე რომ, თავად ტექნიკური სპეციფიკაცია, ყველა დამტკიცების შემდეგ:

დაფუძნებულია ერთი დაფის კომპიუტერზე ვიმ 2 გააკეთეთ სიჩქარის ტესტერი lte კავშირებისთვის H მოდემის საშუალებითuawei e3372h - 153 რამდენიმე ტელეკომის ოპერატორი (ერთიდან n-მდე). ასევე აუცილებელია კოორდინატების მიღება UART-ით დაკავშირებული GPS მიმღებიდან. გააკეთეთ სიჩქარის გაზომვები სერვისის გამოყენებით www.speedtest.net და მოათავსეთ ისინი ასეთ ცხრილში:

ცხრილი csv ფორმატში. შემდეგ გაგზავნეთ ეს ნიშანი ელექტრონული ფოსტით ყოველ 6 საათში. შეცდომის შემთხვევაში, მოციმციმე LED, რომელიც დაკავშირებულია GPIO-სთან.

მე აღვწერე ტექნიკური მახასიათებლები უფასო ფორმით, მრავალი დამტკიცების შემდეგ. მაგრამ დავალების მნიშვნელობა უკვე ჩანს. ყველაფერზე ერთი კვირა იყო მოცემული. მაგრამ სინამდვილეში ეს სამი კვირა გაგრძელდა. ეს იმის გათვალისწინებით, რომ მე ამას გავაკეთებდი მხოლოდ ჩემი მთავარი სამუშაოს შემდეგ და შაბათ-კვირას.

აქვე მინდა კიდევ ერთხელ გავამახვილო ყურადღება იმ ფაქტზე, რომ მომხმარებელი წინასწარ შეთანხმდა სიჩქარის საზომი სერვისისა და აპარატურის გამოყენებაზე, რამაც მნიშვნელოვნად შეზღუდა ჩემი შესაძლებლობები. ბიუჯეტიც შეზღუდული იყო, ამიტომ განსაკუთრებული არაფერი შეიძინა. ამიტომ ამ წესებით უნდა გვეთამაშა.

არქიტექტურა და განვითარება

სქემა მარტივი და გასაგებია. ამიტომ, განსაკუთრებული კომენტარის გარეშე დავტოვებ.

გადავწყვიტე მთელი პროექტი განმეხორციელებინა პითონში, მიუხედავად იმისა, რომ ამ ენაში განვითარების გამოცდილება საერთოდ არ მქონდა. მე ავირჩიე ის, რადგან იყო უამრავი მზა მაგალითი და გადაწყვეტილებები, რომლებსაც შეეძლოთ განვითარების დაჩქარება. ამიტომ, ყველა პროფესიონალ პროგრამისტს ვთხოვ, არ გაკიცხოს პითონში განვითარების ჩემი პირველი გამოცდილება და ყოველთვის სიამოვნებით მოვისმენ კონსტრუქციულ კრიტიკას ჩემი უნარების გასაუმჯობესებლად.

ასევე ამ პროცესში აღმოვაჩინე, რომ პითონს აქვს ორი გაშვებული ვერსია 2 და 3, რის შედეგადაც მე დავრჩი მესამეზე.

აპარატურის კვანძები

ერთსართულიანი vim2

მთავარ მანქანად მაჩუქეს ერთბორტიანი კომპიუტერი ვიმ 2

შესანიშნავი, ძლიერი მედია პროცესორი ჭკვიანი სახლისთვის და SMART-TV-სთვის, მაგრამ უკიდურესად შეუფერებელი ამ ამოცანისთვის, ან, ვთქვათ, ცუდად შესაფერისი. მაგალითად, მისი მთავარი OS არის Android, ხოლო Linux არის მეორადი OS და, შესაბამისად, არავინ იძლევა გარანტიას ყველა კვანძისა და დრაივერის მაღალხარისხიან მუშაობაზე Linux-ის ქვეშ. და მე ვვარაუდობ, რომ ზოგიერთი პრობლემა დაკავშირებული იყო ამ პლატფორმის USB დრაივერებთან, ამიტომ მოდემები არ მუშაობდნენ ისე, როგორც მოსალოდნელი იყო ამ დაფაზე. მას ასევე აქვს ძალიან ცუდი და მიმოფანტული დოკუმენტაცია, ამიტომ თითოეულ ოპერაციას დიდი დრო დასჭირდა დოქების გათხრას. GPIO-სთან ჩვეულებრივ მუშაობასაც კი ბევრი სისხლი წაუღია. მაგალითად, რამდენიმე საათი დამჭირდა LED-ის დაყენება. მაგრამ, ობიექტური რომ ვიყოთ, ფუნდამენტურად არ იყო მნიშვნელოვანი, როგორი ერთი დაფა იყო, მთავარი ის იყო, რომ მუშაობდა და იყო USB პორტები.

პირველ რიგში, მე უნდა დავაყენო Linux ამ დაფაზე. იმისთვის, რომ ყველასთვის და ასევე მათთვის, ვინც ამ ერთიანი დაფის სისტემასთან გაუმკლავდება, მე ვწერ ამ თავს.

Linux-ის დაყენების ორი ვარიანტი არსებობს: გარე SD ბარათზე ან შიდა MMC-ზე. ერთი საღამო გავატარე იმის გარკვევაში, თუ როგორ გამეკეთებინა იგი ბარათთან, ამიტომ გადავწყვიტე მისი დაყენება MMC-ზე, თუმცა ეჭვგარეშეა ბევრად უფრო ადვილი იქნებოდა გარე ბარათთან მუშაობა.

firmware-ის შესახებ უხერხულად თქვა აქ. ვთარგმნი უცნაურიდან რუსულად. დაფის გასანათებლად, მე უნდა დავაკავშირო აპარატურის UART. დააკავშირა შემდეგნაირად.

• ხელსაწყოს პინი GND: <—> VIM-ის GPIO-ის Pin17
• ხელსაწყოს PIN TXD: <—> VIM-ების GPIO-ის Pin18 (Linux_Rx)
• ხელსაწყოს PIN RXD: <—> PIN19 VIM-ების GPIO-დან (Linux_Tx)
• ხელსაწყოს დამაგრება VCC: <—> VIM-ების GPIO-ის Pin20

რის შემდეგაც ჩამოვტვირთე firmware აქედან გამომდინარე,. სპეციფიკური firmware ვერსია VIM1_Ubuntu-server-bionic_Linux-4.9_arm64_EMMC_V20191231.

ამ პროგრამული უზრუნველყოფის ატვირთვისთვის მე მჭირდება კომუნალური პროგრამები. მეტი დეტალი ამის შესახებ აქ. მე არ მიცდია მისი გამორთვა Windows-ში, მაგრამ უნდა გითხრათ რამდენიმე სიტყვა firmware-ის შესახებ Linux-ში. პირველ რიგში, მე დავაყენებ კომუნალურ პროგრამებს ინსტრუქციის მიხედვით.

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

ააან... არაფერი მუშაობს. რამდენიმე საათი დავხარჯე ინსტალაციის სკრიპტების რედაქტირებაში, რათა ყველაფერი სწორად დამეყენებინა. არ მახსოვს იქ რა გავაკეთე, მაგრამ ცირკიც იყო ცხენებით. ასე რომ ფრთხილად იყავი. მაგრამ ამ კომუნალური საშუალებების გარეშე აზრი არ აქვს vim2-ის შემდგომ წამებას. ჯობია მას საერთოდ არ ერევა!

ჯოჯოხეთის შვიდი წრის, სკრიპტის კონფიგურაციისა და ინსტალაციის შემდეგ, მივიღე სამუშაო კომუნალური საშუალებების პაკეტი. დაფა USB-ით დავაკავშირე ლინუქსის კომპიუტერზე და ასევე დავაკავშირე UART ზემოთ მოცემული სქემის მიხედვით.
მე ვაყენებ ჩემს საყვარელ მინიკომის ტერმინალს 115200 სიჩქარით, აპარატურის და პროგრამული უზრუნველყოფის შეცდომების კონტროლის გარეშე. და დავიწყოთ.

VIM2-ის UART ტერმინალში ჩატვირთვისას, მე ვაჭერ კლავიშს, როგორიცაა spacebar, ჩატვირთვის შესაჩერებლად. მას შემდეგ, რაც ხაზი გამოჩნდება

kvim2# 

შევიყვან ბრძანებას:

kvim2# run update

ჰოსტზე, საიდანაც ვტვირთავთ, ვასრულებ:

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

ეს არის ის, ფუ. შევამოწმე, დაფაზე არის ლინუქსი. შესვლა/პაროლი khadas:khadas.

ამის შემდეგ, რამდენიმე მცირე საწყისი პარამეტრი. შემდგომი მუშაობისთვის, მე გამორთე პაროლი სუდოსთვის (დიახ, არა უსაფრთხო, მაგრამ მოსახერხებელი).

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

თუ გაგიჭირდებათ, არ გამოიყენოთ ეს დაფა; Raspberry Pi უკეთესია. პატიოსნად.

მოდემი Huawei e3372h – 153

ეს მოდემი ჩემთვის სისხლის მნიშვნელოვანი წყარო იყო და, ფაქტობრივად, მთელი პროექტის ბლოკირებად იქცა. ზოგადად, ამ მოწყობილობების სახელწოდება "მოდემი" საერთოდ არ ასახავს სამუშაოს არსს: ეს არის მძლავრი კომბაინი, ამ აპარატურულ ნაწილს აქვს კომპოზიტური მოწყობილობა, რომელიც ვითომ CD-ROM-ად არის დრაივერების დასაყენებლად. და შემდეგ გადადის ქსელის ბარათის რეჟიმში.

არქიტექტურულად, Linux მომხმარებლის თვალსაზრისით, ყველა პარამეტრის შემდეგ ასე გამოიყურება: მოდემის მიერთების შემდეგ მაქვს eth* ქსელის ინტერფეისი, რომელიც dhcp-ის საშუალებით იღებს IP მისამართს 192.168.8.100 და ნაგულისხმევ კარიბჭეს. არის 192.168.8.1.

და ყველაზე მნიშვნელოვანი მომენტი! მოდემის ეს მოდელი ვერ მუშაობს მოდემის რეჟიმში, რომელიც კონტროლდება AT ბრძანებებით. ყველაფერი ბევრად უფრო მარტივი იქნებოდა, შექმენით PPP კავშირები თითოეული მოდემისთვის და შემდეგ იმუშავეთ მათთან. მაგრამ ჩემს შემთხვევაში, „თვითონ“ (უფრო ზუსტად, Linux-ის მყვინთავი udev-ის წესების მიხედვით), ქმნის eth ინტერფეისს და ანიჭებს მას IP მისამართს dhcp-ის საშუალებით.

შემდგომი დაბნეულობის თავიდან ასაცილებლად, გირჩევთ დაივიწყოთ სიტყვა „მოდემი“ და თქვათ ქსელის ბარათი და კარიბჭე, რადგან არსებითად, ეს არის ახალი ქსელის ბარათის კარიბჭესთან დაკავშირება.
როდესაც არის ერთი მოდემი, ეს არ იწვევს რაიმე განსაკუთრებულ პრობლემას, მაგრამ როდესაც არის ერთზე მეტი, კერძოდ, n-ცალი, ჩნდება შემდეგი ქსელის სურათი.

ანუ n ქსელის ბარათი, იგივე IP მისამართით, თითოეულს იგივე ნაგულისხმევი კარიბჭე. მაგრამ სინამდვილეში, თითოეული მათგანი დაკავშირებულია საკუთარ ოპერატორთან.

თავდაპირველად, მე მქონდა მარტივი გამოსავალი: ifconfig ან ip ბრძანების გამოყენებით, გამორთეთ ყველა ინტერფეისი და უბრალოდ ჩართეთ ერთი თავის მხრივ და შეამოწმეთ იგი. გამოსავალი ყველასთვის კარგი იყო, გარდა იმისა, რომ გადართვის მომენტებში ვერ ვახერხებდი მოწყობილობას დაკავშირებას. და რადგან გადართვა ხშირი და სწრაფია, მე რეალურად საერთოდ არ მქონდა დაკავშირების შესაძლებლობა.

ამიტომ, მე ავირჩიე მოდემის IP მისამართების ხელით შეცვლა და შემდეგ ტრაფიკის მართვა მარშრუტიზაციის პარამეტრების გამოყენებით.

ამით არ დასრულებულა ჩემი პრობლემები მოდემებთან: დენის პრობლემების შემთხვევაში, ისინი იშლებოდნენ და საჭირო იყო USB კერის კარგი სტაბილური კვების წყარო. მე გადავწყვიტე ეს პრობლემა ელექტროენერგიის პირდაპირ კერაზე მყარი შედუღებით. კიდევ ერთი პრობლემა, რომელიც შემხვდა და რომელმაც გააფუჭა მთელი პროექტი: მოწყობილობის გადატვირთვის ან ცივი დაწყების შემდეგ, ყველა მოდემი არ იქნა აღმოჩენილი და არა ყოველთვის, და მე ვერ დავადგინე, რატომ მოხდა ეს და რა ალგორითმით. მაგრამ პირველ რიგში.

იმისთვის, რომ მოდემმა სწორად იმუშაოს, დავაყენე usb-modeswitch პაკეტი.

sudo apt update
sudo apt install -y usb-modeswitch

რის შემდეგაც, დაკავშირების შემდეგ, მოდემი სწორად იქნება გამოვლენილი და კონფიგურირებული udev ქვესისტემის მიერ. ვამოწმებ უბრალოდ მოდემის შეერთებით და დარწმუნდებით, რომ ქსელი გამოჩნდება.
კიდევ ერთი პრობლემა, რომელიც ვერ მოვაგვარე: როგორ მივიღო ამ მოდემიდან იმ ოპერატორის სახელი, რომლითაც ვმუშაობთ? ოპერატორის სახელს შეიცავს მოდემის ვებ ინტერფეისი 192.168.8.1. ეს არის დინამიური ვებ გვერდი, რომელიც იღებს მონაცემებს Ajax-ის მოთხოვნის საშუალებით, ასე რომ, გვერდის უბრალოდ გადატვირთვა და სახელის გარჩევა არ იმუშავებს. ასე დავიწყე ყურება, როგორ შემექმნა ვებ გვერდი და ა.შ. და მივხვდი, რომ რაღაც სისულელეს ვაკეთებდი. შედეგად, მან გადააფურთხა და ოპერატორმა დაიწყო მიღება თავად Speedtest API-ის გამოყენებით.

ბევრად უფრო ადვილი იქნებოდა, თუ მოდემს წვდომა ექნება AT ბრძანებების საშუალებით. შესაძლებელი იქნებოდა მისი ხელახლა კონფიგურაცია, ppp კავშირის შექმნა, IP-ის მინიჭება, ტელეკომის ოპერატორის მიღება და ა.შ. მაგრამ სამწუხაროდ, მე ვმუშაობ იმით, რაც მომცეს.

GPS

GPS მიმღებს, რომელიც მე მომცეს, ჰქონდა UART ინტერფეისი და სიმძლავრე. ეს არ იყო საუკეთესო გამოსავალი, მაგრამ მაინც გამოსადეგი და მარტივი იყო. მიმღები ასე გამოიყურებოდა.

მართალი გითხრათ, პირველად ვმუშაობდი GPS მიმღებთან, მაგრამ როგორც ველოდი, ჩვენთვის ყველაფერი დიდი ხნის წინ იყო მოფიქრებული. ამიტომ ჩვენ უბრალოდ ვიყენებთ მზა გადაწყვეტილებებს.

პირველ რიგში, მე ვააქტიურებ uart_AO_B (UART_RX_AO_B, UART_TX_AO_B) GPS-ის დასაკავშირებლად.

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

ამის შემდეგ ვამოწმებ ოპერაციის წარმატებას.

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

ეს ბრძანება აშკარად არედაქტირებს devtree-ს, რაც ძალიან მოსახერხებელია.

ამ ოპერაციის წარმატების შემდეგ, გადატვირთეთ და დააინსტალირეთ GPS დემონი.

khadas@Khadas:~$ sudo reboot

GPS დემონის დაყენება. ყველაფერს ვაყენებ და მაშინვე ვწყვეტ შემდგომი კონფიგურაციისთვის.

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

ვაყენებ UART-ს, რომელზეც GPS დაკიდება.

DEVICES="/dev/ttyS4"

შემდეგ ჩვენ ჩართავთ ყველაფერს და ვიწყებთ.

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

ამის შემდეგ ვუერთდები GPS-ს.

GPS მავთული ჩემს ხელშია, UART გამართვის მავთულები ჩანს ჩემი თითების ქვეშ.

გადავტვირთავ და ვამოწმებ GPS მუშაობას gpsmon პროგრამის გამოყენებით.

თქვენ ვერ ხედავთ თანამგზავრებს ამ ეკრანის სურათზე, მაგრამ ხედავთ კომუნიკაციას GPS მიმღებთან და ეს ნიშნავს, რომ ყველაფერი კარგადაა.

პითონში მე ვცადე ბევრი ვარიანტი ამ დემონთან მუშაობისთვის, მაგრამ გადავწყვიტე ის, რომელიც სწორად მუშაობდა პითონ 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 წამში ან მივიღებ კოორდინატს ან არა. დიახ, კოორდინატების მოპოვების ათი მცდელობა მქონდა. არა ოპტიმალური, დახრილი და დახრილი, მაგრამ მუშაობს. მე გადავწყვიტე ამის გაკეთება, რადგან GPS-ს შეიძლება ჰქონდეს ცუდი მიღება და ყოველთვის არ მიიღოს მონაცემები. თუ დაელოდებით მონაცემების მიღებას, მაშინ თუ მუშაობთ დისტანციურ ოთახში, პროგრამა გაყინავს ამ ადგილას. ამიტომ განვახორციელე ეს არაელეგანტური ვარიანტი.

პრინციპში, თუ მეტი დრო იქნებოდა, შესაძლებელი იქნებოდა GPS-დან მონაცემების მიღება უშუალოდ UART-ის საშუალებით, ცალკე თემაში გაანალიზება და მასთან მუშაობა. მაგრამ დრო საერთოდ არ იყო, აქედან გამომდინარეობს სასტიკად მახინჯი კოდი. დიახ, მე არ მრცხვენია.

სინათლის დიოდი

LED-ის დაკავშირება მარტივი და რთული იყო ამავე დროს. მთავარი სირთულე ის არის, რომ სისტემაში არსებული პინის ნომერი არ შეესაბამება დაფაზე არსებულ პინის ნომერს და იმიტომ, რომ დოკუმენტაცია იწერება მარცხენა ხელით. ოპერაციული სისტემის ტექნიკის პინის ნომრისა და პინის ნომრის შესადარებლად, თქვენ უნდა შეასრულოთ ბრძანება:

gpio readall

სისტემაში და დაფაზე ქინძისთავის კორესპონდენციის ცხრილი გამოჩნდება. რის შემდეგაც მე უკვე შემიძლია ოპერაციული პინი თავად OS-ში. ჩემს შემთხვევაში LED უკავშირდება GPIOH_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()-ს და შუქნიშანი ლამაზად აციმციმდება.

პროგრამული კვანძები

Speedtest API

დიდი სიხარულია, რომ speedtest.net სერვისს აქვს საკუთარი python-API, შეგიძლიათ ნახოთ Github.

კარგი ის არის, რომ არსებობს წყაროს კოდები, რომელთა ნახვაც შესაძლებელია. როგორ ვიმუშაოთ ამ API-სთან (მარტივი მაგალითები) შეგიძლიათ იხილოთ აქ შესაბამისი განყოფილება.

მე დავაინსტალირე პითონის ბიბლიოთეკა შემდეგი ბრძანებით.

sudo -H pip3 install speedtest-cli

მაგალითად, თქვენ შეგიძლიათ დააინსტალიროთ სიჩქარის ტესტერი Ubuntu-ში პირდაპირ პროგრამული უზრუნველყოფის საშუალებით. ეს არის იგივე პითონის აპლიკაცია, რომლის გაშვება შესაძლებელია პირდაპირ კონსოლიდან.

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 უტილიტის გამოყენებით. მაგრამ ჩვენ ვიცავთ ტექნიკურ მახასიათებლებს.

ფოსტის გაგზავნა და შეცდომები

ფოსტის გასაგზავნად, მე ვცადე რამდენიმე ათეული სხვადასხვა ვარიანტი, მაგრამ საბოლოოდ დავრჩი შემდეგზე. მე დავრეგისტრირე საფოსტო ყუთი Yandex-ზე და შემდეგ ავიღე ეს არის ფოსტის გაგზავნის მაგალითი. შევამოწმე და ჩავატარე პროგრამაში. ეს მაგალითი განიხილავს სხვადასხვა ვარიანტს, მათ შორის გაგზავნას gmail-დან და ა.შ. მე არ მინდოდა შეწუხება ჩემი ფოსტის სერვერის დაყენებით და დრო არ მქონდა, მაგრამ როგორც მოგვიანებით გაირკვა, ეს ასევე უშედეგო იყო.

ჟურნალები გაიგზავნა გრაფიკის მიხედვით, თუ არის კავშირი, ყოველ 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

თავიდანვე იყო შეცდომებიც. დასაწყისისთვის, ისინი დაგროვდა სიაში და შემდეგ გაგზავნეს ასევე გრაფიკის გამოყენებით, თუ კავშირი იყო. თუმცა, შემდეგ პრობლემები წარმოიშვა იმით, რომ Yandex-ს აქვს შეზღუდვა დღეში გაგზავნილი შეტყობინებების რაოდენობაზე (ეს არის ტკივილი, სევდა და დამცირება). იმის გამო, რომ შეიძლება შეცდომის დიდი რაოდენობა იყოს წუთშიც კი, ჩვენ მოგვიწია უარი თქვან შეცდომების ფოსტით გაგზავნაზე. ასე რომ, გაითვალისწინეთ, როდესაც ავტომატურად აგზავნით ინფორმაციას ამ პრობლემის შესახებ Yandex სერვისების საშუალებით.

უკუკავშირის სერვერი

იმისათვის, რომ მქონოდა წვდომა აპარატურის დისტანციურ ნაწილზე და შემეძლო მისი მორგება და კონფიგურაცია, მჭირდებოდა გარე სერვერი. ზოგადად, სამართლიანი რომ ვიყოთ, სწორი იქნება ყველა მონაცემის სერვერზე გაგზავნა და ყველა ლამაზი გრაფიკის აშენება ვებ ინტერფეისში. მაგრამ არა ერთდროულად.

VPS-სთვის მე ავირჩიე ruvds.com. შეგიძლიათ აიღოთ უმარტივესი სერვერი. და ზოგადად, ჩემი მიზნებისთვის ეს საკმარისი იქნებოდა. მაგრამ რადგან მე არ გადავიხადე სერვერზე ჩემი ჯიბიდან, გადავწყვიტე მისი მიღება მცირე რეზერვით, რათა საკმარისი იქნებოდა ვებ ინტერფეისის, ჩვენი საკუთარი SMTP სერვერის, VPN და ა.შ. გარდა ამისა, შეგიძლიათ დააყენოთ Telegram ბოტი და არ შეგექმნათ პრობლემები მის დაბლოკვასთან დაკავშირებით. ამიტომ ავირჩიე ამსტერდამი და შემდეგი პარამეტრები.

როგორც აპარატურასთან კომუნიკაციის მეთოდი, vim2-მა აირჩია საპირისპირო ssh კავშირი და, როგორც პრაქტიკამ აჩვენა, ეს არ არის საუკეთესო. თუ კავშირი დაიკარგება, სერვერი ინახავს პორტს და მისი საშუალებით დაკავშირება გარკვეული დროის განმავლობაში შეუძლებელია. ამიტომ, მაინც უკეთესია კომუნიკაციის სხვა მეთოდების გამოყენება, მაგალითად VPN. მომავალში მინდოდა VPN-ზე გადასვლა, მაგრამ დრო არ მქონდა.

მე არ შევუდგები დეტალებს Firewall-ის დაყენების, უფლებების შეზღუდვის, root ssh კავშირების გამორთვისა და VPS-ის დაყენების სხვა ჭეშმარიტების შესახებ. მინდა დავიჯერო, რომ შენ უკვე ყველაფერი იცი. დისტანციური კავშირისთვის მე ვქმნი ახალ მომხმარებელს სერვერზე.

adduser vimssh

მე ვქმნი ssh კავშირის გასაღებებს ჩვენს აპარატურაზე.

ssh-keygen

და ვაკოპირებ მათ ჩვენს სერვერზე.

ssh-copy-id [email protected]

ჩვენს აპარატურაზე მე ვქმნი ავტომატურ საპირისპირო ssh კავშირს ყოველ ჩატვირთვისას.

[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: ის განსაზღვრავს რომელ პორტს გამოვიყენებ საპირისპირო ssh-ის საშუალებით დასაკავშირებლად. დაამატეთ ის გაშვებაში და დაიწყეთ.

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

სტატუსის ნახვაც კი შეგიძლიათ:

sudo systemctl status autossh.service

ახლა, ჩვენს VPS სერვერზე, თუ გავუშვით:

ssh -p 8083 khadas@localhost

შემდეგ მივდივარ ტექნიკის სატესტო ნაწილზე. და ტექნიკიდან ასევე შემიძლია ლოგები და ნებისმიერი მონაცემი ssh-ის საშუალებით ჩემს სერვერზე გავაგზავნო, რაც ძალიან მოსახერხებელია.

აყენებს ყველა ერთად

ჩართვით, დავიწყოთ განვითარება და გამართვა

ფუ, კარგი, ეს არის ის, მე აღვწერე ყველა კვანძი. ახლა დროა ეს ყველაფერი ერთად გავაერთიანოთ. თქვენ შეგიძლიათ ნახოთ კოდი აქ.

მნიშვნელოვანი წერტილი კოდთან დაკავშირებით: ეს პროექტი შეიძლება ასე არ დაიწყოს, რადგან ის იყო მორგებული კონკრეტული ამოცანისთვის, კონკრეტული არქიტექტურისთვის. მიუხედავად იმისა, რომ მე ვაძლევ საწყის კოდს, მაინც აგიხსნით ყველაზე ძვირფას ნივთებს აქ, პირდაპირ ტექსტში, წინააღმდეგ შემთხვევაში სრულიად გაუგებარია.

დასაწყისში ვაკეთებ gps-ს, gpio-ს ინიციალიზებას და ვხსნი ცალკე გრაფიკის თემას.

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

გრაფიკი საკმაოდ მარტივია: ის ხედავს, დადგა თუ არა შეტყობინებების გაგზავნის დრო და რა არის ამჟამინდელი შეცდომის სტატუსი. თუ არსებობს შეცდომის დროშა, მაშინ ჩვენ ვაციმებთ 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)

ამ პროექტის ყველაზე რთული ნაწილია საპირისპირო ssh კავშირის შენარჩუნება თითოეული ტესტისთვის. თითოეული ტესტი მოიცავს ნაგულისხმევი კარიბჭის და DNS სერვერის ხელახლა კონფიგურაციას. რადგანაც არავინ კითხულობს, იცოდეთ, რომ მატარებელი ხის რელსებზე არ დადის. ვინც სააღდგომო კვერცხს იპოვის, ტკბილეულს იღებს.

ამისათვის მე ვქმნი ცალკე მარშრუტიზაციის ცხრილს -set-mark 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

სიის მიღების შემდეგ, მე დავაყენე IP მისამართები ყველა ინტერფეისზე, როგორც სურათზე ვაჩვენე თავი მოდემის შესახებ.

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

მე ვამოწმებ ინტერფეისს ფუნქციონირებისთვის, თუ ქსელი არ არის, მაშინ ვქმნი შეცდომებს. თუ არსებობს ქსელი, მაშინ დროა იმოქმედოთ!

აქ მე ვაკონფიგურირებ ssh მარშრუტიზაციას ამ ინტერფეისზე (თუ ეს არ გაკეთებულა), ვაგზავნი შეცდომებს სერვერზე, თუ დრო მოვიდა, ვაგზავნი ჟურნალებს და ბოლოს ვაწარმოებ Speedtest-ს და ლოგის შენახვას csv ფაილში.

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

აღსანიშნავია საპირისპირო ssh-ის დაყენების ფუნქცია.

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 ოპერატორთან იყო, რომელსაც რამდენიმე დღე ვატარებდი.

აქ გამოვიყენე დინამიური საზომი სერვერი. სიჩქარის გაზომვები მუშაობს, მაგრამ ძალიან მერყეობს, მაგრამ გარკვეული საშუალო მნიშვნელობა მაინც ჩანს და ამის მიღება შესაძლებელია მონაცემების გაფილტვრით, მაგალითად, მოძრავი საშუალოზე.

მოგვიანებით ავაშენე რამდენიმე გრაფიკი სხვა ტელეკომის ოპერატორებისთვის. ამ შემთხვევაში უკვე არსებობდა ერთი სატესტო სერვერი და შედეგებიც ძალიან საინტერესო იყო.

როგორც ხედავთ, თემა ძალიან ვრცელია ამ მონაცემების კვლევისა და დამუშავებისთვის და აშკარად არ გრძელდება რამდენიმე კვირის მუშაობისთვის. მაგრამ…

მუშაობის შედეგი

სამუშაო მოულოდნელად დასრულდა ჩემი კონტროლის მიღმა არსებული გარემოებების გამო. ამ პროექტის ერთ-ერთი სუსტი მხარე, ჩემი სუბიექტური აზრით, მოდემი იყო, რომელსაც სხვა მოდემებთან ერთდროულად მუშაობა ნამდვილად არ სურდა და ყოველი ჩატვირთვისას აკეთებდა ასეთ ხრიკებს. ამ მიზნებისათვის, არსებობს უამრავი სხვა მოდემის მოდელები; ჩვეულებრივ, ისინი უკვე არიან Mini PCI-e ფორმატში და დამონტაჟებულია მოწყობილობის შიგნით და ბევრად უფრო ადვილია კონფიგურაცია. მაგრამ ეს სრულიად განსხვავებული ამბავია. პროექტი საინტერესო იყო და ძალიან გამიხარდა, რომ შევძელი მასში მონაწილეობა.

წყარო: www.habr.com