בדיקת מהירות בו זמנית במספר מודמי LTE

במהלך ההסגר הציעו לי להשתתף בפיתוח מכשיר למדידת מהירות מודמי LTE עבור מספר מפעילים סלולריים.

הלקוח רצה להעריך את המהירות של מפעילי טלקום שונים במקומות גיאוגרפיים שונים על מנת שיוכל להבין איזה מפעיל סלולרי הוא האופטימלי ביותר עבורו בעת התקנת ציוד באמצעות חיבור LTE, למשל, לשידורי וידאו. יחד עם זאת, היה צריך לפתור את הבעיה בצורה הכי פשוטה וזולה שאפשר, ללא ציוד יקר.

אני אגיד מיד שהמשימה היא לא הכי פשוטה ועתירת ידע; אני אגיד לך באילו בעיות נתקלתי ואיך פתרתי אותן. אז בוא נלך.

שים לב

מדידת מהירות חיבור LTE היא עניין מורכב מאוד: צריך לבחור את הציוד ואת טכניקת המדידה הנכונים, וגם להבין היטב את הטופולוגיה והתפעול של הרשת הסלולרית. בנוסף, המהירות יכולה להיות מושפעת מכמה גורמים: מספר המנויים בתא, תנאי מזג האוויר, אפילו מתא לתא המהירות יכולה להשתנות באופן דרמטי עקב טופולוגיית הרשת. באופן כללי, מדובר בבעיה עם מספר עצום של אלמונים, ורק מפעיל טלקום יכול לפתור אותה בצורה נכונה.

בתחילה, הלקוח רק רצה להסיע את השליח עם הטלפונים של המפעילים, לבצע מדידות ישירות בטלפון ולאחר מכן לרשום את תוצאות מדידת המהירות במחברת. הפתרון שלי למדידת המהירות של רשתות lte, אם כי לא אידיאלי, פותר את הבעיה.

מחוסר זמן קיבלתי החלטות לא לטובת נוחות או פרקטיות, אלא לטובת מהירות הפיתוח. לדוגמה, ssh הפוך שימש לגישה מרחוק, במקום ה-VPN המעשי יותר, על מנת לחסוך זמן בהגדרת השרת וכל לקוח בודד.

משימה טכנית

כפי שנאמר בכתבה ללא מפרט טכני: למה הלקוח לא רוצה את זה: אל תעבוד בלי מפרט טכני! אף פעם, בשום מקום!

המשימה הטכנית הייתה די פשוטה, ארחיב אותה מעט להבנת משתמש הקצה. בחירת הפתרונות הטכניים והציוד הוכתבה על ידי הלקוח. אז, המפרט הטכני עצמו, לאחר כל האישורים:

מבוסס על מחשב לוח יחיד vim2 צור בודק מהירות עבור חיבורי lte דרך מודמי Huawei e3372h - 153 מספר מפעילי טלקום (מאחד עד n). כמו כן, יש צורך לקבל קואורדינטות ממקלט GPS המחובר באמצעות UART. בצע מדידות מהירות באמצעות השירות www.speedtest.net והכנס אותם לטבלה כמו:

טבלה בפורמט csv. לאחר מכן שלח את השלט הזה בדואר אלקטרוני כל 6 שעות. במקרה של שגיאות, מהבהב את הנורית המחוברת ל-GPIO.

תיארתי את המפרט הטכני בצורה חופשית, לאחר אישורים רבים. אבל המשמעות של המשימה כבר גלויה. ניתן שבוע לכל דבר. אבל במציאות זה נמשך שלושה שבועות. זה לוקח בחשבון את העובדה שעשיתי את זה רק אחרי העבודה העיקרית שלי ובסופי שבוע.

כאן אני רוצה להסב שוב את תשומת הלב לכך שהלקוח הסכים מראש על השימוש בשירות מדידת המהירות ובחומרה, מה שהגביל מאוד את היכולות שלי. גם התקציב היה מוגבל, כך שלא נרכש שום דבר מיוחד. אז היינו צריכים לשחק לפי הכללים האלה.

אדריכלות ופיתוח

התכנית פשוטה וברורה. לכן, אשאיר אותו ללא הערות מיוחדות.

החלטתי ליישם את כל הפרויקט ב-python, למרות שלא היה לי ניסיון בפיתוח בשפה הזו בכלל. בחרתי בו כי היו המון דוגמאות ופתרונות מוכנים שיכולים להאיץ את הפיתוח. לכן, אני מבקש מכל המתכנתים המקצועיים לא לנזוף בניסיון הראשון שלי בפיתוח בפיתון, ואני תמיד שמח לשמוע ביקורת בונה לשיפור הכישורים שלי.

גם בתהליך גיליתי שלפיתון יש שתי גרסאות רצות 2 ו-3, כתוצאה מכך התקבעתי על השלישית.

צמתי חומרה

צלחת אחת vim2

קיבלתי מחשב עם לוח יחיד בתור המכונה הראשית שלי vim2

מעבד מדיה מעולה ועוצמתי לבית חכם ו-SMART-TV, אבל מאוד לא מתאים למשימה הזו, או, נניח, לא מתאים. לדוגמה, מערכת ההפעלה העיקרית שלו היא אנדרואיד, ולינוקס היא מערכת הפעלה משנית, ובהתאם לכך אף אחד לא מבטיח את הפעולה האיכותית של כל הצמתים והדרייברים תחת לינוקס. ואני מניח שחלק מהבעיות היו קשורות לדרייברי ה-USB של הפלטפורמה הזו, כך שהמודמים לא פעלו כמצופה בלוח הזה. יש לו גם תיעוד גרוע ומפוזר, כך שכל פעולה לקחה הרבה זמן לחפור ברציפים. אפילו עבודה רגילה עם GPIO לקחה הרבה דם. לדוגמה, לקח לי כמה שעות להגדיר את ה-LED. אבל, כדי להיות אובייקטיבי, ביסודו לא היה חשוב איזה סוג של לוח יחיד זה היה, העיקר שזה עובד ויש יציאות USB.

ראשית, אני צריך להתקין לינוקס על הלוח הזה. כדי לא לסרוק את פראי התיעוד עבור כולם, וגם עבור אלה שיתמודדו עם מערכת הלוח הבודד הזו, אני כותב את הפרק הזה.

ישנן שתי אפשרויות להתקנת לינוקס: על כרטיס SD חיצוני או על MMC פנימי. ביליתי ערב בניסיון להבין איך לגרום לזה לעבוד עם הכרטיס, אז החלטתי להתקין אותו על ה-MMC, למרות שללא ספק יהיה הרבה יותר קל לעבוד עם כרטיס חיצוני.

לגבי הקושחה מסופר כאן בצורה עקומה. אני מתרגם ממוזר לרוסית. כדי להבהב את הלוח, אני צריך לחבר את החומרה UART. חיבר אותו בדרך הבאה.

• Pin Tool GND: <—> Pin17 של GPIO של VIMs
• Pin Tool TXD: <—> Pin18 של GPIO של VIMs (Linux_Rx)
• Pin Tool RXD: <—> Pin19 של GPIO של VIMs (Linux_Tx)
• Tool Pin VCC: <—> Pin20 של GPIO של VIMs

לאחר מכן, הורדתי את הקושחה מכאן. גרסת קושחה ספציפית VIM1_Ubuntu-server-bionic_Linux-4.9_arm64_EMMC_V20191231.

כדי להעלות קושחה זו, אני צריך כלי עזר. פרטים נוספים על זה כאן. לא ניסיתי להבהב את זה תחת Windows, אבל אני צריך להגיד לך כמה מילים על קושחה תחת לינוקס. ראשית, אתקין את כלי השירות לפי ההוראות.

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

Aaand... שום דבר לא עובד. ביליתי כמה שעות בעריכת תסריטי ההתקנה כדי שהכל יתקין לי כמו שצריך. אני לא זוכר מה עשיתי שם, אבל היה גם את הקרקס הזה עם סוסים. אז היו זהירים. אבל בלי כלי השירות האלה אין טעם לענות את vim2 עוד יותר. עדיף לא להתעסק איתו בכלל!

לאחר שבעה מעגלים של גיהנום, תצורת סקריפט והתקנה, קיבלתי חבילה של כלי עזר עובדים. חיברתי את הלוח דרך USB למחשב הלינוקס שלי, וגם חיברתי את ה-UART לפי התרשים למעלה.
אני מגדיר את מסוף המיניקום האהוב עליי למהירות של 115200, ללא בקרת שגיאות חומרה ותוכנה. ובואו נתחיל.

בעת טעינת VIM2 במסוף UART, אני לוחץ על מקש, כגון מקש הרווח, כדי להפסיק את הטעינה. לאחר הופעת השורה

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 (כן, לא מאובטח, אבל נוח).

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 על מנת להתקין דרייברים, ולאחר מכן עובר למצב כרטיס רשת.

מבחינה ארכיטקטונית, מנקודת מבטו של משתמש לינוקס, אחרי כל ההגדרות, זה נראה כך: לאחר חיבור המודם, יש לי ממשק רשת eth*, אשר באמצעות dhcp מקבל את כתובת ה-IP 192.168.8.100, ואת שער ברירת המחדל. הוא 192.168.8.1.

והרגע הכי חשוב! מודל מודם זה אינו יכול לעבוד במצב מודם, אשר נשלט על ידי פקודות AT. הכל יהיה הרבה יותר פשוט, תיצור חיבורי PPP עבור כל מודם ואז תפעל איתם. אבל במקרה שלי, "עצמו" (ליתר דיוק, צולל לינוקס לפי חוקי udev), יוצר ממשק eth ומקצה לו כתובת IP דרך dhcp.

כדי למנוע בלבול נוסף, אני מציע לשכוח את המילה "מודם" ולומר כרטיס רשת ושער, כי בעצם, זה כמו לחבר כרטיס רשת חדש עם שער.
כאשר יש מודם אחד, זה לא גורם לבעיות מיוחדות, אבל כאשר יש יותר מאחד, כלומר n-pieces, מתעוררת תמונת הרשת הבאה.

כלומר, 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, וזה אומר שהכל בסדר.

ב-python ניסיתי אפשרויות רבות לעבודה עם הדמון הזה, אבל הסתפקתי בזו שעבדה נכון עם python 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

חיבור ה-LED היה פשוט וקשה בו זמנית. הקושי העיקרי הוא שמספר ה-PIN במערכת אינו מתאים למספר ה-Pin על הלוח ובגלל שהתיעוד נכתב ביד שמאל. כדי להשוות את מספר סיכת החומרה ומספר הסיכה במערכת ההפעלה, עליך להפעיל את הפקודה:

gpio readall

תוצג טבלה של התכתבויות סיכות במערכת ובלוח. לאחר מכן אני כבר יכול להפעיל את הפין במערכת ההפעלה עצמה. במקרה שלי ה-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 זה (דוגמאות פשוטות) ניתן למצוא ב סעיף רלוונטי.

אני מתקין את ספריית python עם הפקודה הבאה.

sudo -H pip3 install speedtest-cli

לדוגמה, אתה יכול אפילו להתקין בודק מהירות באובונטו ישירות מהתוכנה. זוהי אותה אפליקציית python, אשר לאחר מכן ניתן להפעיל ישירות מהמסוף.

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

גם כאן התברר שהכל לא כל כך פשוט, למרות שזה היה נראה הרבה יותר פשוט. בתחילה, פרמטר השרתים היה שווה ל [], הם אומרים, בחר את השרת הטוב ביותר. כתוצאה מכך, היו לי שרתים אקראיים, וכפי שאתה יכול לנחש, מהירות משתנה. זהו נושא מורכב למדי, שימוש בשרת קבוע, אם כן, סטטי או דינמי, דורש מחקר. אבל הנה דוגמה לגרפים של מדידת מהירות של מפעילי Beeline בעת בחירה דינמית של שרת בדיקה ושרת קבוע סטטי.

התוצאה של מדידת מהירות בבחירת שרת דינמי.

התוצאה של בדיקת מהירות, עם שרת אחד שנבחר בקפדנות.

במהלך הבדיקה יש "פרווה" בשני המקומות, ויש להסיר אותה בשיטות מתמטיות. אבל עם שרת קבוע זה מעט פחות והמשרעת יציבה יותר.
באופן כללי, זה מקום של מחקר גדול. והייתי מודד את המהירות של השרת שלי באמצעות כלי השירות iperf. אבל אנחנו נצמדים למפרט הטכני.

שליחת דואר ושגיאות

כדי לשלוח דואר, ניסיתי כמה עשרות אפשרויות שונות, אבל בסופו של דבר התפשרתי על הדברים הבאים. רשמתי תיבת דואר ב-Yandex ואז לקחתי זוהי דוגמה לשליחת דואר. בדקתי את זה ויישמתי את זה בתוכנית. דוגמה זו בוחנת אפשרויות שונות, כולל שליחה מ-gmail וכו'. לא רציתי להתעסק בהגדרת שרת הדואר שלי ולא היה לי זמן לזה, אבל כפי שהתברר מאוחר יותר, זה גם היה לשווא.

היומנים נשלחו לפי המתזמן, אם יש קשר, כל 6 שעות: בשעה 00:06, 12:18, XNUMX:XNUMX ו-XNUMX:XNUMX. שלח אותו כדלקמן.

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

מתזמן הוא די פשוט: הוא מסתכל לראות אם הגיע הזמן לשלוח הודעות ומה מצב השגיאה הנוכחי. אם יש דגל שגיאה, אנו מהבהבים את הנורית.

#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