🥇ಹಲವಾರು LTE ಮೋಡೆಮ್‌ಗಳಲ್ಲಿ ಏಕಕಾಲಿಕ ವೇಗ ಪರೀಕ್ಷೆ

ಕ್ವಾರಂಟೈನ್ ಸಮಯದಲ್ಲಿ, ಹಲವಾರು ಸೆಲ್ಯುಲಾರ್ ಆಪರೇಟರ್‌ಗಳಿಗೆ LTE ಮೋಡೆಮ್‌ಗಳ ವೇಗವನ್ನು ಅಳೆಯುವ ಸಾಧನದ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಭಾಗವಹಿಸಲು ನನಗೆ ಅವಕಾಶ ನೀಡಲಾಯಿತು.

ಗ್ರಾಹಕರು ವಿವಿಧ ಭೌಗೋಳಿಕ ಸ್ಥಳಗಳಲ್ಲಿ ವಿವಿಧ ಟೆಲಿಕಾಂ ಆಪರೇಟರ್‌ಗಳ ವೇಗವನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಬಯಸುತ್ತಾರೆ, ಇದು LTE ಸಂಪರ್ಕವನ್ನು ಬಳಸಿಕೊಂಡು ಉಪಕರಣಗಳನ್ನು ಸ್ಥಾಪಿಸುವಾಗ ಯಾವ ಸೆಲ್ಯುಲಾರ್ ಆಪರೇಟರ್ ಅವರಿಗೆ ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ, ಉದಾಹರಣೆಗೆ, ವೀಡಿಯೊ ಪ್ರಸಾರಕ್ಕಾಗಿ. ಅದೇ ಸಮಯದಲ್ಲಿ, ದುಬಾರಿ ಉಪಕರಣಗಳಿಲ್ಲದೆ ಸಮಸ್ಯೆಯನ್ನು ಸರಳವಾಗಿ ಮತ್ತು ಅಗ್ಗವಾಗಿ ಸಾಧ್ಯವಾದಷ್ಟು ಪರಿಹರಿಸಬೇಕಾಗಿತ್ತು.

ಕಾರ್ಯವು ಸರಳ ಮತ್ತು ಹೆಚ್ಚು ಜ್ಞಾನ-ತೀವ್ರವಲ್ಲ ಎಂದು ನಾನು ಈಗಿನಿಂದಲೇ ಹೇಳುತ್ತೇನೆ; ನಾನು ಯಾವ ಸಮಸ್ಯೆಗಳನ್ನು ಎದುರಿಸಿದೆ ಮತ್ತು ನಾನು ಅವುಗಳನ್ನು ಹೇಗೆ ಪರಿಹರಿಸಿದೆ ಎಂದು ನಾನು ನಿಮಗೆ ಹೇಳುತ್ತೇನೆ. ಆದ್ದರಿಂದ, ಹೋಗೋಣ.

ಹೇಳಿಕೆಯನ್ನು

LTE ಸಂಪರ್ಕದ ವೇಗವನ್ನು ಅಳೆಯುವುದು ಬಹಳ ಸಂಕೀರ್ಣವಾದ ವಿಷಯವಾಗಿದೆ: ನೀವು ಸರಿಯಾದ ಸಾಧನ ಮತ್ತು ಮಾಪನ ತಂತ್ರವನ್ನು ಆರಿಸಬೇಕಾಗುತ್ತದೆ, ಮತ್ತು ಸೆಲ್ಯುಲಾರ್ ನೆಟ್ವರ್ಕ್ನ ಟೋಪೋಲಜಿ ಮತ್ತು ಕಾರ್ಯಾಚರಣೆಯ ಬಗ್ಗೆ ಉತ್ತಮ ತಿಳುವಳಿಕೆಯನ್ನು ಹೊಂದಿರಬೇಕು. ಜೊತೆಗೆ, ವೇಗವು ಹಲವಾರು ಅಂಶಗಳಿಂದ ಪ್ರಭಾವಿತವಾಗಿರುತ್ತದೆ: ಸೆಲ್‌ನಲ್ಲಿರುವ ಚಂದಾದಾರರ ಸಂಖ್ಯೆ, ಹವಾಮಾನ ಪರಿಸ್ಥಿತಿಗಳು, ಕೋಶದಿಂದ ಕೋಶಕ್ಕೆ ಸಹ ವೇಗವು ನೆಟ್‌ವರ್ಕ್ ಟೋಪೋಲಜಿಯಿಂದಾಗಿ ನಾಟಕೀಯವಾಗಿ ಬದಲಾಗಬಹುದು. ಸಾಮಾನ್ಯವಾಗಿ, ಇದು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಅಪರಿಚಿತರೊಂದಿಗಿನ ಸಮಸ್ಯೆಯಾಗಿದೆ ಮತ್ತು ಟೆಲಿಕಾಂ ಆಪರೇಟರ್ ಮಾತ್ರ ಅದನ್ನು ಸರಿಯಾಗಿ ಪರಿಹರಿಸಬಹುದು.

ಆರಂಭದಲ್ಲಿ, ಗ್ರಾಹಕರು ಆಪರೇಟರ್‌ಗಳ ಫೋನ್‌ಗಳೊಂದಿಗೆ ಕೊರಿಯರ್ ಅನ್ನು ಓಡಿಸಲು ಬಯಸಿದ್ದರು, ಫೋನ್‌ನಲ್ಲಿ ನೇರವಾಗಿ ಅಳತೆಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ ಮತ್ತು ನಂತರ ನೋಟ್‌ಬುಕ್‌ನಲ್ಲಿ ವೇಗ ಮಾಪನ ಫಲಿತಾಂಶಗಳನ್ನು ಬರೆಯಿರಿ. ಎಲ್ ಟಿಇ ನೆಟ್‌ವರ್ಕ್‌ಗಳ ವೇಗವನ್ನು ಅಳೆಯಲು ನನ್ನ ಪರಿಹಾರವು ಸೂಕ್ತವಲ್ಲದಿದ್ದರೂ, ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತದೆ.

ಸಮಯದ ಕೊರತೆಯಿಂದಾಗಿ, ನಾನು ಅನುಕೂಲಕ್ಕಾಗಿ ಅಥವಾ ಪ್ರಾಯೋಗಿಕತೆಯ ಪರವಾಗಿ ಅಲ್ಲ, ಆದರೆ ಅಭಿವೃದ್ಧಿಯ ವೇಗದ ಪರವಾಗಿ ನಿರ್ಧಾರಗಳನ್ನು ಮಾಡಿದ್ದೇನೆ. ಉದಾಹರಣೆಗೆ, ಸರ್ವರ್ ಮತ್ತು ಪ್ರತಿ ಕ್ಲೈಂಟ್ ಅನ್ನು ಹೊಂದಿಸಲು ಸಮಯವನ್ನು ಉಳಿಸಲು ಹೆಚ್ಚು ಪ್ರಾಯೋಗಿಕ VPN ಬದಲಿಗೆ ರಿಮೋಟ್ ಪ್ರವೇಶಕ್ಕಾಗಿ ರಿವರ್ಸ್ ssh ಅನ್ನು ಬಳಸಲಾಗಿದೆ.

ತಾಂತ್ರಿಕ ಕಾರ್ಯ

ಲೇಖನದಲ್ಲಿ ಹೇಳಿದಂತೆ ತಾಂತ್ರಿಕ ವಿಶೇಷಣಗಳಿಲ್ಲದೆ: ಕ್ಲೈಂಟ್ ಏಕೆ ಬಯಸುವುದಿಲ್ಲ: ತಾಂತ್ರಿಕ ವಿಶೇಷಣಗಳಿಲ್ಲದೆ ಕೆಲಸ ಮಾಡಬೇಡಿ! ಎಂದಿಗೂ, ಎಲ್ಲಿಯೂ!

ತಾಂತ್ರಿಕ ಕಾರ್ಯವು ತುಂಬಾ ಸರಳವಾಗಿದೆ, ಅಂತಿಮ ಬಳಕೆದಾರರ ತಿಳುವಳಿಕೆಗಾಗಿ ನಾನು ಅದನ್ನು ಸ್ವಲ್ಪ ವಿಸ್ತರಿಸುತ್ತೇನೆ. ತಾಂತ್ರಿಕ ಪರಿಹಾರಗಳು ಮತ್ತು ಸಲಕರಣೆಗಳ ಆಯ್ಕೆಯನ್ನು ಗ್ರಾಹಕರು ನಿರ್ದೇಶಿಸುತ್ತಾರೆ. ಆದ್ದರಿಂದ, ಎಲ್ಲಾ ಅನುಮೋದನೆಗಳ ನಂತರ ತಾಂತ್ರಿಕ ವಿವರಣೆಯು ಸ್ವತಃ:

ಒಂದೇ ಬೋರ್ಡ್ ಕಂಪ್ಯೂಟರ್ ಅನ್ನು ಆಧರಿಸಿದೆ ವಿಮ್2 H ಮೋಡೆಮ್‌ಗಳ ಮೂಲಕ lte ಸಂಪರ್ಕಗಳಿಗಾಗಿ ವೇಗ ಪರೀಕ್ಷಕವನ್ನು ಮಾಡಿuawei e3372h - 153 ಹಲವಾರು ಟೆಲಿಕಾಂ ಆಪರೇಟರ್‌ಗಳು (ಒಂದರಿಂದ n ವರೆಗೆ). UART ಮೂಲಕ ಸಂಪರ್ಕಗೊಂಡಿರುವ GPS ರಿಸೀವರ್‌ನಿಂದ ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಸ್ವೀಕರಿಸುವುದು ಸಹ ಅಗತ್ಯವಾಗಿದೆ. ಸೇವೆಯನ್ನು ಬಳಸಿಕೊಂಡು ವೇಗ ಮಾಪನಗಳನ್ನು ಮಾಡಿ www.speedtest.net ಮತ್ತು ಅವುಗಳನ್ನು ಮೇಜಿನ ಮೇಲೆ ಇರಿಸಿ:

csv ಸ್ವರೂಪದಲ್ಲಿ ಟೇಬಲ್. ನಂತರ ಪ್ರತಿ 6 ಗಂಟೆಗಳಿಗೊಮ್ಮೆ ಇಮೇಲ್ ಮೂಲಕ ಈ ಚಿಹ್ನೆಯನ್ನು ಕಳುಹಿಸಿ. ದೋಷಗಳ ಸಂದರ್ಭದಲ್ಲಿ, GPIO ಗೆ ಸಂಪರ್ಕಗೊಂಡಿರುವ LED ಅನ್ನು ಬ್ಲಿಂಕ್ ಮಾಡಿ.

ಅನೇಕ ಅನುಮೋದನೆಗಳ ನಂತರ ನಾನು ತಾಂತ್ರಿಕ ವಿಶೇಷಣಗಳನ್ನು ಉಚಿತ ರೂಪದಲ್ಲಿ ವಿವರಿಸಿದೆ. ಆದರೆ ಕಾರ್ಯದ ಅರ್ಥವು ಈಗಾಗಲೇ ಗೋಚರಿಸುತ್ತದೆ. ಎಲ್ಲದಕ್ಕೂ ಒಂದು ವಾರ ಕಾಲಾವಕಾಶ ನೀಡಲಾಯಿತು. ಆದರೆ ವಾಸ್ತವದಲ್ಲಿ ಇದು ಮೂರು ವಾರಗಳ ಕಾಲ ನಡೆಯಿತು. ನನ್ನ ಮುಖ್ಯ ಕೆಲಸದ ನಂತರ ಮತ್ತು ವಾರಾಂತ್ಯದಲ್ಲಿ ಮಾತ್ರ ನಾನು ಇದನ್ನು ಮಾಡಿದ್ದೇನೆ ಎಂಬ ಅಂಶವನ್ನು ಇದು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತಿದೆ.

ವೇಗ ಮಾಪನ ಸೇವೆ ಮತ್ತು ಯಂತ್ರಾಂಶದ ಬಳಕೆಯನ್ನು ಗ್ರಾಹಕರು ಮುಂಚಿತವಾಗಿ ಒಪ್ಪಿಕೊಂಡಿದ್ದಾರೆ ಎಂಬ ಅಂಶವನ್ನು ಇಲ್ಲಿ ಮತ್ತೊಮ್ಮೆ ಗಮನ ಸೆಳೆಯಲು ನಾನು ಬಯಸುತ್ತೇನೆ, ಅದು ನನ್ನ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಹೆಚ್ಚು ಸೀಮಿತಗೊಳಿಸಿತು. ಬಜೆಟ್ ಕೂಡ ಸೀಮಿತವಾಗಿತ್ತು, ಆದ್ದರಿಂದ ವಿಶೇಷವಾದ ಏನನ್ನೂ ಖರೀದಿಸಲಾಗಿಲ್ಲ. ಆದ್ದರಿಂದ ನಾವು ಈ ನಿಯಮಗಳ ಪ್ರಕಾರ ಆಡಬೇಕಾಗಿತ್ತು.

ವಾಸ್ತುಶಿಲ್ಪ ಮತ್ತು ಅಭಿವೃದ್ಧಿ

ಯೋಜನೆಯು ಸರಳ ಮತ್ತು ಸ್ಪಷ್ಟವಾಗಿದೆ. ಆದ್ದರಿಂದ, ನಾನು ಯಾವುದೇ ವಿಶೇಷ ಕಾಮೆಂಟ್ಗಳಿಲ್ಲದೆ ಬಿಡುತ್ತೇನೆ.

ಈ ಭಾಷೆಯಲ್ಲಿ ಯಾವುದೇ ಅಭಿವೃದ್ಧಿಯ ಅನುಭವವಿಲ್ಲದಿದ್ದರೂ ನಾನು ಸಂಪೂರ್ಣ ಯೋಜನೆಯನ್ನು ಪೈಥಾನ್‌ನಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಿರ್ಧರಿಸಿದೆ. ಅಭಿವೃದ್ಧಿಯನ್ನು ವೇಗಗೊಳಿಸಲು ಸಿದ್ಧವಾದ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಪರಿಹಾರಗಳ ಗುಂಪೇ ಇರುವುದರಿಂದ ನಾನು ಅದನ್ನು ಆರಿಸಿದೆ. ಆದ್ದರಿಂದ, ಪೈಥಾನ್‌ನಲ್ಲಿ ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ನನ್ನ ಮೊದಲ ಅನುಭವವನ್ನು ನಿಂದಿಸಬೇಡಿ ಎಂದು ನಾನು ಎಲ್ಲಾ ವೃತ್ತಿಪರ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳನ್ನು ಕೇಳುತ್ತೇನೆ ಮತ್ತು ನನ್ನ ಕೌಶಲ್ಯಗಳನ್ನು ಸುಧಾರಿಸಲು ರಚನಾತ್ಮಕ ಟೀಕೆಗಳನ್ನು ಕೇಳಲು ನಾನು ಯಾವಾಗಲೂ ಸಂತೋಷಪಡುತ್ತೇನೆ.

ಈ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಪೈಥಾನ್ ಎರಡು ಚಾಲನೆಯಲ್ಲಿರುವ ಆವೃತ್ತಿಗಳು 2 ಮತ್ತು 3 ಅನ್ನು ಹೊಂದಿದೆ ಎಂದು ನಾನು ಕಂಡುಹಿಡಿದಿದ್ದೇನೆ, ಇದರ ಪರಿಣಾಮವಾಗಿ ನಾನು ಮೂರನೆಯದರಲ್ಲಿ ನೆಲೆಸಿದೆ.

ಹಾರ್ಡ್ವೇರ್ ನೋಡ್ಗಳು

ಏಕ-ಫಲಕ ವಿಮ್2

ನನ್ನ ಮುಖ್ಯ ಯಂತ್ರವಾಗಿ ನನಗೆ ಸಿಂಗಲ್ ಬೋರ್ಡ್ ಕಂಪ್ಯೂಟರ್ ನೀಡಲಾಗಿದೆ ವಿಮ್2

ಸ್ಮಾರ್ಟ್ ಹೋಮ್ ಮತ್ತು SMART-TV ಗಾಗಿ ಅತ್ಯುತ್ತಮವಾದ, ಶಕ್ತಿಯುತವಾದ ಮಾಧ್ಯಮ ಪ್ರೊಸೆಸರ್, ಆದರೆ ಈ ಕಾರ್ಯಕ್ಕೆ ಅತ್ಯಂತ ಸೂಕ್ತವಲ್ಲ, ಅಥವಾ, ಸರಿಯಾಗಿ ಸೂಕ್ತವಲ್ಲ ಎಂದು ಹೇಳೋಣ. ಉದಾಹರಣೆಗೆ, ಅದರ ಮುಖ್ಯ ಓಎಸ್ ಆಂಡ್ರಾಯ್ಡ್ ಆಗಿದೆ, ಮತ್ತು ಲಿನಕ್ಸ್ ದ್ವಿತೀಯ ಓಎಸ್ ಆಗಿದೆ, ಮತ್ತು ಅದರ ಪ್ರಕಾರ ಲಿನಕ್ಸ್ ಅಡಿಯಲ್ಲಿ ಎಲ್ಲಾ ನೋಡ್ಗಳು ಮತ್ತು ಡ್ರೈವರ್ಗಳ ಉತ್ತಮ-ಗುಣಮಟ್ಟದ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಯಾರೂ ಖಾತರಿಪಡಿಸುವುದಿಲ್ಲ. ಮತ್ತು ಕೆಲವು ಸಮಸ್ಯೆಗಳು ಈ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನ ಯುಎಸ್‌ಬಿ ಡ್ರೈವರ್‌ಗಳಿಗೆ ಸಂಬಂಧಿಸಿವೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ, ಆದ್ದರಿಂದ ಮೋಡೆಮ್‌ಗಳು ಈ ಬೋರ್ಡ್‌ನಲ್ಲಿ ನಿರೀಕ್ಷೆಯಂತೆ ಕೆಲಸ ಮಾಡಲಿಲ್ಲ. ಇದು ತುಂಬಾ ಕಳಪೆ ಮತ್ತು ಚದುರಿದ ದಾಖಲಾತಿಯನ್ನು ಹೊಂದಿದೆ, ಆದ್ದರಿಂದ ಪ್ರತಿ ಕಾರ್ಯಾಚರಣೆಯು ಹಡಗುಕಟ್ಟೆಗಳ ಮೂಲಕ ಅಗೆಯಲು ಸಾಕಷ್ಟು ಸಮಯವನ್ನು ತೆಗೆದುಕೊಂಡಿತು. GPIO ಯೊಂದಿಗಿನ ಸಾಮಾನ್ಯ ಕೆಲಸವೂ ಸಹ ಬಹಳಷ್ಟು ರಕ್ತವನ್ನು ತೆಗೆದುಕೊಂಡಿತು. ಉದಾಹರಣೆಗೆ, ಎಲ್ಇಡಿ ಹೊಂದಿಸಲು ನನಗೆ ಹಲವಾರು ಗಂಟೆಗಳು ಬೇಕಾಯಿತು. ಆದರೆ, ವಸ್ತುನಿಷ್ಠವಾಗಿರಲು, ಅದು ಯಾವ ರೀತಿಯ ಏಕ-ಬೋರ್ಡ್ ಎಂಬುದು ಮೂಲಭೂತವಾಗಿ ಮುಖ್ಯವಲ್ಲ, ಮುಖ್ಯ ವಿಷಯವೆಂದರೆ ಅದು ಕೆಲಸ ಮಾಡಿದೆ ಮತ್ತು ಯುಎಸ್ಬಿ ಪೋರ್ಟ್ಗಳು ಇದ್ದವು.

ಮೊದಲಿಗೆ, ನಾನು ಈ ಬೋರ್ಡ್‌ನಲ್ಲಿ ಲಿನಕ್ಸ್ ಅನ್ನು ಸ್ಥಾಪಿಸಬೇಕಾಗಿದೆ. ಎಲ್ಲರಿಗೂ ದಾಖಲೀಕರಣದ ಕಾಡುಗಳನ್ನು ಹುಡುಕದಿರಲು ಮತ್ತು ಈ ಏಕ-ಬೋರ್ಡ್ ವ್ಯವಸ್ಥೆಯನ್ನು ನಿಭಾಯಿಸುವವರಿಗೆ, ನಾನು ಈ ಅಧ್ಯಾಯವನ್ನು ಬರೆಯುತ್ತಿದ್ದೇನೆ.

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.

ಈ ಫರ್ಮ್‌ವೇರ್ ಅನ್ನು ಅಪ್‌ಲೋಡ್ ಮಾಡಲು, ನನಗೆ ಉಪಯುಕ್ತತೆಗಳ ಅಗತ್ಯವಿದೆ. ಇದರ ಬಗ್ಗೆ ಹೆಚ್ಚಿನ ವಿವರಗಳು ಇಲ್ಲಿ. ನಾನು ವಿಂಡೋಸ್ ಅಡಿಯಲ್ಲಿ ಮಿನುಗಲು ಪ್ರಯತ್ನಿಸಲಿಲ್ಲ, ಆದರೆ ಲಿನಕ್ಸ್ ಅಡಿಯಲ್ಲಿ ಫರ್ಮ್ವೇರ್ ಬಗ್ಗೆ ನಾನು ನಿಮಗೆ ಕೆಲವು ಪದಗಳನ್ನು ಹೇಳಬೇಕಾಗಿದೆ. ಮೊದಲಿಗೆ, ಸೂಚನೆಗಳ ಪ್ರಕಾರ ನಾನು ಉಪಯುಕ್ತತೆಗಳನ್ನು ಸ್ಥಾಪಿಸುತ್ತೇನೆ.

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

Aaand... ಏನೂ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ. ನಾನು ಅನುಸ್ಥಾಪನಾ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಸಂಪಾದಿಸಲು ಒಂದೆರಡು ಗಂಟೆಗಳ ಕಾಲ ಕಳೆದಿದ್ದೇನೆ ಇದರಿಂದ ಎಲ್ಲವೂ ನನಗೆ ಸರಿಯಾಗಿ ಸ್ಥಾಪಿಸಲ್ಪಡುತ್ತದೆ. ನಾನು ಅಲ್ಲಿ ಏನು ಮಾಡಿದೆ ಎಂದು ನನಗೆ ನೆನಪಿಲ್ಲ, ಆದರೆ ಕುದುರೆಗಳೊಂದಿಗೆ ಸರ್ಕಸ್ ಕೂಡ ಇತ್ತು. ಆದ್ದರಿಂದ ಎಚ್ಚರಿಕೆಯಿಂದಿರಿ. ಆದರೆ ಈ ಉಪಯುಕ್ತತೆಗಳಿಲ್ಲದೆ 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

ಅಷ್ಟೇ, ಛೆ. ನಾನು ಪರಿಶೀಲಿಸಿದೆ, ಬೋರ್ಡ್‌ನಲ್ಲಿ ಲಿನಕ್ಸ್ ಇದೆ. ಲಾಗಿನ್/ಪಾಸ್‌ವರ್ಡ್ ಖಡಾಸ್:ಖಾದಾಸ್.

ಅದರ ನಂತರ, ಕೆಲವು ಸಣ್ಣ ಆರಂಭಿಕ ಸೆಟ್ಟಿಂಗ್ಗಳು. ಹೆಚ್ಚಿನ ಕೆಲಸಕ್ಕಾಗಿ, ನಾನು ಸುಡೋಗಾಗಿ ಪಾಸ್ವರ್ಡ್ ಅನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುತ್ತೇನೆ (ಹೌದು, ಸುರಕ್ಷಿತವಲ್ಲ, ಆದರೆ ಅನುಕೂಲಕರವಾಗಿದೆ).

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 ಎಂದು ನಟಿಸುತ್ತದೆ, ತದನಂತರ ನೆಟ್ವರ್ಕ್ ಕಾರ್ಡ್ ಮೋಡ್ಗೆ ಬದಲಾಯಿಸುತ್ತದೆ.

ವಾಸ್ತುಶಿಲ್ಪೀಯವಾಗಿ, ಲಿನಕ್ಸ್ ಬಳಕೆದಾರರ ದೃಷ್ಟಿಕೋನದಿಂದ, ಎಲ್ಲಾ ಸೆಟ್ಟಿಂಗ್‌ಗಳ ನಂತರ, ಇದು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ: ಮೋಡೆಮ್ ಅನ್ನು ಸಂಪರ್ಕಿಸಿದ ನಂತರ, ನಾನು eth* ನೆಟ್ವರ್ಕ್ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಹೊಂದಿದ್ದೇನೆ, ಇದು dhcp ಮೂಲಕ IP ವಿಳಾಸ 192.168.8.100 ಮತ್ತು ಡೀಫಾಲ್ಟ್ ಗೇಟ್ವೇ ಅನ್ನು ಪಡೆಯುತ್ತದೆ. 192.168.8.1 ಆಗಿದೆ.

ಮತ್ತು ಪ್ರಮುಖ ಕ್ಷಣ! ಈ ಮೋಡೆಮ್ ಮಾದರಿಯು ಮೋಡೆಮ್ ಮೋಡ್‌ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ, ಇದನ್ನು AT ಆಜ್ಞೆಗಳಿಂದ ನಿಯಂತ್ರಿಸಲಾಗುತ್ತದೆ. ಎಲ್ಲವೂ ಹೆಚ್ಚು ಸರಳವಾಗಿರುತ್ತದೆ, ಪ್ರತಿ ಮೋಡೆಮ್‌ಗೆ PPP ಸಂಪರ್ಕಗಳನ್ನು ರಚಿಸಿ ಮತ್ತು ನಂತರ ಅವರೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸಿ. ಆದರೆ ನನ್ನ ವಿಷಯದಲ್ಲಿ, "ಸ್ವತಃ" (ಹೆಚ್ಚು ನಿಖರವಾಗಿ, udev ನಿಯಮಗಳ ಪ್ರಕಾರ ಲಿನಕ್ಸ್ ಡೈವರ್), ಎಥ್ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು dhcp ಮೂಲಕ ಅದಕ್ಕೆ IP ವಿಳಾಸವನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ.

ಮತ್ತಷ್ಟು ಗೊಂದಲವನ್ನು ತಪ್ಪಿಸಲು, "ಮೋಡೆಮ್" ಎಂಬ ಪದವನ್ನು ಮರೆತು ನೆಟ್ವರ್ಕ್ ಕಾರ್ಡ್ ಮತ್ತು ಗೇಟ್ವೇ ಎಂದು ಹೇಳಲು ನಾನು ಸಲಹೆ ನೀಡುತ್ತೇನೆ, ಏಕೆಂದರೆ ಮೂಲಭೂತವಾಗಿ, ಇದು ಗೇಟ್ವೇನೊಂದಿಗೆ ಹೊಸ ನೆಟ್ವರ್ಕ್ ಕಾರ್ಡ್ ಅನ್ನು ಸಂಪರ್ಕಿಸುವಂತಿದೆ.
ಒಂದು ಮೋಡೆಮ್ ಇದ್ದಾಗ, ಇದು ಯಾವುದೇ ವಿಶೇಷ ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡುವುದಿಲ್ಲ, ಆದರೆ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಇದ್ದಾಗ, ಅವುಗಳೆಂದರೆ n- ತುಣುಕುಗಳು, ಕೆಳಗಿನ ನೆಟ್ವರ್ಕ್ ಚಿತ್ರವು ಉದ್ಭವಿಸುತ್ತದೆ.

ಅಂದರೆ, n ನೆಟ್‌ವರ್ಕ್ ಕಾರ್ಡ್‌ಗಳು, ಒಂದೇ IP ವಿಳಾಸದೊಂದಿಗೆ, ಪ್ರತಿಯೊಂದೂ ಒಂದೇ ಡೀಫಾಲ್ಟ್ ಗೇಟ್‌ವೇಯೊಂದಿಗೆ. ಆದರೆ ವಾಸ್ತವವಾಗಿ, ಅವುಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದೂ ತನ್ನದೇ ಆದ ಆಪರೇಟರ್ಗೆ ಸಂಪರ್ಕ ಹೊಂದಿದೆ.

ಆರಂಭದಲ್ಲಿ, ನಾನು ಸರಳ ಪರಿಹಾರವನ್ನು ಹೊಂದಿದ್ದೇನೆ: ifconfig ಅಥವಾ ip ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ, ಎಲ್ಲಾ ಇಂಟರ್ಫೇಸ್ಗಳನ್ನು ಆಫ್ ಮಾಡಿ ಮತ್ತು ಪ್ರತಿಯಾಗಿ ಒಂದನ್ನು ಆನ್ ಮಾಡಿ ಮತ್ತು ಅದನ್ನು ಪರೀಕ್ಷಿಸಿ. ಪರಿಹಾರವು ಎಲ್ಲರಿಗೂ ಒಳ್ಳೆಯದು, ಸ್ವಿಚಿಂಗ್ ಕ್ಷಣಗಳಲ್ಲಿ ನಾನು ಸಾಧನಕ್ಕೆ ಸಂಪರ್ಕಿಸಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ. ಮತ್ತು ಸ್ವಿಚಿಂಗ್ ಆಗಾಗ ಮತ್ತು ವೇಗವಾಗಿರುವುದರಿಂದ, ವಾಸ್ತವವಾಗಿ ಸಂಪರ್ಕಿಸಲು ನನಗೆ ಯಾವುದೇ ಅವಕಾಶವಿರಲಿಲ್ಲ.

ಆದ್ದರಿಂದ, ನಾನು ಮೋಡೆಮ್‌ಗಳ IP ವಿಳಾಸಗಳನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಬದಲಾಯಿಸುವ ಮಾರ್ಗವನ್ನು ಆರಿಸಿದೆ ಮತ್ತು ನಂತರ ರೂಟಿಂಗ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸಂಚಾರವನ್ನು ಚಾಲನೆ ಮಾಡುತ್ತೇನೆ.

ಇದು ಮೋಡೆಮ್‌ಗಳೊಂದಿಗಿನ ನನ್ನ ಸಮಸ್ಯೆಗಳ ಅಂತ್ಯವಾಗಿರಲಿಲ್ಲ: ವಿದ್ಯುತ್ ಸಮಸ್ಯೆಗಳ ಸಂದರ್ಭದಲ್ಲಿ, ಅವು ಬಿದ್ದುಹೋದವು ಮತ್ತು ಯುಎಸ್‌ಬಿ ಹಬ್‌ಗೆ ಉತ್ತಮ ಸ್ಥಿರವಾದ ವಿದ್ಯುತ್ ಸರಬರಾಜು ಅಗತ್ಯವಿದೆ. ವಿದ್ಯುತ್ ಅನ್ನು ನೇರವಾಗಿ ಹಬ್‌ಗೆ ಬೆಸುಗೆ ಹಾಕುವ ಮೂಲಕ ನಾನು ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಿದೆ. ನಾನು ಎದುರಿಸಿದ ಮತ್ತು ಸಂಪೂರ್ಣ ಯೋಜನೆಯನ್ನು ಹಾಳುಮಾಡಿರುವ ಮತ್ತೊಂದು ಸಮಸ್ಯೆ: ಸಾಧನದ ರೀಬೂಟ್ ಅಥವಾ ಶೀತ ಪ್ರಾರಂಭದ ನಂತರ, ಎಲ್ಲಾ ಮೋಡೆಮ್‌ಗಳು ಪತ್ತೆಯಾಗಿಲ್ಲ ಮತ್ತು ಯಾವಾಗಲೂ ಅಲ್ಲ, ಮತ್ತು ಇದು ಏಕೆ ಸಂಭವಿಸಿತು ಮತ್ತು ಯಾವ ಅಲ್ಗಾರಿದಮ್ ಮೂಲಕ ನಾನು ನಿರ್ಧರಿಸಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ. ಆದರೆ ಮೊದಲ ವಿಷಯಗಳು ಮೊದಲು.

ಮೋಡೆಮ್ ಸರಿಯಾಗಿ ಕೆಲಸ ಮಾಡಲು, ನಾನು usb-modeswitch ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿದೆ.

sudo apt update
sudo apt install -y usb-modeswitch

ಅದರ ನಂತರ, ಸಂಪರ್ಕಿಸಿದ ನಂತರ, ಮೋಡೆಮ್ ಅನ್ನು ಸರಿಯಾಗಿ ಪತ್ತೆಹಚ್ಚಲಾಗುತ್ತದೆ ಮತ್ತು udev ಉಪವ್ಯವಸ್ಥೆಯಿಂದ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗುತ್ತದೆ. ಮೋಡೆಮ್ ಅನ್ನು ಸರಳವಾಗಿ ಸಂಪರ್ಕಿಸುವ ಮೂಲಕ ಮತ್ತು ನೆಟ್‌ವರ್ಕ್ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ ನಾನು ಪರಿಶೀಲಿಸುತ್ತೇನೆ.
ನಾನು ಪರಿಹರಿಸಲಾಗದ ಇನ್ನೊಂದು ಸಮಸ್ಯೆ: ಈ ಮೋಡೆಮ್‌ನಿಂದ ನಾವು ಕೆಲಸ ಮಾಡುತ್ತಿರುವ ಆಪರೇಟರ್‌ನ ಹೆಸರನ್ನು ನಾನು ಹೇಗೆ ಪಡೆಯಬಹುದು? ಆಪರೇಟರ್ ಹೆಸರು ಮೋಡೆಮ್ ವೆಬ್ ಇಂಟರ್ಫೇಸ್ನಲ್ಲಿ 192.168.8.1 ನಲ್ಲಿದೆ. ಇದು ಅಜಾಕ್ಸ್ ವಿನಂತಿಗಳ ಮೂಲಕ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸುವ ಡೈನಾಮಿಕ್ ವೆಬ್ ಪುಟವಾಗಿದೆ, ಆದ್ದರಿಂದ ಸರಳವಾಗಿ ಪುಟವನ್ನು wgeting ಮತ್ತು ಹೆಸರನ್ನು ಪಾರ್ಸ್ ಮಾಡುವುದು ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ. ಹಾಗಾಗಿ ನಾನು ವೆಬ್ ಪುಟವನ್ನು ಹೇಗೆ ಅಭಿವೃದ್ಧಿಪಡಿಸುವುದು ಇತ್ಯಾದಿಗಳನ್ನು ನೋಡಲಾರಂಭಿಸಿದೆ ಮತ್ತು ನಾನು ಕೆಲವು ರೀತಿಯ ಅಸಂಬದ್ಧತೆಯನ್ನು ಮಾಡುತ್ತಿದ್ದೇನೆ ಎಂದು ಅರಿತುಕೊಂಡೆ. ಪರಿಣಾಮವಾಗಿ, ಅವರು ಉಗುಳಿದರು, ಮತ್ತು ಆಪರೇಟರ್ ಸ್ಪೀಡ್‌ಟೆಸ್ಟ್ 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 ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಸಂಪಾದಿಸುತ್ತದೆ, ಇದು ತುಂಬಾ ಅನುಕೂಲಕರವಾಗಿದೆ.

ಈ ಕಾರ್ಯಾಚರಣೆಯ ಯಶಸ್ಸಿನ ನಂತರ, ರೀಬೂಟ್ ಮಾಡಿ ಮತ್ತು ಜಿಪಿಎಸ್ ಡೀಮನ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ.

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 ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತೇನೆ.

ಈ ಸ್ಕ್ರೀನ್‌ಶಾಟ್‌ನಲ್ಲಿ ನೀವು ಉಪಗ್ರಹಗಳನ್ನು ನೋಡಲಾಗುವುದಿಲ್ಲ, ಆದರೆ ನೀವು 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 ಸೆಕೆಂಡುಗಳಲ್ಲಿ ನಾನು ನಿರ್ದೇಶಾಂಕವನ್ನು ಪಡೆಯುತ್ತೇನೆ ಅಥವಾ ಇಲ್ಲ. ಹೌದು, ನಾನು ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಪಡೆಯಲು ಹತ್ತು ಪ್ರಯತ್ನಗಳನ್ನು ಹೊಂದಿದ್ದೇನೆ. ಸೂಕ್ತವಲ್ಲ, ವಕ್ರ ಮತ್ತು ಓರೆಯಾಗಿಲ್ಲ, ಆದರೆ ಅದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ನಾನು ಇದನ್ನು ಮಾಡಲು ನಿರ್ಧರಿಸಿದ್ದೇನೆ ಏಕೆಂದರೆ ಜಿಪಿಎಸ್ ಕಳಪೆ ಸ್ವಾಗತವನ್ನು ಹೊಂದಬಹುದು ಮತ್ತು ಯಾವಾಗಲೂ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸುವುದಿಲ್ಲ. ನೀವು ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸಲು ಕಾಯುತ್ತಿದ್ದರೆ, ನಂತರ ನೀವು ದೂರದ ಕೋಣೆಯಲ್ಲಿ ಕೆಲಸ ಮಾಡಿದರೆ, ಪ್ರೋಗ್ರಾಂ ಈ ಸ್ಥಳದಲ್ಲಿ ಫ್ರೀಜ್ ಆಗುತ್ತದೆ. ಆದ್ದರಿಂದ, ನಾನು ಈ ಸೊಗಸಾದ ಆಯ್ಕೆಯನ್ನು ಜಾರಿಗೆ ತಂದಿದ್ದೇನೆ.

ತಾತ್ವಿಕವಾಗಿ, ಹೆಚ್ಚಿನ ಸಮಯವಿದ್ದರೆ, UART ಮೂಲಕ ನೇರವಾಗಿ GPS ನಿಂದ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸಲು ಸಾಧ್ಯವಾಯಿತು, ಅದನ್ನು ಪ್ರತ್ಯೇಕ ಥ್ರೆಡ್ನಲ್ಲಿ ಪಾರ್ಸ್ ಮಾಡಿ ಮತ್ತು ಅದರೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಿ. ಆದರೆ ಸಮಯವಿಲ್ಲ, ಆದ್ದರಿಂದ ಕ್ರೂರವಾಗಿ ಕೊಳಕು ಕೋಡ್. ಮತ್ತು ಹೌದು, ನಾನು ನಾಚಿಕೆಪಡುವುದಿಲ್ಲ.

ಬೆಳಕು ಹೊರಸೂಸುವ ಡಯೋಡ್

ಎಲ್ಇಡಿಯನ್ನು ಸಂಪರ್ಕಿಸುವುದು ಅದೇ ಸಮಯದಲ್ಲಿ ಸರಳ ಮತ್ತು ಕಷ್ಟಕರವಾಗಿತ್ತು. ಮುಖ್ಯ ತೊಂದರೆ ಎಂದರೆ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿನ ಪಿನ್ ಸಂಖ್ಯೆಯು ಬೋರ್ಡ್‌ನಲ್ಲಿರುವ ಪಿನ್ ಸಂಖ್ಯೆಗೆ ಹೊಂದಿಕೆಯಾಗುವುದಿಲ್ಲ ಮತ್ತು ದಾಖಲೆಯನ್ನು ಎಡಗೈಯಿಂದ ಬರೆಯಲಾಗಿದೆ. OS ನಲ್ಲಿ ಹಾರ್ಡ್‌ವೇರ್ ಪಿನ್ ಸಂಖ್ಯೆ ಮತ್ತು ಪಿನ್ ಸಂಖ್ಯೆಯನ್ನು ಹೋಲಿಸಲು, ನೀವು ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಬೇಕು:

gpio readall

ಸಿಸ್ಟಮ್ ಮತ್ತು ಬೋರ್ಡ್‌ನಲ್ಲಿ ಪಿನ್ ಪತ್ರವ್ಯವಹಾರದ ಟೇಬಲ್ ಅನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ. ಅದರ ನಂತರ ನಾನು ಈಗಾಗಲೇ ಪಿನ್ ಅನ್ನು ಓಎಸ್ನಲ್ಲಿಯೇ ನಿರ್ವಹಿಸಬಹುದು. ನನ್ನ ಸಂದರ್ಭದಲ್ಲಿ ಎಲ್ಇಡಿ ಸಂಪರ್ಕಗೊಂಡಿದೆ 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)

ಈಗ, ದೋಷಗಳ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು ದೋಷ_ಬ್ಲಿಂಕ್ () ಎಂದು ಕರೆಯುತ್ತೇನೆ ಮತ್ತು ಎಲ್ಇಡಿ ಸುಂದರವಾಗಿ ಮಿಟುಕಿಸುತ್ತದೆ.

ಸಾಫ್ಟ್ವೇರ್ ನೋಡ್ಗಳು

ಸ್ಪೀಡ್‌ಟೆಸ್ಟ್ 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 ನಲ್ಲಿ ಮೇಲ್ಬಾಕ್ಸ್ ಅನ್ನು ನೋಂದಾಯಿಸಿದೆ ಮತ್ತು ನಂತರ ತೆಗೆದುಕೊಂಡೆ ಇದು ಮೇಲ್ ಕಳುಹಿಸುವ ಉದಾಹರಣೆಯಾಗಿದೆ. ನಾನು ಅದನ್ನು ಪರಿಶೀಲಿಸಿದೆ ಮತ್ತು ಅದನ್ನು ಪ್ರೋಗ್ರಾಂಗೆ ಅಳವಡಿಸಿದೆ. ಈ ಉದಾಹರಣೆಯು ಜಿಮೇಲ್‌ನಿಂದ ಕಳುಹಿಸುವುದು ಸೇರಿದಂತೆ ವಿವಿಧ ಆಯ್ಕೆಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ. ನನ್ನ ಮೇಲ್ ಸರ್ವರ್ ಅನ್ನು ಹೊಂದಿಸುವುದರೊಂದಿಗೆ ನಾನು ತಲೆಕೆಡಿಸಿಕೊಳ್ಳಲು ಬಯಸುವುದಿಲ್ಲ ಮತ್ತು ಅದಕ್ಕೆ ಸಮಯವಿರಲಿಲ್ಲ, ಆದರೆ ಅದು ನಂತರ ಬದಲಾದಂತೆ, ಅದು ಕೂಡ ವ್ಯರ್ಥವಾಯಿತು.

ಶೆಡ್ಯೂಲರ್ ಪ್ರಕಾರ ಲಾಗ್‌ಗಳನ್ನು ಕಳುಹಿಸಲಾಗಿದೆ, ಸಂಪರ್ಕವಿದ್ದರೆ, ಪ್ರತಿ 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. ನೀವು ಸರಳವಾದ ಸರ್ವರ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ, ನನ್ನ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಇದು ಸಾಕು. ಆದರೆ ನಾನು ನನ್ನ ಸ್ವಂತ ಜೇಬಿನಿಂದ ಸರ್ವರ್‌ಗೆ ಪಾವತಿಸದ ಕಾರಣ, ನಾನು ಅದನ್ನು ಸಣ್ಣ ಮೀಸಲುಯೊಂದಿಗೆ ತೆಗೆದುಕೊಳ್ಳಲು ನಿರ್ಧರಿಸಿದೆ, ಆದ್ದರಿಂದ ನಾವು ವೆಬ್ ಇಂಟರ್ಫೇಸ್, ನಮ್ಮದೇ ಆದ 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 ಸರ್ವರ್ ಅನ್ನು ಮರು-ಸಂರಚಿಸುವುದು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಹೇಗಾದರೂ ಯಾರೂ ಓದುವುದಿಲ್ಲವಾದ್ದರಿಂದ, ಮರದ ಹಳಿಗಳ ಮೇಲೆ ರೈಲು ಓಡುವುದಿಲ್ಲ ಎಂದು ತಿಳಿಯಿರಿ. ಈಸ್ಟರ್ ಎಗ್ ಅನ್ನು ಕಂಡುಹಿಡಿದವರು ಸ್ವಲ್ಪ ಕ್ಯಾಂಡಿ ಪಡೆಯುತ್ತಾರೆ.

ಇದನ್ನು ಮಾಡಲು, ನಾನು ಪ್ರತ್ಯೇಕ ರೂಟಿಂಗ್ ಟೇಬಲ್ ಅನ್ನು ರಚಿಸುತ್ತೇನೆ -ಸೆಟ್-ಮಾರ್ಕ್ 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

ರೆಸೆಲ್ಯೂಟ್ಸ್

ಸರಿ, ಈಗ ಅತ್ಯಂತ ಮುಖ್ಯವಾದ ವಿಷಯವೆಂದರೆ, ಪರಿಣಾಮವಾಗಿ ಏನಾಯಿತು? ಅಭಿವೃದ್ಧಿ ಮತ್ತು ಡೀಬಗ್ ಮಾಡುವ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ನಾನು ಸೆರೆಹಿಡಿಯಲು ನಿರ್ವಹಿಸಿದ ಕೆಲವು ಗ್ರಾಫ್‌ಗಳು ಇಲ್ಲಿವೆ. ಕೆಳಗಿನ ಸ್ಕ್ರಿಪ್ಟ್‌ನೊಂದಿಗೆ ಗ್ನಪ್ಲಾಟ್ ಬಳಸಿ ಗ್ರಾಫ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲಾಗಿದೆ.

#! /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

ಹಲವಾರು LTE ಮೋಡೆಮ್‌ಗಳಲ್ಲಿ ಏಕಕಾಲಿಕ ವೇಗ ಪರೀಕ್ಷೆ