ਟੈਂਗੋ ਕੰਟਰੋਲ

ਕੀ ਟੈਂਗੋ?

ਇਹ ਵੱਖ-ਵੱਖ ਹਾਰਡਵੇਅਰ ਅਤੇ ਸੌਫਟਵੇਅਰ ਦੇ ਪ੍ਰਬੰਧਨ ਲਈ ਇੱਕ ਸਿਸਟਮ ਹੈ।
TANGO ਵਰਤਮਾਨ ਵਿੱਚ 4 ਪਲੇਟਫਾਰਮਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ: Linux, Windows NT, Solaris ਅਤੇ HP-UX।
ਇੱਥੇ ਅਸੀਂ ਲੀਨਕਸ (ਉਬੰਟੂ 18.04) ਨਾਲ ਕੰਮ ਕਰਨ ਦਾ ਵਰਣਨ ਕਰਾਂਗੇ।

ਇਹ ਕਿਸ ਲਈ ਹੈ?

ਵੱਖ-ਵੱਖ ਸਾਜ਼ੋ-ਸਾਮਾਨ ਅਤੇ ਸੌਫਟਵੇਅਰ ਨਾਲ ਕੰਮ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ.

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

ਕਿੱਥੇ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ

• ਸਰੋਤ
• ਇੰਸਟਾਲੇਸ਼ਨ ਨਿਰਦੇਸ਼
• ਉਬੰਟੂ 'ਤੇ ਆਧਾਰਿਤ ਟੈਂਗੋਬਾਕਸ ਚਿੱਤਰ

ਮੈਂ ਇਸਨੂੰ ਸਰੋਤ ਕੋਡ ਤੋਂ ਲਾਂਚ ਨਹੀਂ ਕਰ ਸਕਿਆ; ਮੈਂ ਕੰਮ ਕਰਨ ਲਈ ਟੈਂਗੋਬੌਕਸ 9.3 ਦੀ ਇੱਕ ਤਿਆਰ-ਕੀਤੀ ਤਸਵੀਰ ਦੀ ਵਰਤੋਂ ਕੀਤੀ।
ਹਦਾਇਤਾਂ ਦੱਸਦੀਆਂ ਹਨ ਕਿ ਪੈਕੇਜਾਂ ਤੋਂ ਕਿਵੇਂ ਇੰਸਟਾਲ ਕਰਨਾ ਹੈ।

ਇਸ ਵਿੱਚ ਕੀ ਸ਼ਾਮਲ ਹੈ?

• ਜੀਵ — ਟੈਂਗੋ ਡੇਟਾਬੇਸ ਨੂੰ ਦੇਖਣ ਅਤੇ ਸੰਪਾਦਿਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
• POGO - ਟੈਂਗੋ ਡਿਵਾਈਸ ਸਰਵਰਾਂ ਲਈ ਕੋਡ ਜਨਰੇਟਰ।
• ਐਸਟਰ - ਟੈਂਗੋ ਸਿਸਟਮ ਲਈ ਪ੍ਰੋਗਰਾਮ ਮੈਨੇਜਰ।

ਅਸੀਂ ਸਿਰਫ਼ ਪਹਿਲੇ ਦੋ ਹਿੱਸਿਆਂ ਵਿੱਚ ਹੀ ਦਿਲਚਸਪੀ ਲਵਾਂਗੇ।

ਸਮਰਥਿਤ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ

• C
• C ++
• ਜਾਵਾ
• ਜਾਵਾਸਕਰਿਪਟ
• ਪਾਈਥਨ
• ਮੈਟਲਾਬ
• ਲੈਬਵਿਜ਼ਨ

ਮੈਂ ਇਸਦੇ ਨਾਲ python & c++ ਵਿੱਚ ਕੰਮ ਕੀਤਾ। ਇੱਥੇ C++ ਨੂੰ ਉਦਾਹਰਣ ਵਜੋਂ ਵਰਤਿਆ ਜਾਵੇਗਾ।

ਹੁਣ ਆਉ ਇਸ ਦੇ ਵਰਣਨ ਵੱਲ ਵਧੀਏ ਕਿ ਡਿਵਾਈਸ ਨੂੰ ਟੈਂਗੋ ਨਾਲ ਕਿਵੇਂ ਕਨੈਕਟ ਕਰਨਾ ਹੈ ਅਤੇ ਇਸ ਨਾਲ ਕਿਵੇਂ ਕੰਮ ਕਰਨਾ ਹੈ। ਫੀਸ ਨੂੰ ਉਦਾਹਰਣ ਵਜੋਂ ਲਿਆ ਜਾਵੇਗਾ GPS neo-6m-0-001:

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਤਸਵੀਰ ਵਿੱਚ ਦੇਖ ਸਕਦੇ ਹੋ, ਅਸੀਂ UART CP2102 ਦੁਆਰਾ ਬੋਰਡ ਨੂੰ PC ਨਾਲ ਕਨੈਕਟ ਕਰਦੇ ਹਾਂ। ਜਦੋਂ ਇੱਕ PC ਨਾਲ ਕਨੈਕਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਡਿਵਾਈਸ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ /dev/ttyUSB[0-N], ਆਮ ਤੌਰ 'ਤੇ /dev/ttyUSB0.

POGO

ਹੁਣ ਲਾਂਚ ਕਰੀਏ Pogo, ਅਤੇ ਸਾਡੇ ਬੋਰਡ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਪਿੰਜਰ ਕੋਡ ਤਿਆਰ ਕਰੋ।

pogo

ਮੈਂ ਪਹਿਲਾਂ ਹੀ ਕੋਡ ਬਣਾ ਲਿਆ ਹੈ, ਚਲੋ ਇਸਨੂੰ ਦੁਬਾਰਾ ਬਣਾਉ ਫਾਈਲ->ਨਵਾਂ.

ਸਾਨੂੰ ਹੇਠ ਲਿਖਿਆਂ ਮਿਲਦਾ ਹੈ:

ਸਾਡੀ ਡਿਵਾਈਸ (ਭਵਿੱਖ ਵਿੱਚ, ਡਿਵਾਈਸ ਦੁਆਰਾ ਸਾਡਾ ਮਤਲਬ ਸਾਫਟਵੇਅਰ ਭਾਗ ਹੋਵੇਗਾ) ਖਾਲੀ ਹੈ ਅਤੇ ਇਸ ਵਿੱਚ ਦੋ ਕੰਟਰੋਲ ਕਮਾਂਡਾਂ ਹਨ: ਰਾਜ & ਸਥਿਤੀ.

ਇਹ ਜ਼ਰੂਰੀ ਗੁਣਾਂ ਨਾਲ ਭਰਿਆ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ:

ਡਿਵਾਈਸ ਪ੍ਰਾਪਰਟੀ - ਡਿਫੌਲਟ ਮੁੱਲ ਜੋ ਅਸੀਂ ਡਿਵਾਈਸ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਟ੍ਰਾਂਸਫਰ ਕਰਦੇ ਹਾਂ; GPS ਬੋਰਡ ਲਈ, ਤੁਹਾਨੂੰ ਸਿਸਟਮ ਵਿੱਚ ਬੋਰਡ ਦਾ ਨਾਮ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ com="/dev/ttyUSB0" ਅਤੇ com ਪੋਰਟ ਸਪੀਡ ਬੌਦਰਾਡੇ = 9600

ਕਮਾਂਡਾਂ — ਸਾਡੀ ਡਿਵਾਈਸ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਕਮਾਂਡਾਂ; ਉਹਨਾਂ ਨੂੰ ਆਰਗੂਮੈਂਟ ਅਤੇ ਵਾਪਸੀ ਮੁੱਲ ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ।

• ਸਟੇਟ - ਮੌਜੂਦਾ ਸਥਿਤੀ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਤੋਂ ਅਮਰੀਕਾ
• ਸਥਿਤੀ - ਮੌਜੂਦਾ ਸਥਿਤੀ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਇਹ ਸਤਰ ਦਾ ਪੂਰਕ ਹੈ ਸਟੇਟ
• GSArray - ਵਾਪਸੀ GPS ਫਾਰਮ ਵਿੱਚ ਸਤਰ ਦੇਵਵਾਰਚਾਰਾਰੇ

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

ਅਮਰੀਕਾ — ਉਹ ਸਥਿਤੀ ਜਿਸ ਵਿੱਚ ਸਾਡੀ ਡਿਵਾਈਸ ਸਥਿਤ ਹੈ।

• ਖੋਲ੍ਹੋ — ਯੰਤਰ ਖੁੱਲ੍ਹਾ ਹੈ।
• ਬੰਦ ਕਰੋ - ਡਿਵਾਈਸ ਬੰਦ ਹੈ।
• ਫੇਲ - ਗਲਤੀ.
• ON — ਡਿਵਾਈਸ ਤੋਂ ਡਾਟਾ ਪ੍ਰਾਪਤ ਕਰੋ।
• ਬੰਦ — ਡਿਵਾਈਸ ਤੋਂ ਕੋਈ ਡਾਟਾ ਨਹੀਂ।

ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਜੋੜਨ ਦੀ ਉਦਾਹਰਨ gps_string:

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

ਹੋਇਆ:

ਹੁਣ ਤੁਹਾਨੂੰ ਕੋਡ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ ਫਾਈਲ-> ਤਿਆਰ ਕਰੋ

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

ਹੁਣ ਪ੍ਰੋਗਰਾਮਿੰਗ ਵੱਲ ਵਧਦੇ ਹਾਂ। ਪੋਗੋ ਨੇ ਸਾਡੇ ਲਈ ਹੇਠ ਲਿਖਿਆਂ ਨੂੰ ਤਿਆਰ ਕੀਤਾ:

ਸਾਨੂੰ NEO6M.cpp ਅਤੇ NEO6M.h ਵਿੱਚ ਦਿਲਚਸਪੀ ਹੋਵੇਗੀ। ਆਉ ਇੱਕ ਕਲਾਸ ਕੰਸਟਰਕਟਰ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਲਈਏ:

NEO6M::NEO6M(Tango::DeviceClass *cl, string &s)
 : TANGO_BASE_CLASS(cl, s.c_str())
{
    /*----- PROTECTED REGION ID(NEO6M::constructor_1) ENABLED START -----*/
    init_device();

    /*----- PROTECTED REGION END -----*/    //  NEO6M::constructor_1
}

ਇੱਥੇ ਕੀ ਹੈ ਅਤੇ ਇੱਥੇ ਕੀ ਮਹੱਤਵਪੂਰਨ ਹੈ? init_device() ਫੰਕਸ਼ਨ ਸਾਡੇ ਗੁਣਾਂ ਲਈ ਮੈਮੋਰੀ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ: gps_string & gps_array, ਪਰ ਇਹ ਮਹੱਤਵਪੂਰਨ ਨਹੀਂ ਹੈ। ਇੱਥੇ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਗੱਲ ਇਹ ਹੈ, ਇਹ ਟਿੱਪਣੀਆਂ ਹਨ:

/*----- PROTECTED REGION ID(NEO6M::constructor_1) ENABLED START -----*/
    .......
/*----- PROTECTED REGION END -----*/    //  NEO6M::constructor_1

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

ਹੁਣ ਕਲਾਸ ਵਿੱਚ ਮੁੱਖ ਫੰਕਸ਼ਨ ਕੀ ਹਨ? NEO6M:

void always_executed_hook();
void read_attr_hardware(vector<long> &attr_list);
void read_gps_string(Tango::Attribute &attr);
void read_gps_array(Tango::Attribute &attr);

ਜਦੋਂ ਅਸੀਂ ਗੁਣ ਮੁੱਲ ਨੂੰ ਪੜ੍ਹਨਾ ਚਾਹੁੰਦੇ ਹਾਂ gps_string, ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਕ੍ਰਮ ਵਿੱਚ ਬੁਲਾਇਆ ਜਾਵੇਗਾ: ਹਮੇਸ਼ਾ_ਚੱਲਿਆ_ਹੁੱਕ, read_attr_hardware и read_gps_string. Read_gps_string ਮੁੱਲ ਨਾਲ gps_string ਨੂੰ ਭਰ ਦੇਵੇਗਾ।

void NEO6M::read_gps_string(Tango::Attribute &attr)
{
    DEBUG_STREAM << "NEO6M::read_gps_string(Tango::Attribute &attr) entering... " << endl;
    /*----- PROTECTED REGION ID(NEO6M::read_gps_string) ENABLED START -----*/
    //  Set the attribute value

        *this->attr_gps_string_read = Tango::string_dup(this->gps.c_str());

    attr.set_value(attr_gps_string_read);

    /*----- PROTECTED REGION END -----*/    //  NEO6M::read_gps_string
}

ਸੰਗ੍ਰਹਿ

ਸਰੋਤ ਫੋਲਡਰ ਤੇ ਜਾਓ ਅਤੇ:

make

ਪ੍ਰੋਗਰਾਮ ਨੂੰ ~/ਡਿਵਾਈਸ ਸਰਵਰ ਫੋਲਡਰ ਵਿੱਚ ਕੰਪਾਇਲ ਕੀਤਾ ਜਾਵੇਗਾ।

tango-cs@tangobox:~/DeviceServers$ ls
NEO6M

ਜੀਵ

jive

ਡੇਟਾਬੇਸ ਵਿੱਚ ਪਹਿਲਾਂ ਹੀ ਕੁਝ ਡਿਵਾਈਸਾਂ ਹਨ, ਚਲੋ ਹੁਣ ਆਪਣਾ ਬਣਾਓ ਸੰਪਾਦਿਤ ਕਰੋ-> ਸਰਵਰ ਬਣਾਓ

ਹੁਣ ਇਸ ਨਾਲ ਜੁੜਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ:

ਕੁਝ ਵੀ ਕੰਮ ਨਹੀਂ ਕਰੇਗਾ, ਪਹਿਲਾਂ ਸਾਨੂੰ ਆਪਣਾ ਪ੍ਰੋਗਰਾਮ ਚਲਾਉਣ ਦੀ ਲੋੜ ਹੈ:

sudo ./NEO6M neo6m -v2

ਮੈਂ ਸਿਰਫ ਅਧਿਕਾਰਾਂ ਦੇ ਨਾਲ com ਪੋਰਟ ਨਾਲ ਜੁੜ ਸਕਦਾ ਹਾਂ ਰੂਟ-ਏ. v - ਲਾਗਿੰਗ ਪੱਧਰ.

ਹੁਣ ਅਸੀਂ ਕਨੈਕਟ ਕਰ ਸਕਦੇ ਹਾਂ:

ਗਾਹਕ

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

#include <tango.h>
using namespace Tango;

int main(int argc, char **argv) {
    try {

        //
        // create a connection to a TANGO device
        //

        DeviceProxy *device = new DeviceProxy("NEO6M/neo6m/1");

        //
        // Ping the device
        //

        device->ping();

        //
        // Execute a command on the device and extract the reply as a string
        //

        vector<Tango::DevUChar> gps_array;

        DeviceData cmd_reply;
        cmd_reply = device->command_inout("GPSArray");
        cmd_reply >> gps_array;

        for (int i = 0; i < gps_array.size(); i++) {            
            printf("%c", gps_array[i]);
        }
        puts("");

        //
        // Read a device attribute (string data type)
        //

        string spr;
        DeviceAttribute att_reply;
        att_reply = device->read_attribute("gps_string");
        att_reply >> spr;
        cout << spr << endl;

        vector<Tango::DevUChar> spr2;
        DeviceAttribute att_reply2;
        att_reply2 = device->read_attribute("gps_array");
        att_reply2.extract_read(spr2);

        for (int i = 0; i < spr2.size(); i++) {
            printf("%c", spr2[i]);
        }

        puts("");

    } catch (DevFailed &e) {
        Except::print_exception(e);
        exit(-1);
    }
}

ਕੰਪਾਇਲ ਕਿਵੇਂ ਕਰੀਏ:

g++ gps.cpp -I/usr/local/include/tango -I/usr/local/include -I/usr/local/include -std=c++0x -Dlinux -L/usr/local/lib -ltango -lomniDynamic4 -lCOS4 -lomniORB4 -lomnithread -llog4tango -lzmq -ldl -lpthread -lstdc++

ਨਤੀਜਾ:

tango-cs@tangobox:~/workspace/c$ ./a.out 
$GPRMC,,V,,,,,,,,,,N*53

$GPRMC,,V,,,,,,,,,,N*53

$GPRMC,,V,,,,,,,,,,N*53

ਸਾਨੂੰ ਇੱਕ ਸਟਰਿੰਗ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਅੱਖਰਾਂ ਦੀ ਇੱਕ ਐਰੇ ਨੂੰ ਲੈ ਕੇ, ਕਮਾਂਡ ਵਾਪਸੀ ਦੇ ਰੂਪ ਵਿੱਚ ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਹੋਇਆ।

ਹਵਾਲੇ

• ਸਰੋਤ ਕੋਡ

ਮੈਂ ਆਪਣੇ ਲਈ ਲੇਖ ਲਿਖਿਆ, ਕਿਉਂਕਿ ਕੁਝ ਸਮੇਂ ਬਾਅਦ ਮੈਂ ਭੁੱਲਣਾ ਸ਼ੁਰੂ ਕਰ ਦਿੰਦਾ ਹਾਂ ਕਿ ਕਿਵੇਂ ਅਤੇ ਕੀ ਕਰਨਾ ਹੈ.

ਤੁਹਾਡੇ ਧਿਆਨ ਲਈ ਧੰਨਵਾਦ.

ਸਰੋਤ: www.habr.com