ShIoTiny: ਨੋਡ, ਕਨੈਕਸ਼ਨ ਅਤੇ ਇਵੈਂਟਸ ਜਾਂ ਡਰਾਇੰਗ ਪ੍ਰੋਗਰਾਮਾਂ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ

ਮੁੱਖ ਨੁਕਤੇ ਜਾਂ ਇਹ ਲੇਖ ਕਿਸ ਬਾਰੇ ਹੈ

ਲੇਖ ਦਾ ਵਿਸ਼ਾ ਵਿਜ਼ੂਅਲ PLC ਪ੍ਰੋਗਰਾਮਿੰਗ ਹੈ ਸ਼ਿਓਟੀਨੀ ਇੱਥੇ ਵਰਣਿਤ ਸਮਾਰਟ ਹੋਮ ਲਈ: ShioTiny: ਛੋਟਾ ਆਟੋਮੇਸ਼ਨ, ਚੀਜ਼ਾਂ ਦਾ ਇੰਟਰਨੈਟ ਜਾਂ "ਛੁੱਟੀਆਂ ਤੋਂ ਛੇ ਮਹੀਨੇ ਪਹਿਲਾਂ".

ਬਹੁਤ ਸੰਖੇਪ ਵਿੱਚ ਸੰਕਲਪਾਂ ਜਿਵੇਂ ਕਿ ਨੋਡਸ, ਕੁਨੈਕਸ਼ਨ, ਘਟਨਾਵਾਂ, ਅਤੇ ਨਾਲ ਹੀ ਇੱਕ ਵਿਜ਼ੂਅਲ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਲੋਡ ਕਰਨ ਅਤੇ ਚਲਾਉਣ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ESP8266, ਜੋ ਕਿ PLC ਦਾ ਆਧਾਰ ਹੈ ਸ਼ਿਓਟੀਨੀ.

ਜਾਣ-ਪਛਾਣ ਜਾਂ ਕੁਝ ਸੰਗਠਨਾਤਮਕ ਪ੍ਰਸ਼ਨ

ਮੇਰੇ ਵਿਕਾਸ ਬਾਰੇ ਪਿਛਲੇ ਲੇਖ ਵਿੱਚ, ਮੈਂ ਕੰਟਰੋਲਰ ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਬਾਰੇ ਸੰਖੇਪ ਜਾਣਕਾਰੀ ਦਿੱਤੀ ਸੀ ਸ਼ਿਓਟੀਨੀ.

ਅਜੀਬ ਤੌਰ 'ਤੇ, ਜਨਤਾ ਨੇ ਕਾਫ਼ੀ ਮਜ਼ਬੂਤ ​​ਦਿਲਚਸਪੀ ਦਿਖਾਈ ਅਤੇ ਮੈਨੂੰ ਕਾਫ਼ੀ ਸਵਾਲ ਪੁੱਛੇ। ਕੁਝ ਦੋਸਤਾਂ ਨੇ ਤੁਰੰਤ ਮੇਰੇ ਤੋਂ ਇੱਕ ਕੰਟਰੋਲਰ ਖਰੀਦਣ ਦੀ ਪੇਸ਼ਕਸ਼ ਵੀ ਕੀਤੀ। ਨਹੀਂ, ਮੈਂ ਥੋੜਾ ਪੈਸਾ ਕਮਾਉਣ ਦੇ ਵਿਰੁੱਧ ਨਹੀਂ ਹਾਂ, ਪਰ ਮੇਰੀ ਜ਼ਮੀਰ ਮੈਨੂੰ ਅਜਿਹੀ ਕੋਈ ਚੀਜ਼ ਵੇਚਣ ਦੀ ਇਜਾਜ਼ਤ ਨਹੀਂ ਦਿੰਦੀ ਜੋ ਅਜੇ ਵੀ ਸਾਫਟਵੇਅਰ ਦੇ ਰੂਪ ਵਿੱਚ ਬਹੁਤ ਕੱਚਾ ਹੈ।

ਇਸ ਲਈ, ਮੈਂ GitHub 'ਤੇ ਫਰਮਵੇਅਰ ਬਾਈਨਰੀ ਅਤੇ ਡਿਵਾਈਸ ਡਾਇਗ੍ਰਾਮ ਪੋਸਟ ਕੀਤਾ ਹੈ: ਫਰਮਵੇਅਰ + ਛੋਟੀਆਂ ਹਦਾਇਤਾਂ + ਚਿੱਤਰ + ਉਦਾਹਰਣਾਂ.

ਹੁਣ ਹਰ ਕੋਈ ESP-07 ਨੂੰ ਫਲੈਸ਼ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਆਪਣੇ ਆਪ ਫਰਮਵੇਅਰ ਨਾਲ ਖੇਡ ਸਕਦਾ ਹੈ। ਜੇ ਕੋਈ ਸੱਚਮੁੱਚ ਉਹੀ ਬੋਰਡ ਚਾਹੁੰਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਫੋਟੋ ਵਿੱਚ ਹੈ, ਤਾਂ ਮੇਰੇ ਕੋਲ ਉਨ੍ਹਾਂ ਵਿੱਚੋਂ ਕਈ ਹਨ. ਈਮੇਲ ਦੁਆਰਾ ਲਿਖੋ [ਈਮੇਲ ਸੁਰੱਖਿਅਤ]. ਪਰ, ਜਿਵੇਂ ਕਿ ਅਭੁੱਲ ਓਗੁਰਤਸੋਵ ਕਹਿੰਦਾ ਸੀ: "ਮੈਂ ਕਿਸੇ ਵੀ ਚੀਜ਼ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ!"

ਇਸ ਲਈ, ਆਓ ਇਸ ਗੱਲ 'ਤੇ ਪਹੁੰਚੀਏ: ਕੀ ਹੈ "ਗੰਢ"(ਨੋਡ) ਅਤੇ"ਘਟਨਾ"? ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਵੇਂ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ?

ਆਮ ਵਾਂਗ, ਆਓ ਕ੍ਰਮ ਵਿੱਚ ਸ਼ੁਰੂ ਕਰੀਏ: ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਕੇ.

ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਿਵੇਂ ਲੋਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ

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

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

ਜੇ ਸਭ ਕੁਝ ਠੀਕ ਚੱਲਦਾ ਹੈ, ਤਾਂ ਸੰਪਾਦਕ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਇੱਕ ਸਰਕਟ ਇੱਕ ਨੋਡ ਦਾ ਇੱਕ ਟੈਕਸਟ ਵੇਰਵਾ ShIoTiny ਨੂੰ ਭੇਜਦਾ ਹੈ। ਬੇਸ਼ੱਕ, ShioTiny ਤੋਂ ਮੌਜੂਦਾ ਸਰਕਟ ਨੂੰ ਪਹਿਲਾਂ ਹਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ. ਨਤੀਜਾ ਟੈਕਸਟ ਵੇਰਵਾ FLASH ਮੈਮੋਰੀ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਤਰੀਕੇ ਨਾਲ, ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਡਿਵਾਈਸ ਤੋਂ ਇੱਕ ਸਰਕਟ ਨੂੰ ਹਟਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇਸ ਵਿੱਚ ਇੱਕ ਖਾਲੀ ਸਰਕਟ ਲੋਡ ਕਰੋ (ਇੱਕ ਸਿੰਗਲ ਨੋਡ ਤੱਤ ਨਹੀਂ).

ਇੱਕ ਵਾਰ ਜਦੋਂ ਸਾਰਾ ਸਰਕਟ ਪ੍ਰੋਗਰਾਮ ShioTiny PLC ਵਿੱਚ ਲੋਡ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ "ਐਕਜ਼ੀਕਿਊਟ" ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਦਿੰਦਾ ਹੈ। ਇਸਦਾ ਮਤਲੱਬ ਕੀ ਹੈ?

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

ਪਹਿਲਾਂ, ਨੋਡ ਆਬਜੈਕਟ ਉਹਨਾਂ ਦੇ ਵਰਣਨ ਦੇ ਅਧਾਰ ਤੇ ਬਣਾਏ ਜਾਂਦੇ ਹਨ.
ਫਿਰ ਨੋਡਾਂ ਵਿਚਕਾਰ ਕੁਨੈਕਸ਼ਨ ਬਣਾਏ ਜਾਂਦੇ ਹਨ. ਯਾਨੀ, ਆਉਟਪੁੱਟ ਦੇ ਇਨਪੁਟਸ ਅਤੇ ਇਨਪੁਟਸ ਦੇ ਆਉਟਪੁੱਟ ਦੇ ਲਿੰਕ ਤਿਆਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।

ਅਤੇ ਇਸ ਸਭ ਤੋਂ ਬਾਅਦ ਹੀ ਮੁੱਖ ਪ੍ਰੋਗਰਾਮ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਚੱਕਰ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ।

ਮੈਂ ਲੰਬੇ ਸਮੇਂ ਲਈ ਲਿਖਿਆ, ਪਰ ਪੂਰੀ ਪ੍ਰਕਿਰਿਆ - ਫਲੈਸ਼ ਮੈਮੋਰੀ ਤੋਂ ਮੁੱਖ ਚੱਕਰ ਸ਼ੁਰੂ ਕਰਨ ਤੱਕ ਸਰਕਟ ਨੂੰ "ਲੋਡ ਕਰਨ" ਤੋਂ ਲੈ ਕੇ - 60-80 ਨੋਡਾਂ ਦੇ ਸਰਕਟ ਲਈ ਇੱਕ ਸਕਿੰਟ ਦਾ ਇੱਕ ਹਿੱਸਾ ਲੈਂਦਾ ਹੈ।

ਮੁੱਖ ਲੂਪ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ? ਬਹੁਤ ਹੀ ਸਧਾਰਨ. ਪਹਿਲਾਂ ਉਹ ਉਭਰਨ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ ਘਟਨਾਵਾਂ ਕੁਝ ਨੋਡ 'ਤੇ, ਫਿਰ ਉਸ ਘਟਨਾ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਦਾ ਹੈ। ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਬੇਅੰਤ. ਖੈਰ, ਜਾਂ ਜਦੋਂ ਤੱਕ ਉਹ ਇੱਕ ਨਵੀਂ ਸਕੀਮ ਨੂੰ ShioTiny 'ਤੇ ਅਪਲੋਡ ਕਰਦੇ ਹਨ.

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

ਨੋਡ, ਕਨੈਕਸ਼ਨ ਅਤੇ ਇਵੈਂਟਸ

ਲਈ ਸਰਕਟ ਪ੍ਰੋਗਰਾਮਾਂ ਦੀਆਂ ਉਦਾਹਰਣਾਂ 'ਤੇ ਨਜ਼ਰ ਮਾਰੋ ਸ਼ਿਓਟੀਨੀਇਹ ਸਮਝਣ ਲਈ ਕਿ ਚਿੱਤਰ ਵਿੱਚ ਸਿਰਫ ਦੋ ਇਕਾਈਆਂ ਹਨ - ਨੋਡ (ਜਾਂ ਤੱਤ) ਅਤੇ ਉਹਨਾਂ ਵਿਚਕਾਰ ਕਨੈਕਸ਼ਨ।

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

ਪ੍ਰਵੇਸ਼ - ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਨੋਡ ਡਾਟਾ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ। ਇਨਪੁਟ ਚਿੱਤਰ ਉਹ ਪੁਆਇੰਟ ਹੁੰਦੇ ਹਨ ਜੋ ਹਮੇਸ਼ਾ ਨੋਡ ਦੇ ਖੱਬੇ ਪਾਸੇ ਹੁੰਦੇ ਹਨ।

ਬਾਹਰ ਜਾਓ - ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਨੋਡ ਦੀ ਕਾਰਵਾਈ ਦਾ ਨਤੀਜਾ ਮੁੜ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਆਉਟਪੁੱਟ ਚਿੱਤਰ ਉਹ ਪੁਆਇੰਟ ਹੁੰਦੇ ਹਨ ਜੋ ਹਮੇਸ਼ਾ ਨੋਡ ਦੇ ਸੱਜੇ ਪਾਸੇ ਸਥਿਤ ਹੁੰਦੇ ਹਨ।

ਕੁਝ ਨੋਡਾਂ ਵਿੱਚ ਇਨਪੁੱਟ ਨਹੀਂ ਹੁੰਦੇ ਹਨ। ਅਜਿਹੇ ਨੋਡ ਅੰਦਰੂਨੀ ਤੌਰ 'ਤੇ ਨਤੀਜਾ ਪੈਦਾ ਕਰਦੇ ਹਨ. ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਸਥਿਰ ਨੋਡ ਜਾਂ ਇੱਕ ਸੈਂਸਰ ਨੋਡ: ਉਹਨਾਂ ਨੂੰ ਨਤੀਜੇ ਦੀ ਰਿਪੋਰਟ ਕਰਨ ਲਈ ਦੂਜੇ ਨੋਡਾਂ ਤੋਂ ਡੇਟਾ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ ਹੈ।

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

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇੱਕ ਵਿਲੱਖਣ ਟਿੱਪਣੀ ਨੋਡ ਵੀ ਹੈ. ਇਹ ਕੁਝ ਨਹੀਂ ਕਰਦਾ, ਕੋਈ ਇਨਪੁਟ ਜਾਂ ਆਉਟਪੁੱਟ ਨਹੀਂ ਹੈ। ਇਸਦਾ ਉਦੇਸ਼ ਚਿੱਤਰ 'ਤੇ ਸਪੱਸ਼ਟੀਕਰਨ ਹੋਣਾ ਹੈ।

ਕੀ ਹੋਇਆ ਹੈ "ਘਟਨਾ"? ਘਟਨਾ ਕਿਸੇ ਵੀ ਨੋਡ ਵਿੱਚ ਨਵੇਂ ਡੇਟਾ ਦਾ ਉਭਰਨਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇਵੈਂਟਸ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ: ਇਨਪੁਟ ਸਥਿਤੀ ਵਿੱਚ ਤਬਦੀਲੀ (ਨੋਡ ਇੰਪੁੱਟ), ਕਿਸੇ ਹੋਰ ਡਿਵਾਈਸ ਤੋਂ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਨਾ (ਨੋਡਸ ਐਮਕਿTਟੀ и UDP), ਇੱਕ ਨਿਸ਼ਚਿਤ ਸਮੇਂ ਦੀ ਮਿਆਦ (ਨੋਡਸ ਟਾਈਮਰ и ਦੇਰੀ) ਇਤਆਦਿ.

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

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

ਜਦੋਂ ਇੱਕ ਨੋਡ ਇੱਕ ਇਵੈਂਟ ਬਣਾਉਂਦਾ ਹੈ (ਅਰਥਾਤ, ਇਸਦੇ ਆਉਟਪੁੱਟ 'ਤੇ ਨਵਾਂ ਡੇਟਾ ਪ੍ਰਗਟ ਹੁੰਦਾ ਹੈ), ਤਾਂ ਆਮ ਸਥਿਤੀ ਵਿੱਚ ਇਵੈਂਟ ਜਨਰੇਟਰ ਨੋਡ ਦੇ ਆਉਟਪੁੱਟ ਨਾਲ ਜੁੜੇ ਨੋਡਾਂ ਦੀ ਪੂਰੀ ਲੜੀ ਦੀ ਸਥਿਤੀ ਬਦਲ ਜਾਂਦੀ ਹੈ।

ਇਸ ਨੂੰ ਸਪੱਸ਼ਟ ਕਰਨ ਲਈ, ਚਿੱਤਰ ਵਿਚ ਦਿੱਤੀ ਉਦਾਹਰਣ 'ਤੇ ਗੌਰ ਕਰੋ।

ਇੱਥੇ ਸਰਗਰਮ ਨੋਡਸ Input1, Input2 ਅਤੇ Input3 ਹਨ। ਬਾਕੀ ਨੋਡ ਪੈਸਿਵ ਹਨ। ਆਉ ਵਿਚਾਰ ਕਰੀਏ ਕਿ ਕੀ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਇੱਕ ਜਾਂ ਇੱਕ ਹੋਰ ਇਨਪੁਟ ਬੰਦ ਹੁੰਦਾ ਹੈ. ਸਹੂਲਤ ਲਈ, ਨਤੀਜੇ ਇੱਕ ਸਾਰਣੀ ਵਿੱਚ ਸੰਖੇਪ ਕੀਤੇ ਗਏ ਹਨ।

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ, ਜਦੋਂ ਕੋਈ ਘਟਨਾ ਵਾਪਰਦੀ ਹੈ, ਤਾਂ ਘਟਨਾ ਦੇ ਸਰੋਤ ਨੋਡ ਤੋਂ ਅੰਤ ਨੋਡ ਤੱਕ ਇੱਕ ਚੇਨ ਬਣਾਈ ਜਾਂਦੀ ਹੈ। ਉਹਨਾਂ ਨੋਡਾਂ ਦੀ ਸਥਿਤੀ ਜੋ ਚੇਨ ਵਿੱਚ ਨਹੀਂ ਆਉਂਦੇ ਹਨ, ਬਦਲਦੇ ਨਹੀਂ ਹਨ.

ਇੱਕ ਜਾਇਜ਼ ਸਵਾਲ ਉੱਠਦਾ ਹੈ: ਜੇ ਦੋ ਜਾਂ ਕਈ ਘਟਨਾਵਾਂ ਇੱਕੋ ਸਮੇਂ ਵਾਪਰਦੀਆਂ ਹਨ ਤਾਂ ਕੀ ਹੋਵੇਗਾ?

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

ਪਰ ਵਿਹਾਰਕ ਤੌਰ 'ਤੇ ਸਭ ਕੁਝ ਬਹੁਤ ਸਰਲ ਹੈ: ਜਦੋਂ ਦੋ ਜਾਂ ਕਈ ਘਟਨਾਵਾਂ ਵਾਪਰਦੀਆਂ ਹਨ, ਤਾਂ ਹਰੇਕ ਘਟਨਾ ਸਰੋਤ ਤੋਂ ਸਾਰੀਆਂ ਚੇਨਾਂ ਕ੍ਰਮਵਾਰ ਬਣਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ ਅਤੇ ਬਦਲੇ ਵਿੱਚ ਪ੍ਰਕਿਰਿਆ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਅਤੇ ਕੋਈ ਚਮਤਕਾਰ ਨਹੀਂ ਵਾਪਰਦਾ।

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

ਤਾਂ ਇਸ ਮਾਮਲੇ ਵਿੱਚ ਕੀ ਹੋਵੇਗਾ? ਜਵਾਬ ਬਹੁਤ "ਨਿਸ਼ਚਿਤ" ਹੋਵੇਗਾ: ਕਿਸ ਨੋਡ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਆਉ ਚਿੱਤਰ ਵਿੱਚ ਉਦਾਹਰਨ ਨੂੰ ਵੇਖੀਏ.

ਜਦੋਂ ਇਨਪੁਟ 1 ਦੇ ਇਨਪੁਟ ਸੰਪਰਕ ਖੁੱਲ੍ਹੇ ਹੁੰਦੇ ਹਨ, ਤਾਂ ਨੋਡ A ਦਾ ਉਪਰਲਾ ਇਨਪੁਟ 0 ਹੁੰਦਾ ਹੈ। ਨੋਡ A ਦਾ ਆਉਟਪੁੱਟ ਵੀ 0 ਹੁੰਦਾ ਹੈ। ਨੋਡ B ਦਾ ਆਉਟਪੁੱਟ 1 ਹੁੰਦਾ ਹੈ। ਅਤੇ ਅੰਤ ਵਿੱਚ, ਨੋਡ A ਦਾ ਹੇਠਲਾ ਇੰਪੁੱਟ 1 ਹੁੰਦਾ ਹੈ। ਸਭ ਕੁਝ ਹੁੰਦਾ ਹੈ। ਸਾਫ਼ ਅਤੇ ਉਹਨਾਂ ਲਈ ਜੋ ਸਪਸ਼ਟ ਨਹੀਂ ਹਨ, ਹੇਠਾਂ ਵਰਣਨ ਲਈ ਵੇਖੋ ਕਿ "AND" ਅਤੇ "NOT" ਨੋਡ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ।

ਹੁਣ ਅਸੀਂ ਇਨਪੁਟ 1 ਇਨਪੁਟ ਦੇ ਸੰਪਰਕਾਂ ਨੂੰ ਬੰਦ ਕਰਦੇ ਹਾਂ, ਯਾਨੀ ਅਸੀਂ ਇੱਕ ਨੂੰ ਨੋਡ ਏ ਦੇ ਉੱਪਰਲੇ ਇਨਪੁਟ 'ਤੇ ਲਾਗੂ ਕਰਦੇ ਹਾਂ। ਜਿਹੜੇ ਲੋਕ ਇਲੈਕਟ੍ਰੋਨਿਕਸ ਤੋਂ ਜਾਣੂ ਹਨ ਉਹ ਜਾਣਦੇ ਹਨ ਕਿ ਅਸਲ ਵਿੱਚ ਅਸੀਂ ਤਰਕ ਤੱਤਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਕਲਾਸਿਕ ਜਨਰੇਟਰ ਸਰਕਟ ਪ੍ਰਾਪਤ ਕਰਾਂਗੇ। ਅਤੇ ਸਿਧਾਂਤਕ ਤੌਰ 'ਤੇ, ਅਜਿਹੇ ਸਰਕਟ ਨੂੰ ਤੱਤ A ਅਤੇ B ਦੇ ਆਉਟਪੁੱਟ 'ਤੇ ਨਿਰੰਤਰ 1-0-1-0-1-0… ਕ੍ਰਮ ਪੈਦਾ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਅਤੇ 0-1-0-1-0-1-…. ਆਖ਼ਰਕਾਰ, ਇਵੈਂਟ ਨੂੰ ਨੋਡਸ A ਅਤੇ B ਦੀ ਸਥਿਤੀ ਨੂੰ ਲਗਾਤਾਰ ਬਦਲਣਾ ਚਾਹੀਦਾ ਹੈ, ਇੱਕ ਚੱਕਰ 2-3-2-3-!

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

ਨੋਡ ਇਨਪੁਟ 1 ਤੋਂ ਇੱਕ ਘਟਨਾ ਨੋਡ ਏ ਦੀ ਸਥਿਤੀ, ਫਿਰ ਨੋਡ ਬੀ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਇੱਕ ਚੱਕਰ ਵਿੱਚ ਕਈ ਵਾਰ ਬਦਲਦੀ ਹੈ। ਪ੍ਰੋਗਰਾਮ ਘਟਨਾ ਦੇ "ਲੂਪਿੰਗ" ਦਾ ਪਤਾ ਲਗਾਉਂਦਾ ਹੈ ਅਤੇ ਇਸ ਕਾਰਨੀਵਲ ਨੂੰ ਜ਼ਬਰਦਸਤੀ ਰੋਕ ਦਿੰਦਾ ਹੈ। ਇਸ ਤੋਂ ਬਾਅਦ, ਨੋਡਜ਼ A ਅਤੇ B ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਉਦੋਂ ਤੱਕ ਬਲੌਕ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਜਦੋਂ ਤੱਕ ਕੋਈ ਨਵੀਂ ਘਟਨਾ ਨਹੀਂ ਵਾਪਰਦੀ। ਉਹ ਪਲ ਜਿਸ 'ਤੇ ਪ੍ਰੋਗਰਾਮ ਫੈਸਲਾ ਕਰਦਾ ਹੈ "ਸਰਕਲਾਂ ਵਿੱਚ ਘੁੰਮਣਾ ਬੰਦ ਕਰੋ!" - ਆਮ ਤੌਰ 'ਤੇ, ਇਹ ਬਹੁਤ ਸਾਰੇ ਕਾਰਕਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਬੇਤਰਤੀਬ ਮੰਨਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਗੰਢਾਂ ਨੂੰ ਇੱਕ ਰਿੰਗ ਵਿੱਚ ਜੋੜਦੇ ਸਮੇਂ ਸਾਵਧਾਨ ਰਹੋ - ਪ੍ਰਭਾਵ ਹਮੇਸ਼ਾ ਸਪੱਸ਼ਟ ਨਹੀਂ ਹੋਣਗੇ! ਤੁਸੀਂ ਕੀ ਅਤੇ ਕਿਉਂ ਕਰ ਰਹੇ ਹੋ ਇਸ ਬਾਰੇ ਚੰਗੀ ਤਰ੍ਹਾਂ ਵਿਚਾਰ ਕਰੋ!

ਕੀ ਸਾਡੇ ਲਈ ਉਪਲਬਧ ਨੋਡਾਂ 'ਤੇ ਜਨਰੇਟਰ ਬਣਾਉਣਾ ਅਜੇ ਵੀ ਸੰਭਵ ਹੈ? ਤੁਸੀ ਕਰ ਸਕਦੇ ਹੋ! ਪਰ ਇਸ ਲਈ ਇੱਕ ਨੋਡ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਜੋ ਖੁਦ ਈਵੈਂਟ ਤਿਆਰ ਕਰ ਸਕਦਾ ਹੈ। ਅਤੇ ਇੱਕ ਅਜਿਹਾ ਨੋਡ ਹੈ - ਇਹ "ਦੇਰੀ ਲਾਈਨ" ਹੈ. ਆਓ ਦੇਖੀਏ ਕਿ 6 ਸੈਕਿੰਡ ਦੀ ਮਿਆਦ ਵਾਲਾ ਜਨਰੇਟਰ ਹੇਠਾਂ ਦਿੱਤੇ ਚਿੱਤਰ ਵਿੱਚ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ।

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

ਦੇਰੀ ਲਾਈਨ ਦੀ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਵਿਸ਼ੇਸ਼ਤਾ ਇਹ ਹੈ ਕਿ ਇਹ ਦੇਰੀ ਦੇ ਸਮੇਂ ਦੀ ਮਿਆਦ ਪੁੱਗਣ ਤੋਂ ਬਾਅਦ ਇੱਕ ਇਵੈਂਟ ਤਿਆਰ ਕਰਦੀ ਹੈ।

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

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

ਸਮੇਂ-ਸਮੇਂ ਦੀਆਂ ਕਾਰਵਾਈਆਂ ਨੂੰ ਸੈੱਟ ਕਰਨ ਲਈ, ਟਾਈਮਰ ਨੋਡਸ ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਮੈਂ ਨੋਟ ਕਰਦਾ ਹਾਂ ਕਿ ਅਜਿਹੇ ਡਿਜੀਟਲ ਸਿਗਨਲ, ਜਿੱਥੇ "ਜ਼ੀਰੋ" ਅਤੇ "ਇੱਕ" ਦੀ ਮਿਆਦ ਬਰਾਬਰ ਹੁੰਦੀ ਹੈ, ਨੂੰ "ਮੀਂਡਰ" ਕਿਹਾ ਜਾਂਦਾ ਹੈ।

ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਮੈਂ ਇਸ ਸਵਾਲ ਨੂੰ ਥੋੜਾ ਜਿਹਾ ਸਪੱਸ਼ਟ ਕਰ ਦਿੱਤਾ ਹੈ ਕਿ ਨੋਡਾਂ ਦੇ ਵਿਚਕਾਰ ਘਟਨਾਵਾਂ ਕਿਵੇਂ ਪ੍ਰਸਾਰਿਤ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਅਤੇ ਕੀ ਨਹੀਂ ਕਰਨਾ ਹੈ?

ਸਿੱਟਾ ਅਤੇ ਹਵਾਲੇ

ਲੇਖ ਛੋਟਾ ਨਿਕਲਿਆ, ਪਰ ਇਹ ਲੇਖ ਉਹਨਾਂ ਸਵਾਲਾਂ ਦਾ ਜਵਾਬ ਹੈ ਜੋ ਨੋਡਾਂ ਅਤੇ ਘਟਨਾਵਾਂ ਦੇ ਸੰਬੰਧ ਵਿੱਚ ਪੈਦਾ ਹੋਏ ਹਨ.

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

ਪਹਿਲਾਂ ਵਾਂਗ, ਚਿੱਤਰ, ਫਰਮਵੇਅਰ, ਉਦਾਹਰਣਾਂ, ਭਾਗਾਂ ਦਾ ਵੇਰਵਾ ਅਤੇ ਸਭ ਕੁਝ ਬਾਕੀ ਇੱਥੇ ਹੈ.

ਸਵਾਲ, ਸੁਝਾਅ, ਆਲੋਚਨਾ - ਇੱਥੇ ਜਾਓ: [ਈਮੇਲ ਸੁਰੱਖਿਅਤ]

ਸਰੋਤ: www.habr.com