ਕਈ LTE ਮਾਡਮਾਂ 'ਤੇ ਇੱਕੋ ਸਮੇਂ ਦੀ ਸਪੀਡ ਟੈਸਟ

ਕੁਆਰੰਟੀਨ ਦੇ ਦੌਰਾਨ, ਮੈਨੂੰ ਕਈ ਸੈਲੂਲਰ ਆਪਰੇਟਰਾਂ ਲਈ LTE ਮਾਡਮਾਂ ਦੀ ਗਤੀ ਨੂੰ ਮਾਪਣ ਲਈ ਇੱਕ ਡਿਵਾਈਸ ਦੇ ਵਿਕਾਸ ਵਿੱਚ ਹਿੱਸਾ ਲੈਣ ਦੀ ਪੇਸ਼ਕਸ਼ ਕੀਤੀ ਗਈ ਸੀ।

ਗ੍ਰਾਹਕ ਵੱਖ-ਵੱਖ ਭੂਗੋਲਿਕ ਸਥਾਨਾਂ 'ਤੇ ਵੱਖ-ਵੱਖ ਦੂਰਸੰਚਾਰ ਆਪਰੇਟਰਾਂ ਦੀ ਗਤੀ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨਾ ਚਾਹੁੰਦਾ ਸੀ ਤਾਂ ਜੋ ਇਹ ਸਮਝਣ ਦੇ ਯੋਗ ਹੋ ਸਕੇ ਕਿ LTE ਕਨੈਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਸਾਜ਼ੋ-ਸਾਮਾਨ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਵੇਲੇ ਕਿਹੜਾ ਸੈਲੂਲਰ ਆਪਰੇਟਰ ਉਸ ਲਈ ਸਭ ਤੋਂ ਅਨੁਕੂਲ ਸੀ, ਉਦਾਹਰਨ ਲਈ, ਵੀਡੀਓ ਪ੍ਰਸਾਰਣ ਲਈ। ਉਸੇ ਸਮੇਂ, ਸਮੱਸਿਆ ਨੂੰ ਮਹਿੰਗੇ ਸਾਜ਼ੋ-ਸਾਮਾਨ ਤੋਂ ਬਿਨਾਂ, ਜਿੰਨਾ ਸੰਭਵ ਹੋ ਸਕੇ ਸਧਾਰਨ ਅਤੇ ਸਸਤੇ ਢੰਗ ਨਾਲ ਹੱਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਸੀ.

ਮੈਂ ਤੁਰੰਤ ਕਹਾਂਗਾ ਕਿ ਇਹ ਕੰਮ ਸਭ ਤੋਂ ਸਰਲ ਅਤੇ ਸਭ ਤੋਂ ਵੱਧ ਗਿਆਨ ਭਰਪੂਰ ਨਹੀਂ ਹੈ; ਮੈਂ ਤੁਹਾਨੂੰ ਦੱਸਾਂਗਾ ਕਿ ਮੈਨੂੰ ਕਿਹੜੀਆਂ ਸਮੱਸਿਆਵਾਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪਿਆ ਅਤੇ ਮੈਂ ਉਨ੍ਹਾਂ ਨੂੰ ਕਿਵੇਂ ਹੱਲ ਕੀਤਾ। ਇਸ ਲਈ, ਆਓ ਚੱਲੀਏ।

ਟਿੱਪਣੀ

ਇੱਕ LTE ਕਨੈਕਸ਼ਨ ਦੀ ਗਤੀ ਨੂੰ ਮਾਪਣਾ ਇੱਕ ਬਹੁਤ ਹੀ ਗੁੰਝਲਦਾਰ ਮਾਮਲਾ ਹੈ: ਤੁਹਾਨੂੰ ਸਹੀ ਉਪਕਰਨ ਅਤੇ ਮਾਪ ਤਕਨੀਕ ਦੀ ਚੋਣ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਅਤੇ ਸੈਲੂਲਰ ਨੈੱਟਵਰਕ ਦੀ ਟੌਪੋਲੋਜੀ ਅਤੇ ਸੰਚਾਲਨ ਦੀ ਚੰਗੀ ਸਮਝ ਵੀ ਹੈ। ਨਾਲ ਹੀ, ਗਤੀ ਨੂੰ ਕਈ ਕਾਰਕਾਂ ਦੁਆਰਾ ਪ੍ਰਭਾਵਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ: ਇੱਕ ਸੈੱਲ 'ਤੇ ਗਾਹਕਾਂ ਦੀ ਗਿਣਤੀ, ਮੌਸਮ ਦੀਆਂ ਸਥਿਤੀਆਂ, ਇੱਥੋਂ ਤੱਕ ਕਿ ਸੈੱਲ ਤੋਂ ਸੈੱਲ ਤੱਕ, ਨੈਟਵਰਕ ਟੌਪੋਲੋਜੀ ਦੇ ਕਾਰਨ ਗਤੀ ਨਾਟਕੀ ਰੂਪ ਵਿੱਚ ਬਦਲ ਸਕਦੀ ਹੈ। ਆਮ ਤੌਰ 'ਤੇ, ਇਹ ਅਣਜਾਣ ਦੀ ਇੱਕ ਵੱਡੀ ਗਿਣਤੀ ਨਾਲ ਇੱਕ ਸਮੱਸਿਆ ਹੈ, ਅਤੇ ਸਿਰਫ ਇੱਕ ਦੂਰਸੰਚਾਰ ਆਪਰੇਟਰ ਇਸ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਹੱਲ ਕਰ ਸਕਦਾ ਹੈ.

ਸ਼ੁਰੂ ਵਿੱਚ, ਗਾਹਕ ਸਿਰਫ਼ ਓਪਰੇਟਰਾਂ ਦੇ ਫ਼ੋਨਾਂ ਨਾਲ ਕੋਰੀਅਰ ਚਲਾਉਣਾ ਚਾਹੁੰਦਾ ਸੀ, ਸਿੱਧੇ ਫ਼ੋਨ 'ਤੇ ਮਾਪ ਲੈਣਾ ਚਾਹੁੰਦਾ ਸੀ ਅਤੇ ਫਿਰ ਇੱਕ ਨੋਟਬੁੱਕ ਵਿੱਚ ਸਪੀਡ ਮਾਪ ਦੇ ਨਤੀਜਿਆਂ ਨੂੰ ਲਿਖਣਾ ਚਾਹੁੰਦਾ ਸੀ। lte ਨੈੱਟਵਰਕਾਂ ਦੀ ਗਤੀ ਨੂੰ ਮਾਪਣ ਲਈ ਮੇਰਾ ਹੱਲ, ਹਾਲਾਂਕਿ ਆਦਰਸ਼ ਨਹੀਂ ਹੈ, ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ।

ਸਮੇਂ ਦੀ ਘਾਟ ਕਾਰਨ, ਮੈਂ ਸਹੂਲਤ ਜਾਂ ਵਿਹਾਰਕਤਾ ਦੇ ਪੱਖ ਵਿੱਚ ਨਹੀਂ, ਸਗੋਂ ਵਿਕਾਸ ਦੀ ਗਤੀ ਦੇ ਪੱਖ ਵਿੱਚ ਫੈਸਲੇ ਕੀਤੇ। ਉਦਾਹਰਨ ਲਈ, ਰਿਵਰਸ ssh ਦੀ ਵਰਤੋਂ ਰਿਮੋਟ ਐਕਸੈਸ ਲਈ ਕੀਤੀ ਗਈ ਸੀ, ਵਧੇਰੇ ਵਿਹਾਰਕ VPN ਦੀ ਬਜਾਏ, ਸਰਵਰ ਅਤੇ ਹਰੇਕ ਵਿਅਕਤੀਗਤ ਕਲਾਇੰਟ ਨੂੰ ਸਥਾਪਤ ਕਰਨ 'ਤੇ ਸਮਾਂ ਬਚਾਉਣ ਲਈ।

ਤਕਨੀਕੀ ਕੰਮ

ਜਿਵੇਂ ਕਿ ਲੇਖ ਵਿੱਚ ਦੱਸਿਆ ਗਿਆ ਹੈ ਤਕਨੀਕੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੇ ਬਿਨਾਂ: ਗਾਹਕ ਇਹ ਕਿਉਂ ਨਹੀਂ ਚਾਹੁੰਦਾ ਹੈ: ਤਕਨੀਕੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਤੋਂ ਬਿਨਾਂ ਕੰਮ ਨਾ ਕਰੋ! ਕਦੇ, ਕਿਤੇ ਵੀ ਨਹੀਂ!

ਤਕਨੀਕੀ ਕੰਮ ਕਾਫ਼ੀ ਸਧਾਰਨ ਸੀ, ਮੈਂ ਅੰਤਮ ਉਪਭੋਗਤਾ ਦੀ ਸਮਝ ਲਈ ਇਸਨੂੰ ਥੋੜਾ ਜਿਹਾ ਵਿਸਤਾਰ ਕਰਾਂਗਾ. ਤਕਨੀਕੀ ਹੱਲ ਅਤੇ ਉਪਕਰਣ ਦੀ ਚੋਣ ਗਾਹਕ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤੀ ਗਈ ਸੀ. ਇਸ ਲਈ, ਤਕਨੀਕੀ ਨਿਰਧਾਰਨ ਆਪਣੇ ਆਪ, ਸਾਰੀਆਂ ਪ੍ਰਵਾਨਗੀਆਂ ਤੋਂ ਬਾਅਦ:

ਇੱਕ ਸਿੰਗਲ ਬੋਰਡ ਕੰਪਿਊਟਰ 'ਤੇ ਆਧਾਰਿਤ vim2 H ਮਾਡਮ ਦੁਆਰਾ lte ਕਨੈਕਸ਼ਨਾਂ ਲਈ ਇੱਕ ਸਪੀਡ ਟੈਸਟਰ ਬਣਾਓuawei e3372h - 153 ਕਈ ਦੂਰਸੰਚਾਰ ਆਪਰੇਟਰ (ਇੱਕ ਤੋਂ n ਤੱਕ)। UART ਰਾਹੀਂ ਜੁੜੇ GPS ਰਿਸੀਵਰ ਤੋਂ ਕੋਆਰਡੀਨੇਟ ਪ੍ਰਾਪਤ ਕਰਨਾ ਵੀ ਜ਼ਰੂਰੀ ਹੈ। ਸੇਵਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਗਤੀ ਮਾਪ ਕਰੋ www.speedtest.net ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਇੱਕ ਟੇਬਲ ਵਿੱਚ ਰੱਖੋ ਜਿਵੇਂ ਕਿ:

csv ਫਾਰਮੈਟ ਵਿੱਚ ਸਾਰਣੀ। ਫਿਰ ਇਸ ਸਾਈਨ ਨੂੰ ਹਰ 6 ਘੰਟੇ ਬਾਅਦ ਈ-ਮੇਲ ਰਾਹੀਂ ਭੇਜੋ। ਗਲਤੀਆਂ ਦੀ ਸਥਿਤੀ ਵਿੱਚ, GPIO ਨਾਲ ਕਨੈਕਟ ਕੀਤੇ LED ਨੂੰ ਬਲਿੰਕ ਕਰੋ।

ਮੈਂ ਬਹੁਤ ਸਾਰੀਆਂ ਮਨਜ਼ੂਰੀਆਂ ਦੇ ਬਾਅਦ, ਮੁਫਤ ਰੂਪ ਵਿੱਚ ਤਕਨੀਕੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਾ ਵਰਣਨ ਕੀਤਾ ਹੈ। ਪਰ ਕੰਮ ਦਾ ਅਰਥ ਪਹਿਲਾਂ ਹੀ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ. ਹਰ ਚੀਜ਼ ਲਈ ਇੱਕ ਹਫ਼ਤਾ ਦਿੱਤਾ ਗਿਆ ਸੀ। ਪਰ ਅਸਲ ਵਿੱਚ ਇਹ ਤਿੰਨ ਹਫ਼ਤੇ ਤੱਕ ਚੱਲਿਆ. ਇਹ ਇਸ ਤੱਥ ਨੂੰ ਧਿਆਨ ਵਿਚ ਰੱਖ ਰਿਹਾ ਹੈ ਕਿ ਮੈਂ ਇਹ ਸਿਰਫ ਆਪਣੀ ਮੁੱਖ ਨੌਕਰੀ ਤੋਂ ਬਾਅਦ ਅਤੇ ਵੀਕਐਂਡ 'ਤੇ ਕੀਤਾ ਸੀ।

ਇੱਥੇ ਮੈਂ ਇੱਕ ਵਾਰ ਫਿਰ ਇਸ ਤੱਥ ਵੱਲ ਧਿਆਨ ਖਿੱਚਣਾ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਗਾਹਕ ਸਪੀਡ ਮਾਪ ਸੇਵਾ ਅਤੇ ਹਾਰਡਵੇਅਰ ਦੀ ਵਰਤੋਂ 'ਤੇ ਪਹਿਲਾਂ ਹੀ ਸਹਿਮਤ ਹੋ ਗਿਆ ਸੀ, ਜਿਸ ਨੇ ਮੇਰੀ ਸਮਰੱਥਾ ਨੂੰ ਬਹੁਤ ਸੀਮਤ ਕਰ ਦਿੱਤਾ ਸੀ। ਬਜਟ ਵੀ ਸੀਮਤ ਸੀ, ਇਸ ਲਈ ਕੁਝ ਖਾਸ ਨਹੀਂ ਖਰੀਦਿਆ ਗਿਆ। ਇਸ ਲਈ ਸਾਨੂੰ ਇਨ੍ਹਾਂ ਨਿਯਮਾਂ ਅਨੁਸਾਰ ਖੇਡਣਾ ਪਿਆ।

ਆਰਕੀਟੈਕਚਰ ਅਤੇ ਵਿਕਾਸ

ਸਕੀਮ ਸਧਾਰਨ ਅਤੇ ਸਪੱਸ਼ਟ ਹੈ. ਇਸ ਲਈ, ਮੈਂ ਇਸਨੂੰ ਬਿਨਾਂ ਕਿਸੇ ਵਿਸ਼ੇਸ਼ ਟਿੱਪਣੀ ਦੇ ਛੱਡਾਂਗਾ.

ਮੈਂ ਪੂਰੇ ਪ੍ਰੋਜੈਕਟ ਨੂੰ python ਵਿੱਚ ਲਾਗੂ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ, ਇਸ ਤੱਥ ਦੇ ਬਾਵਜੂਦ ਕਿ ਮੈਨੂੰ ਇਸ ਭਾਸ਼ਾ ਵਿੱਚ ਵਿਕਾਸ ਕਰਨ ਦਾ ਕੋਈ ਅਨੁਭਵ ਨਹੀਂ ਸੀ। ਮੈਂ ਇਸਨੂੰ ਇਸ ਲਈ ਚੁਣਿਆ ਕਿਉਂਕਿ ਇੱਥੇ ਤਿਆਰ ਕੀਤੀਆਂ ਉਦਾਹਰਣਾਂ ਅਤੇ ਹੱਲ ਹਨ ਜੋ ਵਿਕਾਸ ਨੂੰ ਤੇਜ਼ ਕਰ ਸਕਦੇ ਹਨ। ਇਸ ਲਈ, ਮੈਂ ਸਾਰੇ ਪੇਸ਼ੇਵਰ ਪ੍ਰੋਗਰਾਮਰਾਂ ਨੂੰ ਪਾਇਥਨ ਵਿੱਚ ਵਿਕਾਸ ਕਰਨ ਦੇ ਮੇਰੇ ਪਹਿਲੇ ਤਜ਼ਰਬੇ ਨੂੰ ਨਾ ਡਾਂਟਣ ਲਈ ਕਹਿੰਦਾ ਹਾਂ, ਅਤੇ ਮੈਂ ਆਪਣੇ ਹੁਨਰ ਨੂੰ ਸੁਧਾਰਨ ਲਈ ਰਚਨਾਤਮਕ ਆਲੋਚਨਾ ਸੁਣ ਕੇ ਹਮੇਸ਼ਾ ਖੁਸ਼ ਹੁੰਦਾ ਹਾਂ।

ਇਸ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਵੀ ਮੈਨੂੰ ਪਤਾ ਲੱਗਾ ਕਿ ਪਾਈਥਨ ਦੇ ਦੋ ਚੱਲ ਰਹੇ ਸੰਸਕਰਣ 2 ਅਤੇ 3 ਹਨ, ਨਤੀਜੇ ਵਜੋਂ ਮੈਂ ਤੀਜੇ 'ਤੇ ਸੈਟਲ ਹੋ ਗਿਆ।

ਹਾਰਡਵੇਅਰ ਨੋਡਸ

ਸਿੰਗਲ-ਪਲੇਟ vim2

ਮੈਨੂੰ ਮੇਰੀ ਮੁੱਖ ਮਸ਼ੀਨ ਵਜੋਂ ਇੱਕ ਸਿੰਗਲ-ਬੋਰਡ ਕੰਪਿਊਟਰ ਦਿੱਤਾ ਗਿਆ ਸੀ vim2

ਇੱਕ ਸਮਾਰਟ ਹੋਮ ਅਤੇ SMART-TV ਲਈ ਇੱਕ ਸ਼ਾਨਦਾਰ, ਸ਼ਕਤੀਸ਼ਾਲੀ ਮੀਡੀਆ ਪ੍ਰੋਸੈਸਰ, ਪਰ ਇਸ ਕੰਮ ਲਈ ਬਹੁਤ ਹੀ ਅਣਉਚਿਤ, ਜਾਂ, ਮੰਨ ਲਓ, ਮਾੜਾ ਢੁਕਵਾਂ। ਉਦਾਹਰਨ ਲਈ, ਇਸਦਾ ਮੁੱਖ OS ਐਂਡਰੌਇਡ ਹੈ, ਅਤੇ ਲੀਨਕਸ ਇੱਕ ਸੈਕੰਡਰੀ OS ਹੈ, ਅਤੇ ਇਸਦੇ ਅਨੁਸਾਰ ਕੋਈ ਵੀ ਲੀਨਕਸ ਦੇ ਅਧੀਨ ਸਾਰੇ ਨੋਡਾਂ ਅਤੇ ਡਰਾਈਵਰਾਂ ਦੇ ਉੱਚ-ਗੁਣਵੱਤਾ ਸੰਚਾਲਨ ਦੀ ਗਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ ਹੈ। ਅਤੇ ਮੈਂ ਮੰਨਦਾ ਹਾਂ ਕਿ ਕੁਝ ਸਮੱਸਿਆਵਾਂ ਇਸ ਪਲੇਟਫਾਰਮ ਦੇ USB ਡਰਾਈਵਰਾਂ ਨਾਲ ਸਬੰਧਤ ਸਨ, ਇਸਲਈ ਮਾਡਮ ਇਸ ਬੋਰਡ 'ਤੇ ਉਮੀਦ ਅਨੁਸਾਰ ਕੰਮ ਨਹੀਂ ਕਰਦੇ ਸਨ। ਇਸ ਵਿੱਚ ਬਹੁਤ ਮਾੜੇ ਅਤੇ ਖਿੰਡੇ ਹੋਏ ਦਸਤਾਵੇਜ਼ ਵੀ ਹਨ, ਇਸਲਈ ਹਰੇਕ ਓਪਰੇਸ਼ਨ ਵਿੱਚ ਡੌਕਸ ਦੀ ਖੁਦਾਈ ਕਰਨ ਵਿੱਚ ਬਹੁਤ ਸਮਾਂ ਲੱਗਿਆ। GPIO ਦੇ ਨਾਲ ਆਮ ਕੰਮ ਵੀ ਬਹੁਤ ਖੂਨ ਲੈਂਦਾ ਹੈ. ਉਦਾਹਰਨ ਲਈ, ਮੈਨੂੰ LED ਨੂੰ ਸੈੱਟ ਕਰਨ ਲਈ ਕਈ ਘੰਟੇ ਲੱਗ ਗਏ। ਪਰ, ਉਦੇਸ਼ ਹੋਣ ਲਈ, ਇਹ ਬੁਨਿਆਦੀ ਤੌਰ 'ਤੇ ਮਹੱਤਵਪੂਰਨ ਨਹੀਂ ਸੀ ਕਿ ਇਹ ਕਿਸ ਕਿਸਮ ਦਾ ਸਿੰਗਲ-ਬੋਰਡ ਸੀ, ਮੁੱਖ ਗੱਲ ਇਹ ਸੀ ਕਿ ਇਹ ਕੰਮ ਕਰਦਾ ਸੀ ਅਤੇ USB ਪੋਰਟਾਂ ਸਨ.

ਪਹਿਲਾਂ, ਮੈਨੂੰ ਇਸ ਬੋਰਡ 'ਤੇ ਲੀਨਕਸ ਇੰਸਟਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਕ੍ਰਮ ਵਿੱਚ ਹਰ ਕਿਸੇ ਲਈ ਦਸਤਾਵੇਜ਼ਾਂ ਦੇ ਜੰਗਲਾਂ ਨੂੰ ਖੁਰਦ-ਬੁਰਦ ਨਾ ਕਰਨ ਲਈ, ਅਤੇ ਉਹਨਾਂ ਲਈ ਵੀ ਜੋ ਇਸ ਸਿੰਗਲ-ਬੋਰਡ ਪ੍ਰਣਾਲੀ ਨਾਲ ਨਜਿੱਠਣਗੇ, ਮੈਂ ਇਹ ਅਧਿਆਇ ਲਿਖ ਰਿਹਾ ਹਾਂ.

Linux ਨੂੰ ਸਥਾਪਤ ਕਰਨ ਲਈ ਦੋ ਵਿਕਲਪ ਹਨ: ਇੱਕ ਬਾਹਰੀ SD ਕਾਰਡ 'ਤੇ ਜਾਂ ਅੰਦਰੂਨੀ MMC 'ਤੇ। ਮੈਂ ਇੱਕ ਸ਼ਾਮ ਇਹ ਪਤਾ ਲਗਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਵਿੱਚ ਬਿਤਾਈ ਕਿ ਇਸਨੂੰ ਕਾਰਡ ਨਾਲ ਕਿਵੇਂ ਕੰਮ ਕਰਨਾ ਹੈ, ਇਸਲਈ ਮੈਂ ਇਸਨੂੰ MMC 'ਤੇ ਸਥਾਪਤ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ, ਹਾਲਾਂਕਿ ਬਿਨਾਂ ਕਿਸੇ ਸ਼ੱਕ ਦੇ ਬਾਹਰੀ ਕਾਰਡ ਨਾਲ ਕੰਮ ਕਰਨਾ ਬਹੁਤ ਸੌਖਾ ਹੋਵੇਗਾ।

ਫਰਮਵੇਅਰ ਬਾਰੇ ਟੇਢੇ ਢੰਗ ਨਾਲ ਇੱਥੇ ਦੱਸਿਆ. ਮੈਂ ਅਜੀਬ ਤੋਂ ਰੂਸੀ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਦਾ ਹਾਂ। ਬੋਰਡ ਨੂੰ ਫਲੈਸ਼ ਕਰਨ ਲਈ, ਮੈਨੂੰ ਹਾਰਡਵੇਅਰ UART ਨਾਲ ਜੁੜਨ ਦੀ ਲੋੜ ਹੈ। ਇਸ ਨੂੰ ਜੋੜਿਆ ਹੇਠ ਲਿਖੇ ਤਰੀਕੇ ਨਾਲ.

• ਟੂਲ ਪਿੰਨ GND: <—> VIMs ਦੇ GPIO ਦਾ ਪਿੰਨ17
• ਟੂਲ ਪਿੰਨ TXD: <—> VIMs ਦੇ GPIO (Linux_Rx) ਦਾ ਪਿੰਨ18
• ਟੂਲ ਪਿੰਨ RXD: <—> VIMs ਦੇ GPIO (Linux_Tx) ਦਾ ਪਿੰਨ19
• ਟੂਲ ਪਿੰਨ VCC: <—> VIMs ਦੇ 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

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

ਬੱਸ, ਓਏ। ਮੈਂ ਜਾਂਚ ਕੀਤੀ, ਬੋਰਡ 'ਤੇ ਲੀਨਕਸ ਹੈ। ਲਾਗਇਨ/ਪਾਸਵਰਡ 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

ਜੇਕਰ ਤੁਹਾਨੂੰ ਇਹ ਮੁਸ਼ਕਲ ਲੱਗਦਾ ਹੈ, ਤਾਂ ਇਸ ਬੋਰਡ ਦੀ ਵਰਤੋਂ ਨਾ ਕਰੋ; ਰਸਬੇਰੀ ਪਾਈ ਬਿਹਤਰ ਹੈ। ਇਮਾਨਦਾਰੀ ਨਾਲ.

ਮੋਡਮ 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 ਹੱਬ ਨੂੰ ਇੱਕ ਚੰਗੀ ਸਥਿਰ ਬਿਜਲੀ ਸਪਲਾਈ ਦੀ ਲੋੜ ਸੀ. ਮੈਂ ਪਾਵਰ ਨੂੰ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਹੱਬ ਤੱਕ ਸਖ਼ਤ ਸੋਲਡਰਿੰਗ ਕਰਕੇ ਇਸ ਸਮੱਸਿਆ ਦਾ ਹੱਲ ਕੀਤਾ। ਇਕ ਹੋਰ ਸਮੱਸਿਆ ਜਿਸ ਦਾ ਮੈਨੂੰ ਸਾਹਮਣਾ ਕਰਨਾ ਪਿਆ ਅਤੇ ਜਿਸ ਨੇ ਪੂਰੇ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਬਰਬਾਦ ਕਰ ਦਿੱਤਾ: ਡਿਵਾਈਸ ਦੇ ਰੀਬੂਟ ਜਾਂ ਕੋਲਡ ਸਟਾਰਟ ਤੋਂ ਬਾਅਦ, ਸਾਰੇ ਮਾਡਮ ਨਹੀਂ ਲੱਭੇ ਗਏ ਅਤੇ ਹਮੇਸ਼ਾ ਨਹੀਂ, ਅਤੇ ਮੈਂ ਇਹ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕਰ ਸਕਿਆ ਕਿ ਅਜਿਹਾ ਕਿਉਂ ਹੋਇਆ ਅਤੇ ਕਿਸ ਐਲਗੋਰਿਦਮ ਦੁਆਰਾ. ਪਰ ਪਹਿਲੀਆਂ ਚੀਜ਼ਾਂ ਪਹਿਲਾਂ.

ਮਾਡਮ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ, ਮੈਂ USB-modeswitch ਪੈਕੇਜ ਇੰਸਟਾਲ ਕੀਤਾ ਹੈ।

sudo apt update
sudo apt install -y usb-modeswitch

ਜਿਸ ਤੋਂ ਬਾਅਦ, ਕਨੈਕਟ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਮਾਡਮ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਖੋਜਿਆ ਜਾਵੇਗਾ ਅਤੇ udev ਸਬ-ਸਿਸਟਮ ਦੁਆਰਾ ਸੰਰਚਿਤ ਕੀਤਾ ਜਾਵੇਗਾ। ਮੈਂ ਸਿਰਫ਼ ਮਾਡਮ ਨੂੰ ਕਨੈਕਟ ਕਰਕੇ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾ ਕੇ ਜਾਂਚ ਕਰਦਾ ਹਾਂ ਕਿ ਨੈੱਟਵਰਕ ਦਿਖਾਈ ਦੇ ਰਿਹਾ ਹੈ।
ਇੱਕ ਹੋਰ ਸਮੱਸਿਆ ਜਿਸ ਨੂੰ ਮੈਂ ਹੱਲ ਨਹੀਂ ਕਰ ਸਕਿਆ: ਮੈਂ ਇਸ ਮਾਡਮ ਤੋਂ ਉਸ ਓਪਰੇਟਰ ਦਾ ਨਾਮ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦਾ ਹਾਂ ਜਿਸ ਨਾਲ ਅਸੀਂ ਕੰਮ ਕਰ ਰਹੇ ਹਾਂ? ਆਪਰੇਟਰ ਦਾ ਨਾਮ 192.168.8.1 'ਤੇ ਮਾਡਮ ਵੈੱਬ ਇੰਟਰਫੇਸ ਵਿੱਚ ਮੌਜੂਦ ਹੈ। ਇਹ ਇੱਕ ਗਤੀਸ਼ੀਲ ਵੈਬ ਪੇਜ ਹੈ ਜੋ Ajax ਬੇਨਤੀਆਂ ਦੁਆਰਾ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਇਸਲਈ ਸਿਰਫ਼ ਪੰਨੇ ਨੂੰ ਵਿਜੇਟ ਕਰਨਾ ਅਤੇ ਨਾਮ ਨੂੰ ਪਾਰਸ ਕਰਨਾ ਕੰਮ ਨਹੀਂ ਕਰੇਗਾ। ਇਸ ਲਈ ਮੈਂ ਇਹ ਦੇਖਣਾ ਸ਼ੁਰੂ ਕੀਤਾ ਕਿ ਇੱਕ ਵੈਬ ਪੇਜ ਕਿਵੇਂ ਵਿਕਸਿਤ ਕਰਨਾ ਹੈ, ਆਦਿ, ਅਤੇ ਮਹਿਸੂਸ ਕੀਤਾ ਕਿ ਮੈਂ ਕਿਸੇ ਕਿਸਮ ਦੀ ਬਕਵਾਸ ਕਰ ਰਿਹਾ ਸੀ। ਨਤੀਜੇ ਵਜੋਂ, ਉਸਨੇ ਥੁੱਕਿਆ, ਅਤੇ ਆਪਰੇਟਰ ਨੇ ਸਪੀਡਟੈਸਟ 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

ਇਹ ਹੁਕਮ ਜ਼ਾਹਰ ਤੌਰ 'ਤੇ ਫਲਾਈ 'ਤੇ ਦੇਵਟਰੀ ਨੂੰ ਸੰਪਾਦਿਤ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਬਹੁਤ ਸੁਵਿਧਾਜਨਕ ਹੈ।

ਇਸ ਕਾਰਵਾਈ ਦੀ ਸਫਲਤਾ ਤੋਂ ਬਾਅਦ, 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 ਓਪਰੇਸ਼ਨ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹਾਂ।

ਤੁਸੀਂ ਇਸ ਸਕ੍ਰੀਨਸ਼ੌਟ ਵਿੱਚ ਸੈਟੇਲਾਈਟ ਨਹੀਂ ਦੇਖ ਸਕਦੇ ਹੋ, ਪਰ ਤੁਸੀਂ 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 ਦਾ ਰਿਸੈਪਸ਼ਨ ਖਰਾਬ ਹੋ ਸਕਦਾ ਹੈ ਅਤੇ ਹਮੇਸ਼ਾ ਡਾਟਾ ਪ੍ਰਾਪਤ ਨਹੀਂ ਕਰ ਸਕਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਉਡੀਕ ਕਰਦੇ ਹੋ, ਤਾਂ ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਰਿਮੋਟ ਕਮਰੇ ਵਿੱਚ ਕੰਮ ਕਰਦੇ ਹੋ, ਤਾਂ ਪ੍ਰੋਗਰਾਮ ਇਸ ਥਾਂ 'ਤੇ ਫ੍ਰੀਜ਼ ਹੋ ਜਾਵੇਗਾ। ਇਸ ਲਈ, ਮੈਂ ਇਸ ਅਢੁੱਕਵੇਂ ਵਿਕਲਪ ਨੂੰ ਲਾਗੂ ਕੀਤਾ.

ਸਿਧਾਂਤਕ ਤੌਰ 'ਤੇ, ਜੇਕਰ ਜ਼ਿਆਦਾ ਸਮਾਂ ਹੁੰਦਾ, ਤਾਂ UART ਰਾਹੀਂ ਸਿੱਧੇ GPS ਤੋਂ ਡਾਟਾ ਪ੍ਰਾਪਤ ਕਰਨਾ, ਇਸ ਨੂੰ ਵੱਖਰੇ ਥ੍ਰੈਡ ਵਿੱਚ ਪਾਰਸ ਕਰਨਾ ਅਤੇ ਇਸ ਨਾਲ ਕੰਮ ਕਰਨਾ ਸੰਭਵ ਹੋਵੇਗਾ। ਪਰ ਇੱਥੇ ਕੋਈ ਸਮਾਂ ਨਹੀਂ ਸੀ, ਇਸ ਲਈ ਬੇਰਹਿਮੀ ਨਾਲ ਬਦਸੂਰਤ ਕੋਡ. ਅਤੇ ਹਾਂ, ਮੈਂ ਸ਼ਰਮਿੰਦਾ ਨਹੀਂ ਹਾਂ।

LED

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 ਸੇਵਾ ਦਾ ਆਪਣਾ python-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

ਪਹਿਲਾਂ ਵੀ ਗਲਤੀਆਂ ਭੇਜੀਆਂ ਗਈਆਂ ਸਨ। ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਉਹਨਾਂ ਨੂੰ ਸੂਚੀ ਵਿੱਚ ਇਕੱਠਾ ਕੀਤਾ ਗਿਆ ਸੀ, ਅਤੇ ਫਿਰ ਸ਼ਡਿਊਲਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵੀ ਭੇਜਿਆ ਗਿਆ ਸੀ, ਜੇਕਰ ਕੋਈ ਕੁਨੈਕਸ਼ਨ ਸੀ. ਹਾਲਾਂਕਿ, ਫਿਰ ਇਸ ਤੱਥ ਨਾਲ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਹੋਈਆਂ ਕਿ ਯਾਂਡੇਕਸ ਪ੍ਰਤੀ ਦਿਨ ਭੇਜੇ ਗਏ ਸੰਦੇਸ਼ਾਂ ਦੀ ਗਿਣਤੀ 'ਤੇ ਸੀਮਾ ਹੈ (ਇਹ ਦਰਦ, ਉਦਾਸੀ ਅਤੇ ਅਪਮਾਨ ਹੈ)। ਕਿਉਂਕਿ ਇੱਥੇ ਪ੍ਰਤੀ ਮਿੰਟ ਵੀ ਬਹੁਤ ਸਾਰੀਆਂ ਗਲਤੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ, ਸਾਨੂੰ ਡਾਕ ਰਾਹੀਂ ਗਲਤੀਆਂ ਭੇਜਣਾ ਛੱਡਣਾ ਪਿਆ। ਇਸ ਲਈ ਯਾਂਡੇਕਸ ਸੇਵਾਵਾਂ ਦੁਆਰਾ ਅਜਿਹੀ ਸਮੱਸਿਆ ਬਾਰੇ ਆਪਣੇ ਆਪ ਜਾਣਕਾਰੀ ਭੇਜਣ ਵੇਲੇ ਧਿਆਨ ਵਿੱਚ ਰੱਖੋ।

ਫੀਡਬੈਕ ਸਰਵਰ

ਹਾਰਡਵੇਅਰ ਦੇ ਇੱਕ ਰਿਮੋਟ ਟੁਕੜੇ ਤੱਕ ਪਹੁੰਚ ਪ੍ਰਾਪਤ ਕਰਨ ਅਤੇ ਇਸਨੂੰ ਅਨੁਕੂਲਿਤ ਅਤੇ ਮੁੜ ਸੰਰਚਿਤ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣ ਲਈ, ਮੈਨੂੰ ਇੱਕ ਬਾਹਰੀ ਸਰਵਰ ਦੀ ਲੋੜ ਸੀ। ਆਮ ਤੌਰ 'ਤੇ, ਨਿਰਪੱਖ ਹੋਣ ਲਈ, ਸਰਵਰ ਨੂੰ ਸਾਰਾ ਡੇਟਾ ਭੇਜਣਾ ਅਤੇ ਵੈਬ ਇੰਟਰਫੇਸ ਵਿੱਚ ਸਾਰੇ ਸੁੰਦਰ ਗ੍ਰਾਫਾਂ ਨੂੰ ਬਣਾਉਣਾ ਸਹੀ ਹੋਵੇਗਾ. ਪਰ ਸਾਰੇ ਇੱਕੋ ਵਾਰ ਨਹੀਂ।

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 ਸਰਵਰ ਨੂੰ ਮੁੜ-ਸੰਰਚਨਾ ਕਰਨਾ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ। ਕਿਉਂਕਿ ਕੋਈ ਵੀ ਪੜ੍ਹਦਾ ਨਹੀਂ ਹੈ, ਜਾਣੋ ਕਿ ਰੇਲਗੱਡੀ ਲੱਕੜ ਦੀਆਂ ਰੇਲਾਂ 'ਤੇ ਨਹੀਂ ਚੜ੍ਹਦੀ. ਜੋ ਕੋਈ ਵੀ ਈਸਟਰ ਅੰਡੇ ਨੂੰ ਲੱਭਦਾ ਹੈ ਉਸਨੂੰ ਕੁਝ ਕੈਂਡੀ ਮਿਲਦੀ ਹੈ.

ਅਜਿਹਾ ਕਰਨ ਲਈ, ਮੈਂ ਇੱਕ ਵੱਖਰੀ ਰੂਟਿੰਗ ਟੇਬਲ ਬਣਾਉਂਦਾ ਹਾਂ -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 ਰੂਟਿੰਗ ਦੀ ਸੰਰਚਨਾ ਕਰਦਾ ਹਾਂ (ਜੇ ਇਹ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ), ਜੇਕਰ ਸਮਾਂ ਆ ਗਿਆ ਹੈ ਤਾਂ ਸਰਵਰ ਨੂੰ ਗਲਤੀਆਂ ਭੇਜੋ, ਲੌਗ ਭੇਜੋ ਅਤੇ ਅੰਤ ਵਿੱਚ ਇੱਕ ਸਪੀਡਟੈਸਟ ਚਲਾਓ ਅਤੇ ਲੌਗਸ ਨੂੰ ਇੱਕ 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 ਆਪਰੇਟਰ ਨਾਲ ਸੀ, ਜੋ ਮੈਂ ਕਈ ਦਿਨਾਂ ਲਈ ਆਯੋਜਿਤ ਕੀਤਾ।

ਇੱਥੇ ਮੈਂ ਇੱਕ ਗਤੀਸ਼ੀਲ ਮਾਪਣ ਵਾਲੇ ਸਰਵਰ ਦੀ ਵਰਤੋਂ ਕੀਤੀ. ਸਪੀਡ ਮਾਪ ਕੰਮ ਕਰਦੇ ਹਨ, ਪਰ ਬਹੁਤ ਜ਼ਿਆਦਾ ਉਤਰਾਅ-ਚੜ੍ਹਾਅ ਕਰਦੇ ਹਨ, ਪਰ ਕੁਝ ਔਸਤ ਮੁੱਲ ਅਜੇ ਵੀ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ, ਅਤੇ ਇਹ ਡੇਟਾ ਨੂੰ ਫਿਲਟਰ ਕਰਕੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਮੂਵਿੰਗ ਔਸਤ ਨਾਲ।

ਬਾਅਦ ਵਿੱਚ ਮੈਂ ਹੋਰ ਟੈਲੀਕਾਮ ਆਪਰੇਟਰਾਂ ਲਈ ਕਈ ਗ੍ਰਾਫ ਬਣਾਏ। ਇਸ ਕੇਸ ਵਿੱਚ, ਪਹਿਲਾਂ ਹੀ ਇੱਕ ਟੈਸਟਿੰਗ ਸਰਵਰ ਸੀ, ਅਤੇ ਨਤੀਜੇ ਵੀ ਬਹੁਤ ਦਿਲਚਸਪ ਸਨ.

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ, ਇਸ ਡੇਟਾ ਦੀ ਖੋਜ ਅਤੇ ਪ੍ਰੋਸੈਸਿੰਗ ਲਈ ਵਿਸ਼ਾ ਬਹੁਤ ਵਿਆਪਕ ਹੈ, ਅਤੇ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਕੰਮ ਦੇ ਕੁਝ ਹਫ਼ਤਿਆਂ ਤੱਕ ਨਹੀਂ ਰਹਿੰਦਾ ਹੈ। ਪਰ…

ਕੰਮ ਦਾ ਨਤੀਜਾ

ਮੇਰੇ ਵੱਸ ਤੋਂ ਬਾਹਰ ਦੇ ਹਾਲਾਤਾਂ ਕਾਰਨ ਕੰਮ ਅਚਾਨਕ ਪੂਰਾ ਹੋ ਗਿਆ ਸੀ। ਇਸ ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਕਮਜ਼ੋਰੀਆਂ ਵਿੱਚੋਂ ਇੱਕ, ਮੇਰੀ ਵਿਅਕਤੀਗਤ ਰਾਏ ਵਿੱਚ, ਮਾਡਮ ਸੀ, ਜੋ ਅਸਲ ਵਿੱਚ ਦੂਜੇ ਮਾਡਮਾਂ ਦੇ ਨਾਲ ਇੱਕੋ ਸਮੇਂ ਕੰਮ ਨਹੀਂ ਕਰਨਾ ਚਾਹੁੰਦਾ ਸੀ, ਅਤੇ ਹਰ ਵਾਰ ਲੋਡ ਹੋਣ 'ਤੇ ਅਜਿਹੀਆਂ ਚਾਲਾਂ ਬਣਾਉਂਦਾ ਸੀ। ਇਹਨਾਂ ਉਦੇਸ਼ਾਂ ਲਈ, ਬਹੁਤ ਸਾਰੇ ਹੋਰ ਮਾਡਮ ਮਾਡਲ ਹਨ; ਆਮ ਤੌਰ 'ਤੇ ਉਹ ਪਹਿਲਾਂ ਹੀ ਮਿੰਨੀ PCI-e ਫਾਰਮੈਟ ਵਿੱਚ ਹੁੰਦੇ ਹਨ ਅਤੇ ਡਿਵਾਈਸ ਦੇ ਅੰਦਰ ਸਥਾਪਤ ਹੁੰਦੇ ਹਨ ਅਤੇ ਸੰਰਚਨਾ ਕਰਨ ਵਿੱਚ ਬਹੁਤ ਆਸਾਨ ਹੁੰਦੇ ਹਨ। ਪਰ ਇਹ ਬਿਲਕੁਲ ਵੱਖਰੀ ਕਹਾਣੀ ਹੈ। ਪ੍ਰੋਜੈਕਟ ਦਿਲਚਸਪ ਸੀ ਅਤੇ ਮੈਨੂੰ ਬਹੁਤ ਖੁਸ਼ੀ ਹੋਈ ਕਿ ਮੈਂ ਇਸ ਵਿੱਚ ਹਿੱਸਾ ਲੈਣ ਦੇ ਯੋਗ ਸੀ।

ਸਰੋਤ: www.habr.com