നിരവധി എൽടിഇ മോഡമുകളിൽ ഒരേസമയം സ്പീഡ് ടെസ്റ്റ്

ക്വാറന്റൈൻ സമയത്ത്, നിരവധി സെല്ലുലാർ ഓപ്പറേറ്റർമാർക്കായി എൽടിഇ മോഡമുകളുടെ വേഗത അളക്കുന്നതിനുള്ള ഒരു ഉപകരണത്തിന്റെ വികസനത്തിൽ പങ്കെടുക്കാൻ ഞാൻ വാഗ്ദാനം ചെയ്തു.

ഒരു എൽടിഇ കണക്ഷൻ ഉപയോഗിച്ച് ഉപകരണങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യുമ്പോൾ ഏത് സെല്ലുലാർ ഓപ്പറേറ്ററാണ് തനിക്ക് ഏറ്റവും അനുയോജ്യമെന്ന് മനസിലാക്കാൻ വിവിധ ഭൂമിശാസ്ത്രപരമായ സ്ഥലങ്ങളിലെ വിവിധ ടെലികോം ഓപ്പറേറ്റർമാരുടെ വേഗത വിലയിരുത്താൻ ഉപഭോക്താവ് ആഗ്രഹിച്ചു, ഉദാഹരണത്തിന്, വീഡിയോ പ്രക്ഷേപണത്തിനായി. അതേ സമയം, വിലകൂടിയ ഉപകരണങ്ങളില്ലാതെ, പ്രശ്നം കഴിയുന്നത്ര ലളിതവും വിലകുറഞ്ഞതും പരിഹരിക്കേണ്ടതുണ്ട്.

ചുമതല ഏറ്റവും ലളിതവും വിജ്ഞാന-തീവ്രവുമല്ലെന്ന് ഞാൻ ഉടൻ പറയും; ഞാൻ നേരിട്ട പ്രശ്നങ്ങൾ എന്താണെന്നും അവ എങ്ങനെ പരിഹരിച്ചുവെന്നും ഞാൻ നിങ്ങളോട് പറയും. അതിനാൽ, നമുക്ക് പോകാം.

അഭിപായപ്പെടുക

ഒരു എൽടിഇ കണക്ഷന്റെ വേഗത അളക്കുന്നത് വളരെ സങ്കീർണ്ണമായ കാര്യമാണ്: നിങ്ങൾ ശരിയായ ഉപകരണങ്ങളും അളക്കൽ സാങ്കേതികതയും തിരഞ്ഞെടുക്കേണ്ടതുണ്ട്, കൂടാതെ സെല്ലുലാർ നെറ്റ്‌വർക്കിന്റെ ടോപ്പോളജിയെയും പ്രവർത്തനത്തെയും കുറിച്ച് നല്ല ധാരണയും ഉണ്ടായിരിക്കണം. കൂടാതെ, വേഗതയെ നിരവധി ഘടകങ്ങളാൽ സ്വാധീനിക്കാം: ഒരു സെല്ലിലെ വരിക്കാരുടെ എണ്ണം, കാലാവസ്ഥ, സെല്ലിൽ നിന്ന് സെല്ലിലേക്ക് പോലും നെറ്റ്‌വർക്ക് ടോപ്പോളജി കാരണം വേഗത ഗണ്യമായി വ്യത്യാസപ്പെടാം. പൊതുവേ, ഇത് ധാരാളം അജ്ഞാതരുടെ ഒരു പ്രശ്നമാണ്, ഒരു ടെലികോം ഓപ്പറേറ്റർക്ക് മാത്രമേ ഇത് ശരിയായി പരിഹരിക്കാൻ കഴിയൂ.

തുടക്കത്തിൽ, ഉപഭോക്താവ് ഓപ്പറേറ്റർമാരുടെ ഫോണുകൾ ഉപയോഗിച്ച് കൊറിയർ ഓടിക്കാനും ഫോണിൽ നേരിട്ട് അളവുകൾ എടുക്കാനും തുടർന്ന് ഒരു നോട്ട്ബുക്കിൽ വേഗത അളക്കൽ ഫലങ്ങൾ എഴുതാനും ആഗ്രഹിച്ചു. lte നെറ്റ്‌വർക്കുകളുടെ വേഗത അളക്കുന്നതിനുള്ള എന്റെ പരിഹാരം, അനുയോജ്യമല്ലെങ്കിലും, പ്രശ്നം പരിഹരിക്കുന്നു.

സമയക്കുറവ് കാരണം, ഞാൻ തീരുമാനങ്ങൾ എടുത്തത് സൗകര്യത്തിനോ പ്രായോഗികതയ്‌ക്കോ അനുകൂലമല്ല, മറിച്ച് വികസനത്തിന്റെ വേഗതയ്ക്ക് അനുകൂലമാണ്. ഉദാഹരണത്തിന്, സെർവറും ഓരോ ക്ലയന്റും സജ്ജീകരിക്കുന്നതിനുള്ള സമയം ലാഭിക്കുന്നതിന്, കൂടുതൽ പ്രായോഗികമായ VPN-ന് പകരം റിമോട്ട് ആക്‌സസിനായി റിവേഴ്സ് ssh ഉപയോഗിച്ചു.

സാങ്കേതിക ചുമതല

ലേഖനത്തിൽ പറഞ്ഞിരിക്കുന്നതുപോലെ സാങ്കേതിക സവിശേഷതകളില്ലാതെ: എന്തുകൊണ്ട് ക്ലയന്റ് അത് ആവശ്യമില്ല: സാങ്കേതിക സവിശേഷതകളില്ലാതെ പ്രവർത്തിക്കരുത്! ഒരിക്കലുമില്ല, എവിടെയും!

സാങ്കേതിക ചുമതല വളരെ ലളിതമായിരുന്നു, അന്തിമ ഉപയോക്താവിന്റെ ധാരണയ്ക്കായി ഞാൻ ഇത് അൽപ്പം വികസിപ്പിക്കും. സാങ്കേതിക പരിഹാരങ്ങളുടെയും ഉപകരണങ്ങളുടെയും തിരഞ്ഞെടുപ്പ് ഉപഭോക്താവ് നിർദ്ദേശിച്ചു. അതിനാൽ, സാങ്കേതിക സവിശേഷതകൾ തന്നെ, എല്ലാ അംഗീകാരങ്ങൾക്കും ശേഷം:

ഒരൊറ്റ ബോർഡ് കമ്പ്യൂട്ടറിനെ അടിസ്ഥാനമാക്കി വിം2 H മോഡം വഴിയുള്ള lte കണക്ഷനുകൾക്കായി ഒരു സ്പീഡ് ടെസ്റ്റർ ഉണ്ടാക്കുകuawei e3372h - 153 നിരവധി ടെലികോം ഓപ്പറേറ്റർമാർ (ഒന്ന് മുതൽ n വരെ). UART വഴി ബന്ധിപ്പിച്ചിരിക്കുന്ന ഒരു GPS റിസീവറിൽ നിന്ന് കോർഡിനേറ്റുകൾ സ്വീകരിക്കേണ്ടതും ആവശ്യമാണ്. സേവനം ഉപയോഗിച്ച് വേഗത അളക്കുക www.speedtest.net അവ ഒരു മേശയിൽ വയ്ക്കുക:

csv ഫോർമാറ്റിലുള്ള പട്ടിക. തുടർന്ന് ഓരോ 6 മണിക്കൂറിലും ഇ-മെയിൽ വഴി ഈ അടയാളം അയയ്ക്കുക. പിശകുകളുണ്ടെങ്കിൽ, GPIO-യുമായി ബന്ധിപ്പിച്ചിരിക്കുന്ന LED ബ്ലിങ്ക് ചെയ്യുക.

നിരവധി അംഗീകാരങ്ങൾക്ക് ശേഷം ഞാൻ സാങ്കേതിക സവിശേഷതകൾ സൌജന്യ രൂപത്തിൽ വിവരിച്ചു. എന്നാൽ ചുമതലയുടെ അർത്ഥം ഇതിനകം ദൃശ്യമാണ്. എല്ലാറ്റിനും ഒരാഴ്ച സമയം നൽകി. എന്നാൽ വാസ്തവത്തിൽ അത് മൂന്നാഴ്ച നീണ്ടുനിന്നു. എന്റെ പ്രധാന ജോലിക്ക് ശേഷവും വാരാന്ത്യങ്ങളിലും മാത്രമാണ് ഞാൻ ഇത് ചെയ്തതെന്ന വസ്തുത ഇത് കണക്കിലെടുക്കുന്നു.

സ്പീഡ് മെഷർമെന്റ് സേവനത്തിന്റെയും ഹാർഡ്‌വെയറിന്റെയും ഉപയോഗത്തെക്കുറിച്ച് ഉപഭോക്താവ് മുൻകൂട്ടി സമ്മതിച്ചുവെന്ന വസ്തുതയിലേക്ക് വീണ്ടും ശ്രദ്ധ ആകർഷിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു, ഇത് എന്റെ കഴിവുകളെ വളരെയധികം പരിമിതപ്പെടുത്തി. ബജറ്റും പരിമിതമായതിനാൽ പ്രത്യേകിച്ചൊന്നും വാങ്ങിയില്ല. അതിനാൽ ഞങ്ങൾക്ക് ഈ നിയമങ്ങൾ അനുസരിച്ച് കളിക്കേണ്ടി വന്നു.

വാസ്തുവിദ്യയും വികസനവും

സ്കീം ലളിതവും വ്യക്തവുമാണ്. അതിനാൽ, പ്രത്യേക അഭിപ്രായങ്ങളൊന്നുമില്ലാതെ ഞാൻ ഇത് ഉപേക്ഷിക്കുന്നു.

ഈ ഭാഷയിൽ വികസിച്ച ഒരു അനുഭവവും ഇല്ലാതിരുന്നിട്ടും, മുഴുവൻ പദ്ധതിയും പൈത്തണിൽ നടപ്പിലാക്കാൻ ഞാൻ തീരുമാനിച്ചു. വികസനം വേഗത്തിലാക്കാൻ കഴിയുന്ന ഒരു കൂട്ടം റെഡിമെയ്ഡ് ഉദാഹരണങ്ങളും പരിഹാരങ്ങളും ഉള്ളതിനാൽ ഞാൻ അത് തിരഞ്ഞെടുത്തു. അതിനാൽ, പൈത്തണിൽ വികസിച്ചതിന്റെ ആദ്യ അനുഭവത്തെ ശകാരിക്കരുതെന്ന് എല്ലാ പ്രൊഫഷണൽ പ്രോഗ്രാമർമാരോടും ഞാൻ ആവശ്യപ്പെടുന്നു, എന്റെ കഴിവുകൾ മെച്ചപ്പെടുത്തുന്നതിന് ക്രിയാത്മകമായ വിമർശനങ്ങൾ കേൾക്കുന്നതിൽ എനിക്ക് എപ്പോഴും സന്തോഷമുണ്ട്.

ഈ പ്രക്രിയയിൽ പൈത്തണിന് 2, 3 എന്നീ രണ്ട് പതിപ്പുകൾ ഉണ്ടെന്ന് ഞാൻ കണ്ടെത്തി, അതിന്റെ ഫലമായി ഞാൻ മൂന്നാമത്തേതിൽ സ്ഥിരതാമസമാക്കി.

ഹാർഡ്വെയർ നോഡുകൾ

സിംഗിൾ പ്ലേറ്റ് vim2

എന്റെ പ്രധാന മെഷീനായി എനിക്ക് ഒരു ഒറ്റ ബോർഡ് കമ്പ്യൂട്ടർ തന്നു വിം2

ഒരു സ്മാർട്ട് ഹോം, സ്മാർട്ട്-ടിവി എന്നിവയ്‌ക്കായുള്ള മികച്ചതും ശക്തവുമായ മീഡിയ പ്രോസസ്സർ, എന്നാൽ ഈ ടാസ്‌ക്കിന് അങ്ങേയറ്റം അനുയോജ്യമല്ല, അല്ലെങ്കിൽ, മോശമായി അനുയോജ്യമെന്ന് പറയാം. ഉദാഹരണത്തിന്, അതിന്റെ പ്രധാന OS Android ആണ്, കൂടാതെ Linux ഒരു ദ്വിതീയ OS ആണ്, അതനുസരിച്ച് Linux-ന് കീഴിലുള്ള എല്ലാ നോഡുകളുടെയും ഡ്രൈവറുകളുടെയും ഉയർന്ന നിലവാരമുള്ള പ്രവർത്തനത്തിന് ആരും ഉറപ്പുനൽകുന്നില്ല. ചില പ്രശ്നങ്ങൾ ഈ പ്ലാറ്റ്‌ഫോമിന്റെ യുഎസ്ബി ഡ്രൈവറുകളുമായി ബന്ധപ്പെട്ടതാണെന്ന് ഞാൻ അനുമാനിക്കുന്നു, അതിനാൽ ഈ ബോർഡിൽ മോഡമുകൾ പ്രതീക്ഷിച്ചതുപോലെ പ്രവർത്തിച്ചില്ല. ഇതിന് വളരെ മോശമായതും ചിതറിക്കിടക്കുന്നതുമായ ഡോക്യുമെന്റേഷനും ഉണ്ട്, അതിനാൽ ഓരോ ഓപ്പറേഷനും ഡോക്കുകളിലൂടെ കുഴിക്കാൻ വളരെയധികം സമയമെടുത്തു. GPIO ഉപയോഗിച്ചുള്ള സാധാരണ ജോലി പോലും ധാരാളം രക്തം എടുത്തു. ഉദാഹരണത്തിന്, LED സജ്ജീകരിക്കാൻ എനിക്ക് നിരവധി മണിക്കൂറുകൾ എടുത്തു. പക്ഷേ, വസ്തുനിഷ്ഠമായി പറഞ്ഞാൽ, അത് ഏത് തരത്തിലുള്ള സിംഗിൾ ബോർഡാണെന്നത് അടിസ്ഥാനപരമായി പ്രധാനമല്ല, പ്രധാന കാര്യം അത് പ്രവർത്തിക്കുകയും യുഎസ്ബി പോർട്ടുകൾ ഉണ്ടായിരുന്നു എന്നതാണ്.

ആദ്യം, എനിക്ക് ഈ ബോർഡിൽ Linux ഇൻസ്റ്റാൾ ചെയ്യണം. എല്ലാവർക്കുമായി ഡോക്യുമെന്റേഷന്റെ വന്യത പരിശോധിക്കാതിരിക്കാനും ഈ സിംഗിൾ ബോർഡ് സംവിധാനം കൈകാര്യം ചെയ്യുന്നവർക്കും വേണ്ടി, ഞാൻ ഈ അധ്യായം എഴുതുന്നു.

Linux ഇൻസ്റ്റാൾ ചെയ്യാൻ രണ്ട് ഓപ്ഷനുകളുണ്ട്: ഒരു ബാഹ്യ SD കാർഡിൽ അല്ലെങ്കിൽ ഒരു ആന്തരിക MMC. കാർഡ് ഉപയോഗിച്ച് ഇത് എങ്ങനെ പ്രവർത്തിക്കാമെന്ന് മനസിലാക്കാൻ ഞാൻ ഒരു സായാഹ്നം ചെലവഴിച്ചു, അതിനാൽ ഇത് എംഎംസിയിൽ ഇൻസ്റ്റാൾ ചെയ്യാൻ ഞാൻ തീരുമാനിച്ചു, എന്നിരുന്നാലും ഒരു ബാഹ്യ കാർഡ് ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് വളരെ എളുപ്പമായിരിക്കും.

ഫേംവെയറിനെക്കുറിച്ച് വക്രമായി ഇവിടെ പറഞ്ഞു. ഞാൻ വിചിത്രമായതിൽ നിന്ന് റഷ്യൻ ഭാഷയിലേക്ക് വിവർത്തനം ചെയ്യുന്നു. ബോർഡ് ഫ്ലാഷ് ചെയ്യുന്നതിന്, എനിക്ക് ഹാർഡ്‌വെയർ UART കണക്റ്റുചെയ്യേണ്ടതുണ്ട്. അത് ബന്ധിപ്പിച്ചു ഇനിപ്പറയുന്ന രീതിയിൽ.

• ടൂൾ പിൻ GND: <—> VIM-കളുടെ GPIO-യുടെ പിൻ17
• ടൂൾ പിൻ TXD: <—> VIM കളുടെ GPIO യുടെ Pin18 (Linux_Rx)
• ടൂൾ പിൻ RXD: <—> VIM കളുടെ GPIO യുടെ Pin19 (Linux_Tx)
• ടൂൾ പിൻ VCC: <—> VIM-കളുടെ GPIO-യുടെ പിൻ20

അതിനുശേഷം, ഞാൻ ഫേംവെയർ ഡൗൺലോഡ് ചെയ്തു ഇവിടെ നിന്ന്. നിർദ്ദിഷ്ട ഫേംവെയർ പതിപ്പ് VIM1_Ubuntu-server-bionic_Linux-4.9_arm64_EMMC_V20191231.

ഈ ഫേംവെയർ അപ്‌ലോഡ് ചെയ്യുന്നതിന്, എനിക്ക് യൂട്ടിലിറ്റികൾ ആവശ്യമാണ്. ഇതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിശദാംശങ്ങൾ ഇവിടെ. വിൻഡോസിന് കീഴിൽ ഇത് മിന്നാൻ ഞാൻ ശ്രമിച്ചിട്ടില്ല, പക്ഷേ ലിനക്സിന് കീഴിലുള്ള ഫേംവെയറിനെക്കുറിച്ച് എനിക്ക് കുറച്ച് വാക്കുകൾ പറയേണ്ടതുണ്ട്. ആദ്യം, നിർദ്ദേശങ്ങൾക്കനുസരിച്ച് ഞാൻ യൂട്ടിലിറ്റികൾ ഇൻസ്റ്റാൾ ചെയ്യും.

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

ആണ്ട്... ഒന്നും പ്രവർത്തിക്കുന്നില്ല. ഇൻസ്റ്റാളേഷൻ സ്ക്രിപ്റ്റുകൾ എഡിറ്റുചെയ്യാൻ ഞാൻ കുറച്ച് മണിക്കൂർ ചെലവഴിച്ചു, അങ്ങനെ എല്ലാം എനിക്ക് ശരിയായി ഇൻസ്റ്റാൾ ചെയ്യപ്പെടും. ഞാൻ അവിടെ എന്താണ് ചെയ്തതെന്ന് എനിക്ക് ഓർമയില്ല, പക്ഷേ കുതിരകളുമായി ആ സർക്കസും ഉണ്ടായിരുന്നു. അതുകൊണ്ട് സൂക്ഷിക്കുക. എന്നാൽ ഈ യൂട്ടിലിറ്റികൾ ഇല്ലാതെ vim2 കൂടുതൽ പീഡിപ്പിക്കുന്നതിൽ അർത്ഥമില്ല. അവനുമായി ഒരിക്കലും കുഴപ്പമുണ്ടാക്കാതിരിക്കുന്നതാണ് നല്ലത്!

നരകത്തിന്റെ ഏഴ് സർക്കിളുകൾ, സ്ക്രിപ്റ്റ് കോൺഫിഗറേഷൻ, ഇൻസ്റ്റാളേഷൻ എന്നിവയ്ക്ക് ശേഷം, എനിക്ക് വർക്കിംഗ് യൂട്ടിലിറ്റികളുടെ ഒരു പാക്കേജ് ലഭിച്ചു. ഞാൻ എന്റെ ലിനക്സ് കമ്പ്യൂട്ടറിലേക്ക് USB വഴി ബോർഡ് കണക്‌റ്റ് ചെയ്‌തു, കൂടാതെ മുകളിലുള്ള ഡയഗ്രം അനുസരിച്ച് 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

അത്രയേ ഉള്ളൂ. ഞാൻ പരിശോധിച്ചു, ബോർഡിൽ ലിനക്സ് ഉണ്ട്. ലോഗിൻ/പാസ്‌വേഡ് 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

നിങ്ങൾക്ക് ബുദ്ധിമുട്ട് തോന്നുന്നുവെങ്കിൽ, ഈ ബോർഡ് ഉപയോഗിക്കരുത്; റാസ്‌ബെറി പൈയാണ് നല്ലത്. സത്യസന്ധമായി.

മോഡം Huawei e3372h - 153

ഈ മോഡം എനിക്ക് രക്തത്തിന്റെ ഒരു പ്രധാന ഉറവിടമായിരുന്നു, വാസ്തവത്തിൽ, ഇത് മുഴുവൻ പ്രോജക്റ്റിന്റെയും തടസ്സമായി മാറി. പൊതുവേ, ഈ ഉപകരണങ്ങൾക്കുള്ള "മോഡം" എന്ന പേര് ജോലിയുടെ സത്തയെ പ്രതിഫലിപ്പിക്കുന്നില്ല: ഇതൊരു ശക്തമായ സംയോജനമാണ്, ഈ ഹാർഡ്‌വെയറിന് ഡ്രൈവറുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനായി ഒരു സിഡി-റോം ആണെന്ന് നടിക്കുന്ന ഒരു സംയോജിത ഉപകരണം ഉണ്ട്, തുടർന്ന് നെറ്റ്‌വർക്ക് കാർഡ് മോഡിലേക്ക് മാറുന്നു.

വാസ്തുവിദ്യാപരമായി, ഒരു ലിനക്സ് ഉപയോക്താവിന്റെ കാഴ്ചപ്പാടിൽ, എല്ലാ ക്രമീകരണങ്ങൾക്കും ശേഷം, ഇത് ഇതുപോലെ കാണപ്പെടുന്നു: മോഡം കണക്റ്റുചെയ്‌തതിന് ശേഷം, എനിക്ക് ഒരു eth* നെറ്റ്‌വർക്ക് ഇന്റർഫേസ് ഉണ്ട്, അത് dhcp വഴി 192.168.8.100 IP വിലാസവും സ്ഥിരസ്ഥിതി ഗേറ്റ്‌വേയും സ്വീകരിക്കുന്നു. 192.168.8.1 ആണ്.

ഒപ്പം ഏറ്റവും പ്രധാനപ്പെട്ട നിമിഷവും! AT കമാൻഡുകളാൽ നിയന്ത്രിക്കപ്പെടുന്ന മോഡം മോഡിൽ ഈ മോഡം മോഡലിന് പ്രവർത്തിക്കാൻ കഴിയില്ല. എല്ലാം വളരെ ലളിതമായിരിക്കും, ഓരോ മോഡമിനും PPP കണക്ഷനുകൾ സൃഷ്ടിക്കുക, തുടർന്ന് അവ ഉപയോഗിച്ച് പ്രവർത്തിക്കുക. എന്നാൽ എന്റെ കാര്യത്തിൽ, "സ്വയം" (കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, udev നിയമങ്ങൾക്കനുസൃതമായി ഒരു ലിനക്സ് ഡൈവർ), ഒരു eth ഇന്റർഫേസ് സൃഷ്ടിക്കുകയും dhcp വഴി അതിന് ഒരു IP വിലാസം നൽകുകയും ചെയ്യുന്നു.

കൂടുതൽ ആശയക്കുഴപ്പം ഒഴിവാക്കാൻ, "മോഡം" എന്ന വാക്ക് മറന്ന് നെറ്റ്വർക്ക് കാർഡും ഗേറ്റ്വേയും പറയാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു, കാരണം സാരാംശത്തിൽ, ഒരു പുതിയ നെറ്റ്വർക്ക് കാർഡ് ഒരു ഗേറ്റ്വേയുമായി ബന്ധിപ്പിക്കുന്നത് പോലെയാണ്.
ഒരു മോഡം ഉള്ളപ്പോൾ, ഇത് പ്രത്യേക പ്രശ്നങ്ങളൊന്നും ഉണ്ടാക്കില്ല, എന്നാൽ ഒന്നിൽ കൂടുതൽ ഉള്ളപ്പോൾ, അതായത് n-പീസ്, ഇനിപ്പറയുന്ന നെറ്റ്‌വർക്ക് ചിത്രം ഉയർന്നുവരുന്നു.

അതായത്, n നെറ്റ്‌വർക്ക് കാർഡുകൾ, ഒരേ ഐപി വിലാസം, ഓരോന്നിനും ഒരേ ഡിഫോൾട്ട് ഗേറ്റ്‌വേ. എന്നാൽ വാസ്തവത്തിൽ, അവ ഓരോന്നും സ്വന്തം ഓപ്പറേറ്ററുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു.

തുടക്കത്തിൽ, എനിക്ക് ഒരു ലളിതമായ പരിഹാരം ഉണ്ടായിരുന്നു: ifconfig അല്ലെങ്കിൽ ip കമാൻഡ് ഉപയോഗിച്ച്, എല്ലാ ഇന്റർഫേസുകളും ഓഫാക്കി ഒരെണ്ണം ഓണാക്കി പരീക്ഷിക്കുക. സ്വിച്ചിംഗ് നിമിഷങ്ങളിൽ എനിക്ക് ഉപകരണത്തിലേക്ക് കണക്റ്റുചെയ്യാൻ കഴിഞ്ഞില്ല എന്നതൊഴിച്ചാൽ, പരിഹാരം എല്ലാവർക്കും നല്ലതാണ്. സ്വിച്ചിംഗ് ഇടയ്ക്കിടെയുള്ളതും വേഗതയുള്ളതുമായതിനാൽ, എനിക്ക് കണക്റ്റുചെയ്യാൻ അവസരമില്ലായിരുന്നു.

അതിനാൽ, മോഡമുകളുടെ ഐപി വിലാസങ്ങൾ സ്വമേധയാ മാറ്റുന്നതിനും റൂട്ടിംഗ് ക്രമീകരണങ്ങൾ ഉപയോഗിച്ച് ട്രാഫിക്ക് ഡ്രൈവ് ചെയ്യുന്നതിനുമുള്ള പാത ഞാൻ തിരഞ്ഞെടുത്തു.

മോഡമുകളുമായുള്ള എന്റെ പ്രശ്‌നങ്ങൾ ഇത് അവസാനിച്ചില്ല: വൈദ്യുതി പ്രശ്‌നങ്ങളുടെ കാര്യത്തിൽ, അവ വീണു, യുഎസ്ബി ഹബിലേക്ക് നല്ല സ്ഥിരതയുള്ള പവർ സപ്ലൈ ആവശ്യമാണ്. പവർ നേരിട്ട് ഹബിലേക്ക് സോൾഡറിംഗ് ചെയ്തുകൊണ്ട് ഞാൻ ഈ പ്രശ്നം പരിഹരിച്ചു. ഞാൻ നേരിട്ടതും മുഴുവൻ പ്രോജക്റ്റും നശിപ്പിച്ചതുമായ മറ്റൊരു പ്രശ്നം: ഉപകരണത്തിന്റെ റീബൂട്ട് അല്ലെങ്കിൽ തണുത്ത ആരംഭത്തിന് ശേഷം, എല്ലാ മോഡമുകളും കണ്ടെത്തിയില്ല, എല്ലായ്‌പ്പോഴും അല്ല, എന്തുകൊണ്ടാണ് ഇത് സംഭവിച്ചതെന്നും ഏത് അൽഗോരിതം ഉപയോഗിച്ചാണെന്നും എനിക്ക് നിർണ്ണയിക്കാൻ കഴിഞ്ഞില്ല. എന്നാൽ ആദ്യം കാര്യങ്ങൾ ആദ്യം.

മോഡം ശരിയായി പ്രവർത്തിക്കുന്നതിന്, ഞാൻ usb-modeswitch പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്തു.

sudo apt update
sudo apt install -y usb-modeswitch

അതിനുശേഷം, കണക്റ്റുചെയ്‌തതിനുശേഷം, മോഡം ശരിയായി കണ്ടെത്തുകയും udev സബ്സിസ്റ്റം ക്രമീകരിക്കുകയും ചെയ്യും. മോഡം കണക്‌റ്റ് ചെയ്‌ത് നെറ്റ്‌വർക്ക് ദൃശ്യമാണെന്ന് ഉറപ്പാക്കിക്കൊണ്ട് ഞാൻ പരിശോധിക്കുന്നു.
എനിക്ക് പരിഹരിക്കാൻ കഴിയാത്ത മറ്റൊരു പ്രശ്നം: ഈ മോഡത്തിൽ നിന്ന് ഞങ്ങൾ പ്രവർത്തിക്കുന്ന ഓപ്പറേറ്ററുടെ പേര് എനിക്ക് എങ്ങനെ ലഭിക്കും? ഓപ്പറേറ്ററുടെ പേര് മോഡം വെബ് ഇന്റർഫേസിൽ 192.168.8.1-ൽ അടങ്ങിയിരിക്കുന്നു. അജാക്സ് അഭ്യർത്ഥനകളിലൂടെ ഡാറ്റ സ്വീകരിക്കുന്ന ഒരു ഡൈനാമിക് വെബ് പേജാണിത്, അതിനാൽ പേജ് വെജിറ്റുചെയ്യുന്നതും പേര് പാഴ്‌സ് ചെയ്യുന്നതും പ്രവർത്തിക്കില്ല. അങ്ങനെ ഒരു വെബ് പേജ് എങ്ങനെ ഡെവലപ്പ് ചെയ്യാമെന്നും മറ്റും നോക്കാൻ തുടങ്ങി, ഞാൻ ഒരുതരം വിഡ്ഢിത്തമാണ് ചെയ്യുന്നതെന്ന് മനസ്സിലായി. തൽഫലമായി, അവൻ തുപ്പി, സ്പീഡ്ടെസ്റ്റ് API ഉപയോഗിച്ച് ഓപ്പറേറ്റർ സ്വീകരിക്കാൻ തുടങ്ങി.

AT കമാൻഡുകൾ വഴി മോഡം ആക്സസ് ഉണ്ടെങ്കിൽ വളരെ എളുപ്പമായിരിക്കും. ഇത് വീണ്ടും ക്രമീകരിക്കാനും ഒരു പിപിപി കണക്ഷൻ സൃഷ്ടിക്കാനും ഒരു ഐപി നൽകാനും ടെലികോം ഓപ്പറേറ്റർ നേടാനും കഴിയും. പക്ഷേ, അയ്യോ, എനിക്ക് ലഭിച്ചതിൽ ഞാൻ പ്രവർത്തിക്കുന്നു.

ജിപിഎസ്

എനിക്ക് നൽകിയ GPS റിസീവറിന് UART ഇന്റർഫേസും പവറും ഉണ്ടായിരുന്നു. ഇത് മികച്ച പരിഹാരമായിരുന്നില്ല, പക്ഷേ അത് ഇപ്പോഴും പ്രവർത്തനക്ഷമവും ലളിതവുമായിരുന്നു. റിസീവർ ഇതുപോലെ നോക്കി.

സത്യം പറഞ്ഞാൽ, ഇത് ഒരു ജിപിഎസ് റിസീവറിൽ പ്രവർത്തിക്കുന്നത് ഇതാദ്യമാണ്, പക്ഷേ ഞാൻ പ്രതീക്ഷിച്ചതുപോലെ, എല്ലാം വളരെക്കാലം മുമ്പ് ഞങ്ങൾക്കായി ചിന്തിച്ചു. അതിനാൽ ഞങ്ങൾ റെഡിമെയ്ഡ് പരിഹാരങ്ങൾ ഉപയോഗിക്കുന്നു.

ആദ്യം, 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 വയർ എന്റെ കൈയിലാണ്, UART ഡീബഗ്ഗർ വയറുകൾ എന്റെ വിരലുകൾക്ക് കീഴിൽ ദൃശ്യമാണ്.

ഞാൻ 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 ന് മോശം സ്വീകരണം ലഭിക്കുമെന്നതിനാലും എല്ലായ്പ്പോഴും ഡാറ്റ ലഭിക്കാത്തതിനാലും ഞാൻ ഇത് ചെയ്യാൻ തീരുമാനിച്ചു. ഡാറ്റ ലഭിക്കാൻ നിങ്ങൾ കാത്തിരിക്കുകയാണെങ്കിൽ, നിങ്ങൾ ഒരു വിദൂര മുറിയിൽ ജോലി ചെയ്യുകയാണെങ്കിൽ, ഈ സ്ഥലത്ത് പ്രോഗ്രാം മരവിപ്പിക്കും. അതിനാൽ, ഞാൻ ഈ അസാധാരണമായ ഓപ്ഷൻ നടപ്പിലാക്കി.

തത്വത്തിൽ, കൂടുതൽ സമയമുണ്ടെങ്കിൽ, UART വഴി ജിപിഎസിൽ നിന്ന് നേരിട്ട് ഡാറ്റ സ്വീകരിക്കാനും പ്രത്യേക ത്രെഡിൽ പാഴ്സ് ചെയ്യാനും അതുമായി പ്രവർത്തിക്കാനും സാധിക്കും. എന്നാൽ സമയമില്ല, അതിനാൽ ക്രൂരമായ വൃത്തികെട്ട കോഡ്. അതെ, എനിക്ക് നാണമില്ല.

എൽഇഡി

എൽഇഡി കണക്റ്റുചെയ്യുന്നത് ഒരേ സമയം ലളിതവും ബുദ്ധിമുട്ടുള്ളതുമായിരുന്നു. സിസ്റ്റത്തിലെ പിൻ നമ്പർ ബോർഡിലെ പിൻ നമ്പറുമായി പൊരുത്തപ്പെടാത്തതും ഡോക്യുമെന്റേഷൻ ഇടതുവശത്ത് എഴുതിയിരിക്കുന്നതുമാണ് പ്രധാന ബുദ്ധിമുട്ട്. OS-ലെ ഹാർഡ്‌വെയർ പിൻ നമ്പറും പിൻ നമ്പറും താരതമ്യം ചെയ്യാൻ, നിങ്ങൾ കമാൻഡ് പ്രവർത്തിപ്പിക്കേണ്ടതുണ്ട്:

gpio readall

സിസ്റ്റത്തിലും ബോർഡിലും പിൻ കത്തിടപാടുകളുടെ ഒരു പട്ടിക പ്രദർശിപ്പിക്കും. അതിനുശേഷം എനിക്ക് ഇതിനകം തന്നെ OS-ൽ തന്നെ പിൻ പ്രവർത്തിപ്പിക്കാൻ കഴിയും. എന്റെ കാര്യത്തിൽ എൽഇഡി ബന്ധിപ്പിച്ചിരിക്കുന്നു 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 ഉപയോഗിച്ച് എങ്ങനെ പ്രവർത്തിക്കാം (ലളിതമായ ഉദാഹരണങ്ങൾ) ഇതിൽ കാണാം പ്രസക്തമായ വിഭാഗം.

താഴെ പറയുന്ന കമാൻഡ് ഉപയോഗിച്ച് ഞാൻ പൈത്തൺ ലൈബ്രറി ഇൻസ്റ്റാൾ ചെയ്യുന്നു.

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-ൽ ഒരു മെയിൽബോക്സ് രജിസ്റ്റർ ചെയ്യുകയും തുടർന്ന് എടുത്തു മെയിൽ അയക്കുന്നതിനുള്ള ഒരു ഉദാഹരണമാണിത്. ഞാൻ അത് പരിശോധിച്ച് പ്രോഗ്രാമിൽ നടപ്പിലാക്കി. ഈ ഉദാഹരണം ജിമെയിലിൽ നിന്ന് അയയ്ക്കുന്നത് ഉൾപ്പെടെ വിവിധ ഓപ്ഷനുകൾ പരിശോധിക്കുന്നു. എന്റെ മെയിൽ സെർവർ സജ്ജീകരിക്കുന്നതിൽ ഞാൻ വിഷമിക്കേണ്ടതില്ല, അതിന് സമയമില്ലായിരുന്നു, പക്ഷേ പിന്നീട് അത് വ്യർത്ഥമായി.

ഷെഡ്യൂളർ അനുസരിച്ച് ലോഗുകൾ അയച്ചു, ഒരു കണക്ഷൻ ഉണ്ടെങ്കിൽ, ഓരോ 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 സേവനങ്ങളിലൂടെ അത്തരമൊരു പ്രശ്നത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ സ്വയമേവ അയയ്ക്കുമ്പോൾ ഓർമ്മിക്കുക.

ഫീഡ്ബാക്ക് സെർവർ

ഒരു വിദൂര ഹാർഡ്‌വെയറിലേക്ക് ആക്‌സസ് ലഭിക്കുന്നതിനും അത് ഇഷ്‌ടാനുസൃതമാക്കാനും പുനഃക്രമീകരിക്കാനും കഴിയുന്നതിന്, എനിക്ക് ഒരു ബാഹ്യ സെർവർ ആവശ്യമാണ്. പൊതുവായി പറഞ്ഞാൽ, എല്ലാ ഡാറ്റയും സെർവറിലേക്ക് അയച്ച് വെബ് ഇന്റർഫേസിലെ എല്ലാ മനോഹരമായ ഗ്രാഫുകളും നിർമ്മിക്കുന്നത് ശരിയായിരിക്കും. എന്നാൽ എല്ലാം ഒറ്റയടിക്ക് അല്ല.

VPS-നായി ഞാൻ തിരഞ്ഞെടുത്തു ruvds.com. നിങ്ങൾക്ക് ഏറ്റവും ലളിതമായ സെർവർ എടുക്കാം. പൊതുവേ, എന്റെ ആവശ്യങ്ങൾക്ക് ഇത് മതിയാകും. പക്ഷേ, സെർവറിനായി എന്റെ സ്വന്തം പോക്കറ്റിൽ നിന്ന് പണം നൽകാത്തതിനാൽ, ഒരു വെബ് ഇന്റർഫേസ്, ഞങ്ങളുടെ സ്വന്തം എസ്എംടിപി സെർവർ, വിപിഎൻ മുതലായവ വിന്യസിച്ചാൽ മതിയാകും എന്നതിനാൽ, ഒരു ചെറിയ കരുതൽ ഉപയോഗിച്ച് അത് എടുക്കാൻ ഞാൻ തീരുമാനിച്ചു. കൂടാതെ, ഒരു ടെലിഗ്രാം ബോട്ട് സജ്ജീകരിക്കാനും അത് ബ്ലോക്ക് ചെയ്യുന്നതിൽ പ്രശ്‌നങ്ങളുണ്ടാകാതിരിക്കാനും കഴിയും. അതിനാൽ, ഞാൻ ആംസ്റ്റർഡാമും ഇനിപ്പറയുന്ന പാരാമീറ്ററുകളും തിരഞ്ഞെടുത്തു.

ഹാർഡ്‌വെയറുമായുള്ള ആശയവിനിമയ രീതി എന്ന നിലയിൽ, 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 കണക്ഷൻ നിലനിർത്തുക എന്നതാണ്. ഓരോ ടെസ്റ്റിലും ഡിഫോൾട്ട് ഗേറ്റ്‌വേയും ഡിഎൻഎസ് സെർവറും വീണ്ടും ക്രമീകരിക്കുന്നത് ഉൾപ്പെടുന്നു. എന്തായാലും ആരും വായിക്കാത്തതിനാൽ, മരം പാളത്തിൽ വണ്ടി കയറില്ലെന്ന് അറിയുക. ഈസ്റ്റർ മുട്ട കണ്ടെത്തുന്നയാൾക്ക് കുറച്ച് മിഠായി ലഭിക്കും.

ഇത് ചെയ്യുന്നതിന്, ഞാൻ ഒരു പ്രത്യേക റൂട്ടിംഗ് ടേബിൾ സൃഷ്ടിക്കുന്നു -സെറ്റ്-മാർക്ക് 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"

ആദ്യ അനുഭവം ടെലി 2 ഓപ്പറേറ്റർ ഉപയോഗിച്ചാണ്, അത് ഞാൻ നിരവധി ദിവസങ്ങൾ നടത്തി.

ഇവിടെ ഞാൻ ഒരു ഡൈനാമിക് മെഷറിംഗ് സെർവർ ഉപയോഗിച്ചു. സ്പീഡ് അളവുകൾ പ്രവർത്തിക്കുന്നു, പക്ഷേ വളരെയധികം ചാഞ്ചാടുന്നു, പക്ഷേ ചില ശരാശരി മൂല്യങ്ങൾ ഇപ്പോഴും ദൃശ്യമാണ്, കൂടാതെ ഡാറ്റ ഫിൽട്ടർ ചെയ്യുന്നതിലൂടെ ഇത് നേടാനാകും, ഉദാഹരണത്തിന്, ചലിക്കുന്ന ശരാശരി.

പിന്നീട് മറ്റ് ടെലികോം ഓപ്പറേറ്റർമാർക്കായി ഞാൻ നിരവധി ഗ്രാഫുകൾ നിർമ്മിച്ചു. ഈ സാഹചര്യത്തിൽ, ഇതിനകം ഒരു ടെസ്റ്റിംഗ് സെർവർ ഉണ്ടായിരുന്നു, കൂടാതെ ഫലങ്ങളും വളരെ രസകരമായിരുന്നു.

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഈ ഡാറ്റയുടെ ഗവേഷണത്തിനും പ്രോസസ്സിംഗിനും വിഷയം വളരെ വിപുലമാണ്, മാത്രമല്ല രണ്ടാഴ്ചത്തെ ജോലിക്ക് ഇത് നിലനിൽക്കില്ല. പക്ഷേ…

ജോലിയുടെ ഫലം

എന്റെ നിയന്ത്രണത്തിനപ്പുറമുള്ള സാഹചര്യങ്ങൾ കാരണം ജോലി പെട്ടെന്ന് പൂർത്തിയായി. ഈ പ്രോജക്റ്റിന്റെ ബലഹീനതകളിലൊന്ന്, എന്റെ ആത്മനിഷ്ഠമായ അഭിപ്രായത്തിൽ, മറ്റ് മോഡമുകളുമായി ഒരേസമയം പ്രവർത്തിക്കാൻ ശരിക്കും ആഗ്രഹിക്കാത്ത മോഡം ആയിരുന്നു, ഓരോ തവണ ലോഡ് ചെയ്യുമ്പോൾ അത്തരം തന്ത്രങ്ങൾ ഉണ്ടാക്കി. ഈ ആവശ്യങ്ങൾക്കായി, മറ്റ് നിരവധി മോഡം മോഡലുകൾ ഉണ്ട്; സാധാരണയായി അവ ഇതിനകം തന്നെ മിനി പിസിഐ-ഇ ഫോർമാറ്റിലാണ്, കൂടാതെ ഉപകരണത്തിനുള്ളിൽ ഇൻസ്റ്റാൾ ചെയ്യുകയും കോൺഫിഗർ ചെയ്യാൻ വളരെ എളുപ്പമാണ്. എന്നാൽ അത് തികച്ചും വ്യത്യസ്തമായ ഒരു കഥയാണ്. പ്രോജക്റ്റ് രസകരമായിരുന്നു, അതിൽ പങ്കെടുക്കാൻ കഴിഞ്ഞതിൽ ഞാൻ വളരെ സന്തോഷിച്ചു.

അവലംബം: www.habr.com