అనేక LTE మోడెమ్‌లపై ఏకకాలంలో స్పీడ్‌టెస్ట్

దిగ్బంధం సమయంలో, అనేక సెల్యులార్ ఆపరేటర్‌ల కోసం LTE మోడెమ్‌ల వేగాన్ని కొలిచే పరికరం అభివృద్ధిలో పాల్గొనడానికి నేను ప్రతిపాదించబడ్డాను.

LTE కనెక్షన్‌ని ఉపయోగించి పరికరాలను ఇన్‌స్టాల్ చేసేటప్పుడు, ఉదాహరణకు, వీడియో ప్రసారాల కోసం ఏ సెల్యులార్ ఆపరేటర్ తనకు అత్యంత అనుకూలమైనదో అర్థం చేసుకోవడానికి కస్టమర్ వివిధ భౌగోళిక ప్రదేశాలలో వివిధ టెలికాం ఆపరేటర్ల వేగాన్ని అంచనా వేయాలని కోరుకున్నాడు. అదే సమయంలో, ఖరీదైన పరికరాలు లేకుండా, సమస్యను వీలైనంత సరళంగా మరియు చౌకగా పరిష్కరించాలి.

పని సరళమైనది మరియు అత్యంత జ్ఞానంతో కూడుకున్నది కాదని నేను వెంటనే చెబుతాను; నేను ఏ సమస్యలను ఎదుర్కొన్నానో మరియు వాటిని ఎలా పరిష్కరించానో నేను మీకు చెప్తాను. కనుక మనము వెళ్దాము.

వ్యాఖ్య

LTE కనెక్షన్ యొక్క వేగాన్ని కొలవడం చాలా క్లిష్టమైన విషయం: మీరు సరైన పరికరాలు మరియు కొలత సాంకేతికతను ఎంచుకోవాలి మరియు సెల్యులార్ నెట్‌వర్క్ యొక్క టోపోలాజీ మరియు ఆపరేషన్ గురించి కూడా మంచి అవగాహన కలిగి ఉండాలి. అదనంగా, వేగం అనేక కారకాలచే ప్రభావితమవుతుంది: సెల్‌లోని చందాదారుల సంఖ్య, వాతావరణ పరిస్థితులు, సెల్ నుండి సెల్‌కు కూడా నెట్‌వర్క్ టోపోలాజీ కారణంగా వేగం నాటకీయంగా మారవచ్చు. సాధారణంగా, ఇది పెద్ద సంఖ్యలో తెలియని వ్యక్తులతో సమస్య, మరియు టెలికాం ఆపరేటర్ మాత్రమే దీన్ని సరిగ్గా పరిష్కరించగలరు.

ప్రారంభంలో, కస్టమర్ కేవలం ఆపరేటర్ల ఫోన్‌లతో కొరియర్‌ను నడపాలని, నేరుగా ఫోన్‌లో కొలతలు తీసుకుని, ఆపై వేగ కొలత ఫలితాలను నోట్‌బుక్‌లో రాయాలని కోరుకున్నారు. lte నెట్‌వర్క్‌ల వేగాన్ని కొలవడానికి నా పరిష్కారం, ఆదర్శంగా లేనప్పటికీ, సమస్యను పరిష్కరిస్తుంది.

సమయాభావం వల్ల సౌలభ్యం, ఆచరణకు అనుకూలంగా కాకుండా అభివృద్ధి వేగానికి అనుకూలంగా నిర్ణయాలు తీసుకున్నాను. ఉదాహరణకు, సర్వర్ మరియు ప్రతి క్లయింట్‌ను సెటప్ చేయడంలో సమయాన్ని ఆదా చేయడానికి, రిమోట్ యాక్సెస్ కోసం రివర్స్ ssh ఉపయోగించబడింది, మరింత ఆచరణాత్మక VPNకి బదులుగా.

సాంకేతిక పని

వ్యాసంలో పేర్కొన్నట్లు సాంకేతిక లక్షణాలు లేకుండా: క్లయింట్ ఎందుకు కోరుకోలేదు: సాంకేతిక లక్షణాలు లేకుండా పని చేయవద్దు! ఎప్పుడూ, ఎక్కడా!

సాంకేతిక పని చాలా సులభం, తుది వినియోగదారుని అర్థం చేసుకోవడానికి నేను దానిని కొద్దిగా విస్తరిస్తాను. సాంకేతిక పరిష్కారాలు మరియు పరికరాల ఎంపిక కస్టమర్చే నిర్దేశించబడింది. కాబట్టి, సాంకేతిక వివరణ కూడా, అన్ని ఆమోదాల తర్వాత:

సింగిల్ బోర్డ్ కంప్యూటర్ ఆధారంగా vim2 H మోడెమ్‌ల ద్వారా lte కనెక్షన్‌ల కోసం స్పీడ్ టెస్టర్‌ను తయారు చేయండిuawei e3372h - 153 అనేక టెలికాం ఆపరేటర్లు (ఒకటి నుండి n వరకు). UART ద్వారా కనెక్ట్ చేయబడిన GPS రిసీవర్ నుండి కోఆర్డినేట్‌లను స్వీకరించడం కూడా అవసరం. సేవను ఉపయోగించి వేగ కొలతలు చేయండి www.speedtest.net మరియు వాటిని పట్టికలో ఉంచండి:

csv ఆకృతిలో పట్టిక. ఆపై ప్రతి 6 గంటలకు ఈ గుర్తును ఇ-మెయిల్ ద్వారా పంపండి. ఎర్రర్‌ల విషయంలో, GPIOకి కనెక్ట్ చేయబడిన LEDని బ్లింక్ చేయండి.

అనేక ఆమోదాల తర్వాత నేను సాంకేతిక వివరణలను ఉచిత రూపంలో వివరించాను. కానీ పని యొక్క అర్థం ఇప్పటికే కనిపిస్తుంది. అన్నింటికీ ఒక వారం సమయం ఇచ్చారు. కానీ వాస్తవానికి ఇది మూడు వారాల పాటు కొనసాగింది. ఇది నేను నా ప్రధాన పని తర్వాత మరియు వారాంతాల్లో మాత్రమే చేశాను అనే వాస్తవాన్ని పరిగణనలోకి తీసుకుంటోంది.

స్పీడ్ మెజర్‌మెంట్ సర్వీస్ మరియు హార్డ్‌వేర్ వాడకంపై కస్టమర్ ముందుగానే అంగీకరించారని ఇక్కడ నేను మరోసారి దృష్టిని ఆకర్షించాలనుకుంటున్నాను, ఇది నా సామర్థ్యాలను బాగా పరిమితం చేసింది. బడ్జెట్ కూడా పరిమితం చేయబడింది, కాబట్టి ప్రత్యేకంగా ఏమీ కొనుగోలు చేయలేదు. కాబట్టి మేము ఈ నిబంధనల ప్రకారం ఆడవలసి వచ్చింది.

ఆర్కిటెక్చర్ మరియు అభివృద్ధి

పథకం సరళమైనది మరియు స్పష్టమైనది. అందువల్ల, నేను ప్రత్యేక వ్యాఖ్యలు లేకుండా వదిలివేస్తాను.

ఈ భాషలో అభివృద్ధి చేసిన అనుభవం నాకు లేనప్పటికీ, నేను మొత్తం ప్రాజెక్ట్‌ను పైథాన్‌లో అమలు చేయాలని నిర్ణయించుకున్నాను. డెవలప్‌మెంట్‌ను వేగవంతం చేసే రెడీమేడ్ ఉదాహరణలు మరియు పరిష్కారాల సమూహం ఉన్నందున నేను దానిని ఎంచుకున్నాను. అందువల్ల, పైథాన్‌లో అభివృద్ధి చెందుతున్న నా మొదటి అనుభవాన్ని తిట్టవద్దని నేను అన్ని ప్రొఫెషనల్ ప్రోగ్రామర్‌లను కోరుతున్నాను మరియు నా నైపుణ్యాలను మెరుగుపరచడానికి నిర్మాణాత్మక విమర్శలను వినడానికి నేను ఎల్లప్పుడూ సంతోషిస్తాను.

ఈ ప్రక్రియలో నేను పైథాన్‌లో 2 మరియు 3 రెండు రన్నింగ్ వెర్షన్‌లు ఉన్నాయని కనుగొన్నాను, ఫలితంగా నేను మూడవదానిపై స్థిరపడ్డాను.

హార్డ్వేర్ నోడ్స్

సింగిల్-ప్లేట్ vim2

నా మెయిన్ మెషీన్‌గా నాకు సింగిల్ బోర్డ్ కంప్యూటర్ ఇవ్వబడింది vim2

స్మార్ట్ హోమ్ మరియు SMART-TV కోసం అద్భుతమైన, శక్తివంతమైన మీడియా ప్రాసెసర్, కానీ ఈ పనికి చాలా సరికాదు, లేదా, పేలవంగా సరిఅయినదని చెప్పండి. ఉదాహరణకు, దాని ప్రధాన OS Android, మరియు Linux ద్వితీయ OS, మరియు తదనుగుణంగా Linux క్రింద ఉన్న అన్ని నోడ్‌లు మరియు డ్రైవర్ల యొక్క అధిక-నాణ్యత ఆపరేషన్‌కు ఎవరూ హామీ ఇవ్వరు. మరియు కొన్ని సమస్యలు ఈ ప్లాట్‌ఫారమ్ యొక్క USB డ్రైవర్‌లకు సంబంధించినవని నేను ఊహిస్తున్నాను, కాబట్టి మోడెమ్‌లు ఈ బోర్డులో ఆశించిన విధంగా పని చేయలేదు. ఇది చాలా పేలవమైన మరియు చెల్లాచెదురుగా ఉన్న డాక్యుమెంటేషన్‌ను కూడా కలిగి ఉంది, కాబట్టి ప్రతి ఆపరేషన్ డాక్స్ ద్వారా త్రవ్వడానికి చాలా సమయం పట్టింది. GPIOతో సాధారణ పనికి కూడా చాలా రక్తం పడుతుంది. ఉదాహరణకు, LEDని సెటప్ చేయడానికి నాకు చాలా గంటలు పట్టింది. కానీ, ఆబ్జెక్టివ్‌గా ఉండటానికి, ఇది ఏ విధమైన సింగిల్-బోర్డ్ అనేది ప్రాథమికంగా ముఖ్యమైనది కాదు, ప్రధాన విషయం ఏమిటంటే అది పని చేసి USB పోర్ట్‌లు ఉన్నాయి.

ముందుగా, నేను ఈ బోర్డ్‌లో Linuxని ఇన్‌స్టాల్ చేయాలి. ప్రతిఒక్కరికీ మరియు ఈ సింగిల్-బోర్డ్ సిస్టమ్‌తో వ్యవహరించే వారి కోసం డాక్యుమెంటేషన్ యొక్క వైల్డ్‌లను కొట్టకుండా ఉండటానికి, నేను ఈ అధ్యాయాన్ని వ్రాస్తున్నాను.

Linuxని ఇన్‌స్టాల్ చేయడానికి రెండు ఎంపికలు ఉన్నాయి: బాహ్య SD కార్డ్‌లో లేదా అంతర్గత MMCలో. కార్డ్‌తో దీన్ని ఎలా పని చేయాలో గుర్తించడానికి నేను సాయంత్రం గడిపాను, కాబట్టి నేను దానిని MMCలో ఇన్‌స్టాల్ చేయాలని నిర్ణయించుకున్నాను, అయినప్పటికీ ఎటువంటి సందేహం లేకుండా బాహ్య కార్డ్‌తో పని చేయడం చాలా సులభం.

ఫర్మ్‌వేర్ గురించి వంకరగా ఇక్కడ చెప్పబడింది. నేను వింత నుండి రష్యన్లోకి అనువదిస్తాను. బోర్డుని ఫ్లాష్ చేయడానికి, నేను హార్డ్‌వేర్ UARTని కనెక్ట్ చేయాలి. దాన్ని కనెక్ట్ చేశారు క్రింది విధంగా.

• టూల్ పిన్ GND: <—> VIMల GPIO యొక్క Pin17
• టూల్ పిన్ TXD: <—> VIMల GPIO యొక్క Pin18 (Linux_Rx)
• టూల్ పిన్ RXD: <—> VIMల GPIO యొక్క Pin19 (Linux_Tx)
• టూల్ పిన్ VCC: <—> VIMల GPIO యొక్క Pin20

ఆ తర్వాత, నేను ఫర్మ్‌వేర్‌ను డౌన్‌లోడ్ చేసాను ఇక్కడ నుండి. నిర్దిష్ట ఫర్మ్‌వేర్ వెర్షన్ VIM1_Ubuntu-server-bionic_Linux-4.9_arm64_EMMC_V20191231.

ఈ ఫర్మ్‌వేర్‌ను అప్‌లోడ్ చేయడానికి, నాకు యుటిలిటీలు కావాలి. దీని గురించి మరిన్ని వివరాలు ఇక్కడ. నేను దీన్ని Windows కింద ఫ్లాషింగ్ చేయడానికి ప్రయత్నించలేదు, కానీ Linux కింద ఫర్మ్‌వేర్ గురించి నేను మీకు కొన్ని మాటలు చెప్పాలి. మొదట, నేను సూచనల ప్రకారం యుటిలిటీలను ఇన్‌స్టాల్ చేస్తాను.

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

Aaand... ఏదీ పనిచేయదు. నేను ఇన్‌స్టాలేషన్ స్క్రిప్ట్‌లను సవరించడానికి కొన్ని గంటలు గడిపాను, తద్వారా ప్రతిదీ నాకు సరిగ్గా ఇన్‌స్టాల్ అవుతుంది. నేను అక్కడ ఏమి చేశానో నాకు గుర్తు లేదు, కానీ గుర్రాలతో సర్కస్ కూడా ఉంది. కాబట్టి జాగ్రత్తగా ఉండండి. కానీ ఈ యుటిలిటీస్ లేకుండా vim2ని మరింత హింసించడంలో అర్థం లేదు. అతనితో అస్సలు గొడవ పడకపోవడమే మంచిది!

హెల్ యొక్క ఏడు సర్కిల్‌లు, స్క్రిప్ట్ కాన్ఫిగరేషన్ మరియు ఇన్‌స్టాలేషన్ తర్వాత, నేను వర్కింగ్ యుటిలిటీల ప్యాకేజీని అందుకున్నాను. నేను USB ద్వారా బోర్డ్‌ని నా Linux కంప్యూటర్‌కి కనెక్ట్ చేసాను మరియు పైన ఉన్న రేఖాచిత్రం ప్రకారం UARTని కూడా కనెక్ట్ చేసాను.
నేను హార్డ్‌వేర్ మరియు సాఫ్ట్‌వేర్ ఎర్రర్ నియంత్రణ లేకుండా 115200 వేగంతో నాకు ఇష్టమైన మినీకామ్ టెర్మినల్‌ను సెటప్ చేస్తున్నాను. మరియు ప్రారంభిద్దాం.

UART టెర్మినల్‌లో VIM2ని లోడ్ చేస్తున్నప్పుడు, లోడ్ చేయడాన్ని ఆపడానికి నేను స్పేస్‌బార్ వంటి కీని నొక్కాను. లైన్ కనిపించిన తర్వాత

kvim2# 

నేను ఆదేశాన్ని నమోదు చేస్తున్నాను:

kvim2# run update

మేము లోడ్ చేస్తున్న హోస్ట్‌లో, నేను అమలు చేస్తాను:

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

అంతే, అయ్యో. నేను తనిఖీ చేసాను, బోర్డులో Linux ఉంది. లాగిన్/పాస్‌వర్డ్ ఖాదాస్:ఖాదాస్.

ఆ తర్వాత, కొన్ని చిన్న ప్రారంభ సెట్టింగ్‌లు. తదుపరి పని కోసం, నేను సుడో కోసం పాస్‌వర్డ్‌ను నిలిపివేస్తాను (అవును, సురక్షితం కాదు, కానీ అనుకూలమైనది).

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

మీకు కష్టంగా అనిపిస్తే, ఈ బోర్డుని ఉపయోగించవద్దు; రాస్ప్బెర్రీ పై ఉత్తమం. నిజాయితీగా.

మోడెమ్ Huawei e3372h – 153

ఈ మోడెమ్ నాకు రక్తం యొక్క ముఖ్యమైన మూలం, మరియు వాస్తవానికి, ఇది మొత్తం ప్రాజెక్ట్ యొక్క అడ్డంకిగా మారింది. సాధారణంగా, ఈ పరికరాల కోసం "మోడెమ్" అనే పేరు పని యొక్క సారాంశాన్ని ప్రతిబింబించదు: ఇది శక్తివంతమైన కలయిక, ఈ హార్డ్‌వేర్ ముక్కలో డ్రైవర్‌లను ఇన్‌స్టాల్ చేయడానికి CD-ROM వలె నటించే మిశ్రమ పరికరం ఉంది, ఆపై నెట్‌వర్క్ కార్డ్ మోడ్‌కి మారుతుంది.

నిర్మాణపరంగా, Linux వినియోగదారు యొక్క దృక్కోణం నుండి, అన్ని సెట్టింగుల తర్వాత, ఇది ఇలా కనిపిస్తుంది: మోడెమ్‌ను కనెక్ట్ చేసిన తర్వాత, నాకు eth* నెట్‌వర్క్ ఇంటర్‌ఫేస్ ఉంది, ఇది dhcp ద్వారా IP చిరునామా 192.168.8.100 మరియు డిఫాల్ట్ గేట్‌వేని అందుకుంటుంది. 192.168.8.1.

మరియు అత్యంత ముఖ్యమైన క్షణం! ఈ మోడెమ్ మోడల్ మోడెమ్ మోడ్‌లో పనిచేయదు, ఇది AT ఆదేశాలచే నియంత్రించబడుతుంది. ప్రతిదీ చాలా సరళంగా ఉంటుంది, ప్రతి మోడెమ్‌కు PPP కనెక్షన్‌లను సృష్టించి, ఆపై వాటితో పనిచేయండి. కానీ నా విషయంలో, "అతను" (మరింత ఖచ్చితంగా, udev నియమాల ప్రకారం ఒక Linux డైవర్), ఒక eth ఇంటర్‌ఫేస్‌ను సృష్టిస్తుంది మరియు దానికి dhcp ద్వారా IP చిరునామాను కేటాయిస్తుంది.

మరింత గందరగోళాన్ని నివారించడానికి, నేను "మోడెమ్" అనే పదాన్ని మరచిపోవాలని మరియు నెట్వర్క్ కార్డ్ మరియు గేట్వేని చెప్పమని నేను సూచిస్తున్నాను, ఎందుకంటే సారాంశంలో, ఇది గేట్వేతో కొత్త నెట్వర్క్ కార్డ్ని కనెక్ట్ చేయడం లాంటిది.
ఒక మోడెమ్ ఉన్నప్పుడు, ఇది ఏ ప్రత్యేక సమస్యలను కలిగించదు, కానీ ఒకటి కంటే ఎక్కువ ఉన్నప్పుడు, అవి n-పీస్‌లు, క్రింది నెట్‌వర్క్ చిత్రం పుడుతుంది.

అంటే, n నెట్‌వర్క్ కార్డ్‌లు, ఒకే IP చిరునామాతో, ఒక్కొక్కటి ఒకే డిఫాల్ట్ గేట్‌వేతో ఉంటాయి. కానీ వాస్తవానికి, వాటిలో ప్రతి ఒక్కటి దాని స్వంత ఆపరేటర్‌కు కనెక్ట్ చేయబడింది.

ప్రారంభంలో, నేను ఒక సాధారణ పరిష్కారాన్ని కలిగి ఉన్నాను: ifconfig లేదా ip ఆదేశాన్ని ఉపయోగించి, అన్ని ఇంటర్‌ఫేస్‌లను ఆపివేయండి మరియు కేవలం ఒకదానిని ఆన్ చేసి దాన్ని పరీక్షించండి. ఈ పరిష్కారం అందరికీ మంచిది, స్విచ్ చేసే సమయంలో నేను పరికరానికి కనెక్ట్ చేయలేకపోయాను. మరియు స్విచ్చింగ్ తరచుగా మరియు వేగవంతమైనది కాబట్టి, వాస్తవానికి నాకు కనెక్ట్ అయ్యే అవకాశం లేదు.

అందువల్ల, నేను మోడెమ్‌ల యొక్క IP చిరునామాలను మాన్యువల్‌గా మార్చడం మరియు రౌటింగ్ సెట్టింగ్‌లను ఉపయోగించి ట్రాఫిక్‌ను డ్రైవింగ్ చేసే మార్గాన్ని ఎంచుకున్నాను.

మోడెమ్‌లతో నా సమస్యలకు ఇది అంతం కాదు: విద్యుత్ సమస్యల విషయంలో, అవి పడిపోయాయి మరియు USB హబ్‌కి మంచి స్థిరమైన విద్యుత్ సరఫరా అవసరం. పవర్‌ను నేరుగా హబ్‌కి గట్టిగా టంకం చేయడం ద్వారా నేను ఈ సమస్యను పరిష్కరించాను. నేను ఎదుర్కొన్న మరియు మొత్తం ప్రాజెక్ట్‌ను నాశనం చేసిన మరో సమస్య: పరికరాన్ని రీబూట్ చేసిన తర్వాత లేదా చల్లగా ప్రారంభించిన తర్వాత, అన్ని మోడెమ్‌లు కనుగొనబడలేదు మరియు ఎల్లప్పుడూ కాదు, మరియు ఇది ఎందుకు జరిగిందో మరియు ఏ అల్గోరిథం ద్వారా నేను గుర్తించలేకపోయాను. కానీ మొదటి విషయాలు మొదటి.

మోడెమ్ సరిగ్గా పని చేయడానికి, నేను usb-modeswitch ప్యాకేజీని ఇన్‌స్టాల్ చేసాను.

sudo apt update
sudo apt install -y usb-modeswitch

దీని తర్వాత, కనెక్ట్ చేసిన తర్వాత, మోడెమ్ సరిగ్గా గుర్తించబడుతుంది మరియు udev సబ్‌సిస్టమ్ ద్వారా కాన్ఫిగర్ చేయబడుతుంది. నేను మోడెమ్‌ను కనెక్ట్ చేయడం ద్వారా మరియు నెట్‌వర్క్ కనిపిస్తుందో లేదో తనిఖీ చేయడం ద్వారా తనిఖీ చేస్తాను.
నేను పరిష్కరించలేని మరో సమస్య: ఈ మోడెమ్ నుండి మనం పని చేస్తున్న ఆపరేటర్ పేరును నేను ఎలా పొందగలను? ఆపరేటర్ పేరు మోడెమ్ వెబ్ ఇంటర్‌ఫేస్‌లో 192.168.8.1 వద్ద ఉంది. ఇది అజాక్స్ అభ్యర్థనల ద్వారా డేటాను స్వీకరించే డైనమిక్ వెబ్ పేజీ, కాబట్టి కేవలం పేజీని పొందడం మరియు పేరును అన్వయించడం పని చేయదు. కాబట్టి నేను వెబ్ పేజీని ఎలా డెవలప్ చేయాలి మొదలైనవాటిని చూడటం ప్రారంభించాను మరియు నేను ఒక రకమైన అర్ధంలేని పని చేస్తున్నానని గ్రహించాను. ఫలితంగా, అతను ఉమ్మివేసాడు మరియు ఆపరేటర్ స్పీడ్‌టెస్ట్ APIని ఉపయోగించడం ప్రారంభించాడు.

AT ఆదేశాల ద్వారా మోడెమ్ యాక్సెస్‌ను కలిగి ఉంటే చాలా సులభం అవుతుంది. దీన్ని మళ్లీ కాన్ఫిగర్ చేయడం, ppp కనెక్షన్‌ని సృష్టించడం, IPని కేటాయించడం, టెలికాం ఆపరేటర్‌ని పొందడం మొదలైనవి సాధ్యమవుతాయి. కానీ అయ్యో, నేను ఇచ్చిన దానితో పని చేస్తున్నాను.

GPS

నాకు ఇచ్చిన GPS రిసీవర్ UART ఇంటర్‌ఫేస్ మరియు పవర్‌ని కలిగి ఉంది. ఇది ఉత్తమ పరిష్కారం కాదు, కానీ ఇది ఇప్పటికీ పని చేయదగినది మరియు సరళమైనది. రిసీవర్ ఇలా చూసింది.

నిజం చెప్పాలంటే, GPS రిసీవర్‌తో పని చేయడం ఇది నా మొదటిసారి, కానీ నేను ఊహించినట్లుగా, చాలా కాలం క్రితం మా కోసం ప్రతిదీ ఆలోచించబడింది. కాబట్టి మేము రెడీమేడ్ పరిష్కారాలను ఉపయోగిస్తాము.

ముందుగా, నేను GPSని కనెక్ట్ చేయడానికి uart_AO_B (UART_RX_AO_B, UART_TX_AO_B)ని ప్రారంభిస్తాను.

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

నేను GPS హ్యాంగ్ అయ్యే UARTని ఇన్‌స్టాల్ చేస్తున్నాను.

DEVICES="/dev/ttyS4"

ఆపై మేము ప్రతిదీ ఆన్ చేసి ప్రారంభిస్తాము.

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

ఆ తర్వాత, నేను GPSని కనెక్ట్ చేస్తాను.

GPS వైర్ నా చేతుల్లో ఉంది, UART డీబగ్గర్ వైర్లు నా వేళ్ల క్రింద కనిపిస్తాయి.

నేను రీబూట్ చేసి, gpsmon ప్రోగ్రామ్‌ని ఉపయోగించి GPS ఆపరేషన్‌ని తనిఖీ చేస్తాను.

మీరు ఈ స్క్రీన్‌షాట్‌లో ఉపగ్రహాలను చూడలేరు, కానీ మీరు 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 పేలవమైన ఆదరణను కలిగి ఉంటుంది మరియు ఎల్లప్పుడూ డేటాను స్వీకరించదు కాబట్టి నేను దీన్ని చేయాలని నిర్ణయించుకున్నాను. మీరు డేటాను స్వీకరించడానికి వేచి ఉంటే, మీరు రిమోట్ గదిలో పని చేస్తే, ప్రోగ్రామ్ ఈ స్థలంలో స్తంభింపజేస్తుంది. అందువలన, నేను ఈ అసంబద్ధ ఎంపికను అమలు చేసాను.

సూత్రప్రాయంగా, ఎక్కువ సమయం ఉంటే, UART ద్వారా నేరుగా GPS నుండి డేటాను స్వీకరించడం, ప్రత్యేక థ్రెడ్‌లో అన్వయించడం మరియు దానితో పని చేయడం సాధ్యమవుతుంది. కానీ అస్సలు సమయం లేదు, అందుకే క్రూరమైన అగ్లీ కోడ్. మరియు అవును, నేను సిగ్గుపడను.

కాంతి ఉద్గార డయోడ్

LEDని కనెక్ట్ చేయడం సులభం మరియు అదే సమయంలో కష్టం. ప్రధాన ఇబ్బంది ఏమిటంటే, సిస్టమ్‌లోని పిన్ నంబర్ బోర్డులోని పిన్ నంబర్‌కు అనుగుణంగా లేదు మరియు డాక్యుమెంటేషన్ ఎడమ చేతితో వ్రాయబడింది. OSలో హార్డ్‌వేర్ పిన్ నంబర్ మరియు పిన్ నంబర్‌ను సరిపోల్చడానికి, మీరు ఆదేశాన్ని అమలు చేయాలి:

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() అని పిలుస్తాను మరియు LED అందంగా బ్లింక్ అవుతుంది.

సాఫ్ట్‌వేర్ నోడ్స్

స్పీడ్‌టెస్ట్ API

speedtest.net సేవ దాని స్వంత పైథాన్-APIని కలిగి ఉండటం చాలా ఆనందంగా ఉంది, మీరు చూడవచ్చు Github.

మంచి విషయం ఏమిటంటే సోర్స్ కోడ్‌లు కూడా చూడవచ్చు. ఈ APIతో ఎలా పని చేయాలో (సాధారణ ఉదాహరణలు) చూడవచ్చు సంబంధిత విభాగం.

నేను కింది ఆదేశంతో పైథాన్ లైబ్రరీని ఇన్‌స్టాల్ చేస్తాను.

sudo -H pip3 install speedtest-cli

ఉదాహరణకు, మీరు సాఫ్ట్‌వేర్ నుండి నేరుగా ఉబుంటులో స్పీడ్ టెస్టర్‌ను కూడా ఇన్‌స్టాల్ చేయవచ్చు. ఇది అదే పైథాన్ అప్లికేషన్, ఇది కన్సోల్ నుండి నేరుగా ప్రారంభించబడుతుంది.

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 am, 12 మరియు 18 pm. ఈ క్రింది విధంగా పంపారు.

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 మొదలైనవాటిని అమలు చేస్తే సరిపోతుంది కాబట్టి దానిని చిన్న నిల్వతో తీసుకోవాలని నిర్ణయించుకున్నాను. అదనంగా, టెలిగ్రామ్ బాట్‌ను సెటప్ చేయగలగాలి మరియు అది బ్లాక్ చేయబడినప్పుడు సమస్యలు ఉండవు. అందువలన, నేను ఆమ్స్టర్డ్యామ్ మరియు క్రింది పారామితులను ఎంచుకున్నాను.

హార్డ్‌వేర్‌తో కమ్యూనికేషన్ పద్ధతిగా, vim2 రివర్స్ ssh కనెక్షన్‌ని ఎంచుకుంది మరియు ఆచరణలో చూపినట్లుగా, ఇది ఉత్తమమైనది కాదు. కనెక్షన్ పోయినట్లయితే, సర్వర్ పోర్ట్‌ను కలిగి ఉంటుంది మరియు కొంత సమయం వరకు దాని ద్వారా కనెక్ట్ చేయడం అసాధ్యం. అందువల్ల, ఇతర కమ్యూనికేషన్ పద్ధతులను ఉపయోగించడం ఇంకా ఉత్తమం, ఉదాహరణకు VPN. భవిష్యత్తులో నేను VPNకి మారాలనుకున్నాను, కానీ సమయం లేదు.

నేను ఫైర్‌వాల్‌ని సెటప్ చేయడం, హక్కులను పరిమితం చేయడం, రూట్ 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 సర్వర్‌ని మళ్లీ కాన్ఫిగర్ చేయడం ఉంటుంది. ఏమైనప్పటికీ ఎవరూ చదవరు కాబట్టి, రైలు చెక్క పట్టాలపై నడవదని తెలుసుకోండి. ఎవరైతే ఈస్టర్ గుడ్డును కనుగొన్నారో వారికి కొంత మిఠాయి లభిస్తుంది.

దీన్ని చేయడానికి, నేను ప్రత్యేక రౌటింగ్ టేబుల్ -సెట్-మార్క్ 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 రూటింగ్‌ని కాన్ఫిగర్ చేస్తాను (అది చేయకపోతే), సమయం వచ్చినట్లయితే సర్వర్‌కు లోపాలను పంపండి, లాగ్‌లను పంపండి మరియు చివరకు స్పీడ్‌టెస్ట్‌ను అమలు చేసి, లాగ్‌లను 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 ఆపరేటర్‌తో, నేను చాలా రోజులు నిర్వహించాను.

ఇక్కడ నేను డైనమిక్ కొలిచే సర్వర్‌ని ఉపయోగించాను. స్పీడ్ కొలతలు పని చేస్తాయి, కానీ చాలా హెచ్చుతగ్గులకు గురవుతాయి, కానీ కొంత సగటు విలువ ఇప్పటికీ కనిపిస్తుంది మరియు డేటాను ఫిల్టర్ చేయడం ద్వారా ఇది పొందవచ్చు, ఉదాహరణకు, కదిలే సగటుతో.

తర్వాత నేను ఇతర టెలికాం ఆపరేటర్ల కోసం అనేక గ్రాఫ్‌లను రూపొందించాను. ఈ సందర్భంలో, ఇప్పటికే ఒక పరీక్ష సర్వర్ ఉంది మరియు ఫలితాలు కూడా చాలా ఆసక్తికరంగా ఉన్నాయి.

మీరు చూడగలిగినట్లుగా, ఈ డేటా యొక్క పరిశోధన మరియు ప్రాసెసింగ్ కోసం అంశం చాలా విస్తృతమైనది మరియు రెండు వారాల పని కోసం స్పష్టంగా ఉండదు. కానీ…

పని ఫలితం

నా నియంత్రణకు మించిన పరిస్థితుల కారణంగా పని అకస్మాత్తుగా పూర్తయింది. ఈ ప్రాజెక్ట్ యొక్క బలహీనతలలో ఒకటి, నా ఆత్మాశ్రయ అభిప్రాయం ప్రకారం, ఇతర మోడెమ్‌లతో ఏకకాలంలో పనిచేయడానికి నిజంగా ఇష్టపడని మోడెమ్, మరియు అది లోడ్ చేయబడిన ప్రతిసారీ అలాంటి ఉపాయాలు చేసింది. ఈ ప్రయోజనాల కోసం, భారీ సంఖ్యలో ఇతర మోడెమ్ నమూనాలు ఉన్నాయి; సాధారణంగా అవి ఇప్పటికే మినీ PCI-e ఫార్మాట్‌లో ఉన్నాయి మరియు పరికరం లోపల ఇన్‌స్టాల్ చేయబడ్డాయి మరియు కాన్ఫిగర్ చేయడం చాలా సులభం. కానీ అది పూర్తిగా భిన్నమైన కథ. ప్రాజెక్ట్ ఆసక్తికరంగా ఉంది మరియు నేను ఇందులో పాల్గొనగలిగినందుకు చాలా సంతోషించాను.

మూలం: www.habr.com