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

ਅੱਜ ਮੈਂ ਤੁਹਾਨੂੰ ਦਿਖਾਵਾਂਗਾ ਕਿ STM32 (Blue Pill) ਅਤੇ STM8 ਕੰਟਰੋਲਰਾਂ 'ਤੇ ਬਹੁਤ ਸਾਰੇ ਪ੍ਰੋਜੈਕਟਾਂ, ਕਾਰਜਾਂ ਲਈ ਕਾਫ਼ੀ ਸਧਾਰਨ, ਪਰ ਜ਼ਰੂਰੀ ਹੱਲ ਕਰਨ ਲਈ ਡੇਟਾਸ਼ੀਟਾਂ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ। ਸਾਰੇ ਡੈਮੋ ਪ੍ਰੋਜੈਕਟ ਮੇਰੇ ਮਨਪਸੰਦ LEDs ਨੂੰ ਸਮਰਪਿਤ ਹਨ, ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਵੱਡੀ ਮਾਤਰਾ ਵਿੱਚ ਪ੍ਰਕਾਸ਼ ਕਰਾਂਗੇ, ਜਿਸ ਲਈ ਸਾਨੂੰ ਹਰ ਤਰ੍ਹਾਂ ਦੇ ਦਿਲਚਸਪ ਪੈਰੀਫਿਰਲ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਪਵੇਗੀ।

ਟੈਕਸਟ ਫਿਰ ਤੋਂ ਬਹੁਤ ਵੱਡਾ ਨਿਕਲਿਆ, ਇਸਲਈ ਸਹੂਲਤ ਲਈ ਮੈਂ ਸਮੱਗਰੀ ਬਣਾ ਰਿਹਾ ਹਾਂ:

STM32 ਬਲੂ ਪਿਲ: DM16 ਡਰਾਈਵਰ ਦੇ ਨਾਲ 634 LEDs
STM8: ਛੇ PWM ਪਿੰਨ ਸਥਾਪਤ ਕਰਨਾ
STM8: ਤਿੰਨ ਪਿੰਨਾਂ 'ਤੇ 8 RGB LEDs, ਰੁਕਾਵਟਾਂ

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

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

ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਮੇਰਾ ਲੇਖ ਸ਼ੌਕ ਵਿੱਚ ਡੁੱਬਣ ਦੇ ਸਮਾਨ ਪੜਾਅ 'ਤੇ ਕਿਸੇ ਦੀ ਮਦਦ ਕਰੇਗਾ.

ਐਸਟੀਐਮ 32

DM16 ਅਤੇ SPI ਨਾਲ 634 LEDs

ਬਲੂ ਪਿਲ (STM32F103C8T6) ਅਤੇ DM634 LED ਡਰਾਈਵਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਛੋਟਾ ਪ੍ਰੋਜੈਕਟ। ਡੇਟਾਸ਼ੀਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਅਸੀਂ ਡਰਾਈਵਰ, STM IO ਪੋਰਟਾਂ ਦਾ ਪਤਾ ਲਗਾਵਾਂਗੇ ਅਤੇ SPI ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਾਂਗੇ।

DM634

16 16-ਬਿੱਟ PWM ਆਉਟਪੁੱਟ ਦੇ ਨਾਲ ਤਾਈਵਾਨੀ ਚਿੱਪ, ਚੇਨ ਵਿੱਚ ਜੁੜੀ ਜਾ ਸਕਦੀ ਹੈ। ਘੱਟ-ਅੰਤ ਦੇ 12-ਬਿੱਟ ਮਾਡਲ ਨੂੰ ਘਰੇਲੂ ਪ੍ਰੋਜੈਕਟ ਤੋਂ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ ਲਾਈਟਪੈਕ. ਇੱਕ ਸਮੇਂ, DM63x ਅਤੇ ਮਸ਼ਹੂਰ TLC5940 ਵਿਚਕਾਰ ਚੋਣ ਕਰਦੇ ਹੋਏ, ਮੈਂ ਕਈ ਕਾਰਨਾਂ ਕਰਕੇ DM ਨੂੰ ਚੁਣਿਆ: 1) Aliexpress 'ਤੇ TLC ਯਕੀਨੀ ਤੌਰ 'ਤੇ ਜਾਅਲੀ ਹੈ, ਪਰ ਇਹ ਇੱਕ ਨਹੀਂ ਹੈ; 2) DM ਕੋਲ ਆਪਣੇ ਖੁਦ ਦੇ ਬਾਰੰਬਾਰਤਾ ਜਨਰੇਟਰ ਦੇ ਨਾਲ ਇੱਕ ਖੁਦਮੁਖਤਿਆਰੀ PWM ਹੈ; 3) ਇਸ ਨੂੰ ਅਲੀ ਤੋਂ ਪਾਰਸਲ ਦੀ ਉਡੀਕ ਕਰਨ ਦੀ ਬਜਾਏ ਮਾਸਕੋ ਵਿੱਚ ਸਸਤੇ ਵਿੱਚ ਖਰੀਦਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਅਤੇ, ਬੇਸ਼ੱਕ, ਇਹ ਸਿੱਖਣਾ ਦਿਲਚਸਪ ਸੀ ਕਿ ਇੱਕ ਤਿਆਰ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਬਜਾਏ, ਆਪਣੇ ਆਪ ਨੂੰ ਚਿੱਪ ਨੂੰ ਕਿਵੇਂ ਨਿਯੰਤਰਿਤ ਕਰਨਾ ਹੈ. ਚਿੱਪਾਂ ਨੂੰ ਹੁਣ ਮੁੱਖ ਤੌਰ 'ਤੇ SSOP24 ਪੈਕੇਜ ਵਿੱਚ ਪੇਸ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ; ਉਹਨਾਂ ਨੂੰ ਅਡਾਪਟਰ ਵਿੱਚ ਸੋਲਡ ਕਰਨਾ ਆਸਾਨ ਹੁੰਦਾ ਹੈ।

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

ਡੀਸੀ ਸਿੰਕ ਸਰੋਤ (ਓਪਨ ਡਰੇਨ)

ਡੁੱਬਣਾ / ਓਪਨ-ਡਰੇਨ ਆਉਟਪੁੱਟ - ਨਿਕਾਸ; ਪ੍ਰਵਾਹ ਕਰੰਟ ਦਾ ਸਰੋਤ; ਆਉਟਪੁੱਟ ਸਰਗਰਮ ਸਥਿਤੀ ਵਿੱਚ ਜ਼ਮੀਨ ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ - LEDs ਕੈਥੋਡ ਦੁਆਰਾ ਡਰਾਈਵਰ ਨਾਲ ਜੁੜੇ ਹੋਏ ਹਨ. ਬਿਜਲਈ ਤੌਰ 'ਤੇ, ਇਹ, ਬੇਸ਼ੱਕ, "ਖੁੱਲ੍ਹਾ ਡਰੇਨ" ਨਹੀਂ ਹੈ (ਖੁੱਲ੍ਹੀ ਨਾਲੀ), ਪਰ ਡੈਟਾਸ਼ੀਟਾਂ ਵਿੱਚ ਡਰੇਨ ਮੋਡ ਵਿੱਚ ਪਿੰਨਾਂ ਲਈ ਇਹ ਅਹੁਦਾ ਅਕਸਰ ਪਾਇਆ ਜਾਂਦਾ ਹੈ।

ਆਉਟਪੁੱਟ ਮੌਜੂਦਾ ਮੁੱਲ ਨੂੰ ਸੈੱਟ ਕਰਨ ਲਈ REXT ਅਤੇ GND ਵਿਚਕਾਰ ਬਾਹਰੀ ਰੋਧਕ

REXT ਪਿੰਨ ਅਤੇ ਜ਼ਮੀਨ ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਸੰਦਰਭ ਰੋਧਕ ਸਥਾਪਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਜੋ ਕਿ ਆਉਟਪੁੱਟ ਦੇ ਅੰਦਰੂਨੀ ਵਿਰੋਧ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦਾ ਹੈ, ਡੇਟਾਸ਼ੀਟ ਦੇ ਪੰਨਾ 9 'ਤੇ ਗ੍ਰਾਫ ਵੇਖੋ। DM634 ਵਿੱਚ, ਇਸ ਪ੍ਰਤੀਰੋਧ ਨੂੰ ਸੌਫਟਵੇਅਰ ਦੁਆਰਾ ਵੀ ਨਿਯੰਤਰਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਸਮੁੱਚੀ ਚਮਕ (ਗਲੋਬਲ ਚਮਕ); ਮੈਂ ਇਸ ਲੇਖ ਵਿੱਚ ਵੇਰਵਿਆਂ ਵਿੱਚ ਨਹੀਂ ਜਾਵਾਂਗਾ, ਮੈਂ ਇੱਥੇ ਇੱਕ 2.2 - 3 kOhm ਰੋਧਕ ਪਾਵਾਂਗਾ।

ਇਹ ਸਮਝਣ ਲਈ ਕਿ ਚਿੱਪ ਨੂੰ ਕਿਵੇਂ ਨਿਯੰਤਰਿਤ ਕਰਨਾ ਹੈ, ਆਓ ਡਿਵਾਈਸ ਇੰਟਰਫੇਸ ਦੇ ਵਰਣਨ ਨੂੰ ਵੇਖੀਏ:

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

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

ਲੰਚ - ਲੈਚ/ਲੈਚ/ਲਾਕ।
ਵਧ ਰਿਹਾ ਕਿਨਾਰਾ - ਨਬਜ਼ ਦੇ ਮੋਹਰੀ ਕਿਨਾਰੇ
MSB ਪਹਿਲਾਂ - ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ (ਖੱਬੇ ਪਾਸੇ) ਬਿੱਟ ਅੱਗੇ।
ਡਾਟਾ ਘੜੀ ਕਰਨ ਲਈ - ਕ੍ਰਮਵਾਰ ਡੇਟਾ ਸੰਚਾਰਿਤ ਕਰੋ (ਬਿੱਟ-ਬਿੱਟ)।

ਸ਼ਬਦ ਨੂੰ ਲੱਕ ਅਕਸਰ ਚਿਪਸ ਲਈ ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਪਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਨਾਲ ਅਨੁਵਾਦ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਇਸਲਈ ਸਮਝ ਲਈ ਮੈਂ ਆਪਣੇ ਆਪ ਨੂੰ ਇਜਾਜ਼ਤ ਦੇਵਾਂਗਾ

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

ਇਸ ਲਈ, DM634 ਨੂੰ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਇਸ ਤਰ੍ਹਾਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ: DAI ਇੰਪੁੱਟ ਨੂੰ ਦੂਰ LED ਦੇ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਬਿੱਟ ਦੇ ਮੁੱਲ 'ਤੇ ਸੈੱਟ ਕਰੋ, DCK ਨੂੰ ਉੱਪਰ ਅਤੇ ਹੇਠਾਂ ਖਿੱਚੋ; DAI ਇੰਪੁੱਟ ਨੂੰ ਅਗਲੇ ਬਿੱਟ ਦੇ ਮੁੱਲ 'ਤੇ ਸੈੱਟ ਕਰੋ, DCK ਖਿੱਚੋ; ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਉਦੋਂ ਤੱਕ ਜਦੋਂ ਤੱਕ ਸਾਰੇ ਬਿੱਟ ਪ੍ਰਸਾਰਿਤ ਨਹੀਂ ਹੋ ਜਾਂਦੇ (ਅੰਦਰ ਬੰਦ), ਜਿਸ ਤੋਂ ਬਾਅਦ ਅਸੀਂ LAT ਨੂੰ ਖਿੱਚਦੇ ਹਾਂ। ਇਹ ਹੱਥੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ (ਬਿੱਟ-ਬੈਂਗ), ਪਰ ਇਸਦੇ ਲਈ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਤਿਆਰ ਕੀਤੇ ਗਏ SPI ਇੰਟਰਫੇਸ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਬਿਹਤਰ ਹੈ, ਕਿਉਂਕਿ ਇਹ ਸਾਡੇ STM32 'ਤੇ ਦੋ ਕਾਪੀਆਂ ਵਿੱਚ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ ਹੈ।

ਨੀਲੀ ਗੋਲੀ STM32F103

ਸ਼ੁਰੂਆਤੀ: STM32 ਕੰਟਰੋਲਰ Atmega328 ਨਾਲੋਂ ਬਹੁਤ ਜ਼ਿਆਦਾ ਗੁੰਝਲਦਾਰ ਹਨ ਜਿੰਨਾ ਕਿ ਉਹ ਡਰਾਉਣੇ ਲੱਗ ਸਕਦੇ ਹਨ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਊਰਜਾ ਬਚਾਉਣ ਦੇ ਕਾਰਨਾਂ ਕਰਕੇ, ਲਗਭਗ ਸਾਰੇ ਪੈਰੀਫਿਰਲ ਸ਼ੁਰੂ ਵਿੱਚ ਬੰਦ ਹੋ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਘੜੀ ਦੀ ਬਾਰੰਬਾਰਤਾ ਅੰਦਰੂਨੀ ਸਰੋਤ ਤੋਂ 8 MHz ਹੈ। ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, STM ਪ੍ਰੋਗਰਾਮਰਾਂ ਨੇ ਕੋਡ ਲਿਖਿਆ ਜੋ ਚਿਪ ਨੂੰ "ਗਣਿਤ" 72 MHz ਤੱਕ ਲਿਆਉਂਦਾ ਹੈ, ਅਤੇ ਸਾਰੇ IDEs ਦੇ ਲੇਖਕ ਜਿਨ੍ਹਾਂ ਨੂੰ ਮੈਂ ਜਾਣਦਾ ਹਾਂ, ਨੇ ਇਸਨੂੰ ਸ਼ੁਰੂਆਤੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਹੈ, ਇਸ ਲਈ ਸਾਨੂੰ ਘੜੀ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ (ਪਰ ਜੇਕਰ ਤੁਸੀਂ ਸੱਚਮੁੱਚ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ਤੁਸੀਂ ਕਰ ਸਕਦੇ ਹੋ). ਪਰ ਤੁਹਾਨੂੰ ਪੈਰੀਫਿਰਲ ਚਾਲੂ ਕਰਨੇ ਪੈਣਗੇ।

ਦਸਤਾਵੇਜ਼: ਬਲੂ ਪਿਲ ਪ੍ਰਸਿੱਧ STM32F103C8T6 ਚਿੱਪ ਨਾਲ ਲੈਸ ਹੈ, ਇਸਦੇ ਲਈ ਦੋ ਉਪਯੋਗੀ ਦਸਤਾਵੇਜ਼ ਹਨ:

• ਡਾਟਾ ਸ਼ੀਟ ਮਾਈਕ੍ਰੋਕੰਟਰੋਲਰ STM32F103x8 ਅਤੇ STM32F103xB ਲਈ;
• ਹਵਾਲਾ ਮੈਨੂਅਲ ਪੂਰੀ STM32F103 ਲਾਈਨ ਅਤੇ ਹੋਰ ਲਈ।

ਡੇਟਾਸ਼ੀਟ ਵਿੱਚ ਸਾਡੀ ਦਿਲਚਸਪੀ ਹੋ ਸਕਦੀ ਹੈ:

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

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

ਅਸੀਂ ਡੇਟਾਸ਼ੀਟ ਨੂੰ ਹਟਾਉਂਦੇ ਹਾਂ, ਹਵਾਲਾ ਮੈਨੂਅਲ ਖੋਲ੍ਹਦੇ ਹਾਂ, ਅਤੇ ਹੁਣ ਤੋਂ ਅਸੀਂ ਸਿਰਫ਼ ਇਸਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ।
ਵਿਧੀ: ਅਸੀਂ ਮਿਆਰੀ ਇਨਪੁਟ/ਆਊਟਪੁੱਟ ਨਾਲ ਨਜਿੱਠਦੇ ਹਾਂ, SPI ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਦੇ ਹਾਂ, ਲੋੜੀਂਦੇ ਪੈਰੀਫਿਰਲਾਂ ਨੂੰ ਚਾਲੂ ਕਰਦੇ ਹਾਂ।

ਇਨਪੁਟ ਆਉਟਪੁੱਟ

Atmega328 'ਤੇ, I/O ਨੂੰ ਬਹੁਤ ਹੀ ਸਰਲ ਢੰਗ ਨਾਲ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ, ਇਸੇ ਕਰਕੇ STM32 ਵਿਕਲਪਾਂ ਦੀ ਬਹੁਤਾਤ ਉਲਝਣ ਵਾਲੀ ਹੋ ਸਕਦੀ ਹੈ। ਹੁਣ ਸਾਨੂੰ ਸਿਰਫ਼ ਸਿੱਟਿਆਂ ਦੀ ਲੋੜ ਹੈ, ਪਰ ਇਹਨਾਂ ਕੋਲ ਚਾਰ ਵਿਕਲਪ ਹਨ:

ਓਪਨ ਡਰੇਨ, ਪੁਸ਼-ਪੁੱਲ, ਵਿਕਲਪਕ ਪੁਸ਼-ਪੁੱਲ, ਵਿਕਲਪਕ ਓਪਨ ਡਰੇਨ

"ਪੁੱਲ-ਪੁਸ਼" (ਧੱਕਾ-ਖਿੱਚਣਾ) Arduino ਤੋਂ ਆਮ ਆਉਟਪੁੱਟ ਹੈ, ਪਿੰਨ ਮੁੱਲ ਨੂੰ ਉੱਚ ਜਾਂ ਘੱਟ ਲੈ ਸਕਦਾ ਹੈ। ਪਰ "ਓਪਨ ਡਰੇਨ" ਦੇ ਨਾਲ ਹਨ ਮੁਸ਼ਕਿਲਾਂ, ਹਾਲਾਂਕਿ ਅਸਲ ਵਿੱਚ ਇੱਥੇ ਸਭ ਕੁਝ ਸਧਾਰਨ ਹੈ:

ਆਉਟਪੁੱਟ ਕੌਂਫਿਗਰੇਸ਼ਨ / ਜਦੋਂ ਪੋਰਟ ਨੂੰ ਆਉਟਪੁੱਟ ਲਈ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ: / ਆਉਟਪੁੱਟ ਬਫਰ ਸਮਰੱਥ: / - ਓਪਨ ਡਰੇਨ ਮੋਡ: ਆਉਟਪੁੱਟ ਰਜਿਸਟਰ ਵਿੱਚ "0" N-MOS ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ, ਆਉਟਪੁੱਟ ਰਜਿਸਟਰ ਵਿੱਚ "1" ਪੋਰਟ ਨੂੰ Hi-Z ਮੋਡ ਵਿੱਚ ਛੱਡ ਦਿੰਦਾ ਹੈ ( P-MOS ਸਰਗਰਮ ਨਹੀਂ ਹੈ ) / – ਪੁਸ਼-ਪੁੱਲ ਮੋਡ: ਆਉਟਪੁੱਟ ਰਜਿਸਟਰ ਵਿੱਚ "0" N-MOS ਨੂੰ ਸਰਗਰਮ ਕਰਦਾ ਹੈ, ਆਉਟਪੁੱਟ ਰਜਿਸਟਰ ਵਿੱਚ "1" P-MOS ਨੂੰ ਸਰਗਰਮ ਕਰਦਾ ਹੈ।

ਖੁੱਲੇ ਡਰੇਨ ਦੇ ਵਿਚਕਾਰ ਸਾਰੇ ਅੰਤਰ (ਖੁੱਲ੍ਹੀ ਨਾਲੀ) "ਪੁਸ਼-ਪੁੱਲ" ਤੋਂ (ਧੱਕਾ-ਖਿੱਚਣਾ(ਉੱਚ ਰੁਕਾਵਟ, ਹਾਇ-ਜ਼ੈਡ). ਜ਼ੀਰੋ ਲਿਖਣ ਵੇਲੇ, ਪਿੰਨ ਦੋਨਾਂ ਮੋਡਾਂ ਵਿੱਚ, ਤਰਕ ਅਤੇ ਇਲੈਕਟ੍ਰਿਕ ਤੌਰ 'ਤੇ ਇੱਕੋ ਜਿਹਾ ਵਿਹਾਰ ਕਰਦਾ ਹੈ।

ਆਮ ਆਉਟਪੁੱਟ ਮੋਡ ਵਿੱਚ, ਪਿੰਨ ਸਿਰਫ਼ ਆਉਟਪੁੱਟ ਰਜਿਸਟਰ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਪ੍ਰਸਾਰਿਤ ਕਰਦਾ ਹੈ। "ਵਿਕਲਪਕ" ਵਿੱਚ ਇਸ ਨੂੰ ਸੰਬੰਧਿਤ ਪੈਰੀਫਿਰਲ ਦੁਆਰਾ ਨਿਯੰਤਰਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ (ਦੇਖੋ 9.1.4):

ਜੇਕਰ ਇੱਕ ਪੋਰਟ ਬਿੱਟ ਇੱਕ ਵਿਕਲਪਿਕ ਫੰਕਸ਼ਨ ਪਿੰਨ ਦੇ ਤੌਰ ਤੇ ਕੌਂਫਿਗਰ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਪਿੰਨ ਰਜਿਸਟਰ ਅਯੋਗ ਹੈ ਅਤੇ ਪਿੰਨ ਪੈਰੀਫਿਰਲ ਪਿੰਨ ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ।

ਹਰੇਕ ਪਿੰਨ ਦੀ ਵਿਕਲਪਿਕ ਕਾਰਜਕੁਸ਼ਲਤਾ ਵਿੱਚ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ ਪਿੰਨ ਪਰਿਭਾਸ਼ਾ ਡਾਟਾਸ਼ੀਟ ਡਾਊਨਲੋਡ ਕੀਤੀ ਤਸਵੀਰ 'ਤੇ ਹੈ। ਇਸ ਸਵਾਲ ਦਾ ਕਿ ਕੀ ਕਰਨਾ ਹੈ ਜੇਕਰ ਇੱਕ ਪਿੰਨ ਵਿੱਚ ਕਈ ਵਿਕਲਪਿਕ ਫੰਕਸ਼ਨ ਹਨ, ਜਵਾਬ ਡੇਟਾਸ਼ੀਟ ਵਿੱਚ ਇੱਕ ਫੁਟਨੋਟ ਦੁਆਰਾ ਦਿੱਤਾ ਗਿਆ ਹੈ:

ਜੇਕਰ ਮਲਟੀਪਲ ਪੈਰੀਫਿਰਲ ਇੱਕੋ ਪਿੰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ, ਤਾਂ ਵਿਕਲਪਕ ਫੰਕਸ਼ਨਾਂ ਵਿਚਕਾਰ ਟਕਰਾਅ ਤੋਂ ਬਚਣ ਲਈ, ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਸਿਰਫ਼ ਇੱਕ ਪੈਰੀਫਿਰਲ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ, ਪੈਰੀਫਿਰਲ ਕਲਾਕ ਇਨੇਬਲ ਬਿੱਟ (ਉਚਿਤ RCC ਰਜਿਸਟਰ ਵਿੱਚ) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਟੌਗਲ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

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

ਇਸ ਲਈ: ਅਸੀਂ SPI ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਦੋ ਪਿੰਨ (ਡੇਟਾ ਅਤੇ ਇੱਕ ਘੜੀ ਸਿਗਨਲ ਦੇ ਨਾਲ) "ਵਿਕਲਪਕ ਪੁਸ਼-ਪੁੱਲ ਫੰਕਸ਼ਨ" ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ, ਅਤੇ ਇੱਕ ਹੋਰ (LAT) "ਰੈਗੂਲਰ ਪੁਸ਼-ਪੁੱਲ" ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ। ਪਰ ਉਹਨਾਂ ਨੂੰ ਸੌਂਪਣ ਤੋਂ ਪਹਿਲਾਂ, ਆਓ SPI ਨਾਲ ਨਜਿੱਠੀਏ.

SPI

ਇੱਕ ਹੋਰ ਛੋਟਾ ਵਿਦਿਅਕ ਪ੍ਰੋਗਰਾਮ

SPI ਜਾਂ ਸੀਰੀਅਲ ਪੈਰੀਫਿਰਲ ਇੰਟਰਫੇਸ (ਸੀਰੀਅਲ ਪੈਰੀਫਿਰਲ ਇੰਟਰਫੇਸ) ਇੱਕ MK ਨੂੰ ਦੂਜੇ MK ਅਤੇ ਆਮ ਤੌਰ 'ਤੇ ਬਾਹਰੀ ਦੁਨੀਆ ਨਾਲ ਜੋੜਨ ਲਈ ਇੱਕ ਸਧਾਰਨ ਅਤੇ ਬਹੁਤ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਇੰਟਰਫੇਸ ਹੈ। ਇਸਦੇ ਸੰਚਾਲਨ ਦਾ ਸਿਧਾਂਤ ਪਹਿਲਾਂ ਹੀ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਜਿੱਥੇ ਚੀਨੀ LED ਡਰਾਈਵਰ ਬਾਰੇ (ਹਵਾਲਾ ਮੈਨੂਅਲ ਵਿੱਚ, ਸੈਕਸ਼ਨ 25 ਦੇਖੋ). SPI ਮਾਸਟਰ (“ਮਾਸਟਰ”) ਅਤੇ ਸਲੇਵ (“ਗੁਲਾਮ”) ਮੋਡ ਵਿੱਚ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ। SPI ਦੇ ਚਾਰ ਬੁਨਿਆਦੀ ਚੈਨਲ ਹਨ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਸਾਰੇ ਵਰਤੇ ਨਹੀਂ ਜਾ ਸਕਦੇ:

• MOSI, ਮਾਸਟਰ ਆਉਟਪੁੱਟ / ਸਲੇਵ ਇਨਪੁਟ: ਇਹ ਪਿੰਨ ਮਾਸਟਰ ਮੋਡ ਵਿੱਚ ਡੇਟਾ ਸੰਚਾਰਿਤ ਕਰਦਾ ਹੈ, ਅਤੇ ਸਲੇਵ ਮੋਡ ਵਿੱਚ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ;
• MISO, ਮਾਸਟਰ ਇਨਪੁਟ / ਸਲੇਵ ਆਉਟਪੁੱਟ: ਇਸਦੇ ਉਲਟ, ਇਹ ਮਾਸਟਰ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਅਤੇ ਸਲੇਵ ਵਿੱਚ ਸੰਚਾਰਿਤ ਕਰਦਾ ਹੈ;
• SCK, ਸੀਰੀਅਲ ਕਲਾਕ: ਮਾਸਟਰ ਵਿੱਚ ਡੇਟਾ ਪ੍ਰਸਾਰਣ ਦੀ ਬਾਰੰਬਾਰਤਾ ਸੈਟ ਕਰਦਾ ਹੈ ਜਾਂ ਸਲੇਵ ਵਿੱਚ ਇੱਕ ਘੜੀ ਸਿਗਨਲ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ। ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਧੜਕਣ;
• SS, ਸਲੇਵ ਸਿਲੈਕਟ: ਇਸ ਚੈਨਲ ਦੀ ਮਦਦ ਨਾਲ, ਨੌਕਰ ਜਾਣਦਾ ਹੈ ਕਿ ਉਸ ਤੋਂ ਕੁਝ ਚਾਹੀਦਾ ਹੈ। STM32 'ਤੇ ਇਸਨੂੰ NSS ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਜਿੱਥੇ N = ਨੈਗੇਟਿਵ, i.e. ਕੰਟਰੋਲਰ ਇੱਕ ਗੁਲਾਮ ਬਣ ਜਾਂਦਾ ਹੈ ਜੇਕਰ ਇਸ ਚੈਨਲ ਵਿੱਚ ਜ਼ਮੀਨ ਹੈ। ਇਹ ਓਪਨ ਡਰੇਨ ਆਉਟਪੁੱਟ ਮੋਡ ਨਾਲ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜੋੜਦਾ ਹੈ, ਪਰ ਇਹ ਇਕ ਹੋਰ ਕਹਾਣੀ ਹੈ।

ਹਰ ਚੀਜ਼ ਦੀ ਤਰ੍ਹਾਂ, STM32 'ਤੇ SPI ਕਾਰਜਸ਼ੀਲਤਾ ਵਿੱਚ ਅਮੀਰ ਹੈ, ਜੋ ਇਸਨੂੰ ਸਮਝਣਾ ਕੁਝ ਮੁਸ਼ਕਲ ਬਣਾਉਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇਹ ਨਾ ਸਿਰਫ਼ SPI ਨਾਲ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ, ਸਗੋਂ ਇੱਕ I2S ਇੰਟਰਫੇਸ ਨਾਲ ਵੀ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਉਹਨਾਂ ਦੇ ਵਰਣਨ ਨੂੰ ਮਿਲਾਇਆ ਗਿਆ ਹੈ, ਸਮੇਂ ਸਿਰ ਵਾਧੂ ਨੂੰ ਕੱਟਣਾ ਜ਼ਰੂਰੀ ਹੈ. ਸਾਡਾ ਕੰਮ ਬਹੁਤ ਹੀ ਸਧਾਰਨ ਹੈ: ਸਾਨੂੰ ਸਿਰਫ਼ MOSI ਅਤੇ SCK ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਡਾਟਾ ਭੇਜਣ ਦੀ ਲੋੜ ਹੈ। ਅਸੀਂ ਸੈਕਸ਼ਨ 25.3.4 (ਅੱਧਾ-ਡੁਪਲੈਕਸ ਸੰਚਾਰ, ਅੱਧ-ਡੁਪਲੈਕਸ ਸੰਚਾਰ) 'ਤੇ ਜਾਂਦੇ ਹਾਂ, ਜਿੱਥੇ ਅਸੀਂ ਲੱਭਦੇ ਹਾਂ 1 ਘੜੀ ਅਤੇ 1 ਯੂਨੀਡਾਇਰੈਕਸ਼ਨਲ ਡਾਟਾ ਵਾਇਰ (1 ਘੜੀ ਸਿਗਨਲ ਅਤੇ 1 ਯੂਨੀਡਾਇਰੈਕਸ਼ਨਲ ਡਾਟਾ ਸਟ੍ਰੀਮ):

ਇਸ ਮੋਡ ਵਿੱਚ, ਐਪਲੀਕੇਸ਼ਨ ਸਿਰਫ-ਪ੍ਰਸਾਰਿਤ ਜਾਂ ਸਿਰਫ-ਰਿਸੀਵ ਮੋਡ ਵਿੱਚ SPI ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ। / ਟ੍ਰਾਂਸਮਿਟ-ਓਨਲੀ ਮੋਡ ਡੁਪਲੈਕਸ ਮੋਡ ਦੇ ਸਮਾਨ ਹੈ: ਡੇਟਾ ਟ੍ਰਾਂਸਮਿਟ ਪਿੰਨ (ਮਾਸਟਰ ਮੋਡ ਵਿੱਚ MOSI ਜਾਂ ਸਲੇਵ ਮੋਡ ਵਿੱਚ MISO), ਅਤੇ ਰਿਸੀਵ ਪਿੰਨ (ਕ੍ਰਮਵਾਰ MISO ਜਾਂ MOSI) ਨੂੰ ਇੱਕ ਨਿਯਮਤ I/O ਪਿੰਨ ਵਜੋਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। . ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਸਿਰਫ Rx ਬਫਰ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ (ਜੇ ਇਸਨੂੰ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਉੱਥੇ ਕੋਈ ਟ੍ਰਾਂਸਫਰ ਡੇਟਾ ਨਹੀਂ ਹੋਵੇਗਾ)।

ਬਹੁਤ ਵਧੀਆ, MISO ਪਿੰਨ ਮੁਫ਼ਤ ਹੈ, ਆਓ LAT ਸਿਗਨਲ ਨੂੰ ਇਸ ਨਾਲ ਕਨੈਕਟ ਕਰੀਏ। ਆਉ ਸਲੇਵ ਸਿਲੈਕਟ ਨੂੰ ਵੇਖੀਏ, ਜਿਸ ਨੂੰ STM32 'ਤੇ ਪ੍ਰੋਗਰਾਮੇਟਿਕ ਤੌਰ 'ਤੇ ਨਿਯੰਤਰਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜੋ ਕਿ ਬਹੁਤ ਸੁਵਿਧਾਜਨਕ ਹੈ। ਅਸੀਂ ਸੈਕਸ਼ਨ 25.3.1 SPI ਆਮ ਵਰਣਨ ਵਿੱਚ ਉਸੇ ਨਾਮ ਦੇ ਪੈਰੇ ਪੜ੍ਹਦੇ ਹਾਂ:

ਸੌਫਟਵੇਅਰ ਕੰਟਰੋਲ NSS (SSM = 1) / ਸਲੇਵ ਚੋਣ ਜਾਣਕਾਰੀ SPI_CR1 ਰਜਿਸਟਰ ਦੇ SSI ਬਿੱਟ ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ। ਬਾਹਰੀ NSS ਪਿੰਨ ਹੋਰ ਐਪਲੀਕੇਸ਼ਨ ਲੋੜਾਂ ਲਈ ਮੁਫ਼ਤ ਰਹਿੰਦਾ ਹੈ।

ਇਹ ਰਜਿਸਟਰਾਂ ਨੂੰ ਲਿਖਣ ਦਾ ਸਮਾਂ ਹੈ. ਮੈਂ SPI2 ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ, ਡੈਟਾਸ਼ੀਟ ਵਿੱਚ ਇਸਦਾ ਅਧਾਰ ਪਤਾ ਲੱਭੋ - ਸੈਕਸ਼ਨ 3.3 ਮੈਮੋਰੀ ਮੈਪ ਵਿੱਚ:

ਖੈਰ, ਆਓ ਸ਼ੁਰੂ ਕਰੀਏ:

#define _SPI2_(mem_offset) (*(volatile uint32_t *)(0x40003800 + (mem_offset)))

ਸੈਕਸ਼ਨ 25.3.3 ਨੂੰ ਸਵੈ-ਵਿਆਖਿਆਤਮਕ ਸਿਰਲੇਖ "ਮਾਸਟਰ ਮੋਡ ਵਿੱਚ SPI ਦੀ ਸੰਰਚਨਾ" ਨਾਲ ਖੋਲ੍ਹੋ:

1. SPI_CR2 ਰਜਿਸਟਰ ਵਿੱਚ ਬਿੱਟ BR[0:1] ਨਾਲ ਸੀਰੀਅਲ ਕਲਾਕ ਬਾਰੰਬਾਰਤਾ ਸੈਟ ਕਰੋ।

ਰਜਿਸਟਰਾਂ ਨੂੰ ਉਸੇ ਨਾਮ ਦੇ ਹਵਾਲਾ ਮੈਨੂਅਲ ਭਾਗ ਵਿੱਚ ਇਕੱਠਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਪਤਾ ਸ਼ਿਫਟ (ਪਤਾ ਆਫਸੈੱਟ) CR1 - 0x00 ਲਈ, ਮੂਲ ਰੂਪ ਵਿੱਚ ਸਾਰੇ ਬਿੱਟ ਕਲੀਅਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ (ਮੁੱਲ ਰੀਸੈਟ ਕਰੋ 0x0000):

BR ਬਿੱਟ ਕੰਟਰੋਲਰ ਕਲਾਕ ਡਿਵਾਈਡਰ ਨੂੰ ਸੈੱਟ ਕਰਦੇ ਹਨ, ਇਸ ਤਰ੍ਹਾਂ ਇਹ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਨ ਕਿ SPI ਕਿਸ 'ਤੇ ਕੰਮ ਕਰੇਗਾ। ਸਾਡੀ STM32 ਫ੍ਰੀਕੁਐਂਸੀ 72 MHz ਹੋਵੇਗੀ, LED ਡ੍ਰਾਈਵਰ, ਇਸਦੇ ਡੇਟਾਸ਼ੀਟ ਦੇ ਅਨੁਸਾਰ, 25 MHz ਤੱਕ ਦੀ ਬਾਰੰਬਾਰਤਾ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ, ਇਸਲਈ ਸਾਨੂੰ ਚਾਰ (BR[2:0] = 001) ਨਾਲ ਵੰਡਣ ਦੀ ਲੋੜ ਹੈ।

#define _SPI_CR1 0x00

#define BR_0        0x0008
#define BR_1        0x0010
#define BR_2        0x0020

_SPI2_ (_SPI_CR1) |= BR_0;// pclk/4

2. ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ ਅਤੇ ਸੀਰੀਅਲ ਕਲਾਕ ਟਾਈਮਿੰਗ ਵਿਚਕਾਰ ਸਬੰਧ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ CPOL ਅਤੇ CPHA ਬਿੱਟ ਸੈੱਟ ਕਰੋ (ਪੰਨਾ 240 'ਤੇ ਚਿੱਤਰ ਦੇਖੋ)

ਕਿਉਂਕਿ ਅਸੀਂ ਇੱਥੇ ਇੱਕ ਡੈਟਾਸ਼ੀਟ ਪੜ੍ਹ ਰਹੇ ਹਾਂ ਅਤੇ ਯੋਜਨਾਬੰਦੀ ਨੂੰ ਨਹੀਂ ਦੇਖ ਰਹੇ ਹਾਂ, ਆਓ ਪੰਨਾ 704 (SPI ਜਨਰਲ ਵਰਣਨ) 'ਤੇ CPOL ਅਤੇ CPHA ਬਿੱਟਾਂ ਦੇ ਟੈਕਸਟ ਵਰਣਨ 'ਤੇ ਇੱਕ ਡੂੰਘਾਈ ਨਾਲ ਵਿਚਾਰ ਕਰੀਏ:

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

ਇਸ ਗਿਆਨ ਨੂੰ ਜਜ਼ਬ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਇਸ ਸਿੱਟੇ 'ਤੇ ਪਹੁੰਚਦੇ ਹਾਂ ਕਿ ਦੋਵੇਂ ਬਿੱਟ ਜ਼ੀਰੋ ਹੀ ਰਹਿਣੇ ਚਾਹੀਦੇ ਹਨ, ਕਿਉਂਕਿ ਅਸੀਂ ਚਾਹੁੰਦੇ ਹਾਂ ਕਿ ਵਰਤੋਂ ਵਿੱਚ ਨਾ ਹੋਣ 'ਤੇ SCK ਸਿਗਨਲ ਘੱਟ ਰਹੇ, ਅਤੇ ਨਬਜ਼ ਦੇ ਵਧਦੇ ਕਿਨਾਰੇ 'ਤੇ ਡੇਟਾ ਨੂੰ ਪ੍ਰਸਾਰਿਤ ਕੀਤਾ ਜਾਵੇ (ਚਿੱਤਰ XNUMX ਦੇਖੋ। ਰਾਈਜ਼ਿੰਗ ਐਜ DM634 ਡੇਟਾਸ਼ੀਟ ਵਿੱਚ)।

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

3. ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ DFF ਬਿੱਟ ਸੈੱਟ ਕਰੋ ਕਿ ਡੇਟਾ ਬਲਾਕ 8-ਬਿੱਟ ਜਾਂ 16-ਬਿੱਟ ਫਾਰਮੈਟ ਹੈ

ਮੈਂ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਇੱਕ 16-ਬਿੱਟ DM634 ਲਿਆ ਤਾਂ ਜੋ DM12 ਵਾਂਗ 633-ਬਿੱਟ PWM ਡੇਟਾ ਨੂੰ ਸੰਚਾਰਿਤ ਕਰਨ ਵਿੱਚ ਪਰੇਸ਼ਾਨ ਨਾ ਹੋਵੇ। DFF ਨੂੰ ਇੱਕ 'ਤੇ ਸੈੱਟ ਕਰਨਾ ਸਮਝਦਾਰ ਹੈ:

#define DFF         0x0800

_SPI2_ (_SPI_CR1) |= DFF; // 16-bit mode

4. ਬਲਾਕ ਫਾਰਮੈਟ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ SPI_CR1 ਰਜਿਸਟਰ ਵਿੱਚ LSBFIRST ਬਿੱਟ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰੋ

LSBFIRST, ਜਿਵੇਂ ਕਿ ਇਸਦਾ ਨਾਮ ਦਰਸਾਉਂਦਾ ਹੈ, ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਘੱਟ ਮਹੱਤਵਪੂਰਨ ਬਿੱਟ ਨਾਲ ਟ੍ਰਾਂਸਮਿਸ਼ਨ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਦਾ ਹੈ। ਪਰ DM634 ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਬਿੱਟ ਤੋਂ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋਏ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹੈ। ਇਸ ਲਈ, ਅਸੀਂ ਇਸਨੂੰ ਰੀਸੈਟ ਛੱਡ ਦਿੰਦੇ ਹਾਂ.

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

NSS ਹਾਰਡਵੇਅਰ ਮੋਡ ਨੂੰ ਭੁੱਲਣ ਲਈ SSM ਅਤੇ SSI ਸਥਾਪਿਤ ਕਰੋ:

#define SSI         0x0100
#define SSM         0x0200

_SPI2_ (_SPI_CR1) |= SSM | SSI; //enable software control of SS, SS high

6. MSTR ਅਤੇ SPE ਬਿੱਟ ਸੈੱਟ ਕੀਤੇ ਜਾਣੇ ਚਾਹੀਦੇ ਹਨ (ਉਹ ਸਿਰਫ਼ ਉਦੋਂ ਹੀ ਸੈੱਟ ਰਹਿੰਦੇ ਹਨ ਜੇਕਰ NSS ਸਿਗਨਲ ਉੱਚਾ ਹੋਵੇ)

ਅਸਲ ਵਿੱਚ, ਇਹਨਾਂ ਬਿੱਟਾਂ ਦੇ ਨਾਲ ਅਸੀਂ ਆਪਣੇ SPI ਨੂੰ ਇੱਕ ਮਾਸਟਰ ਵਜੋਂ ਮਨੋਨੀਤ ਕਰਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਚਾਲੂ ਕਰਦੇ ਹਾਂ:

#define MSTR        0x0004
#define SPE         0x0040

_SPI2_ (_SPI_CR1) |= MSTR; //SPI master
//когда все готово, включаем SPI
_SPI2_ (_SPI_CR1) |= SPE;

SPI ਕੌਂਫਿਗਰ ਕੀਤਾ ਗਿਆ ਹੈ, ਆਓ ਤੁਰੰਤ ਫੰਕਸ਼ਨ ਲਿਖੀਏ ਜੋ ਡਰਾਈਵਰ ਨੂੰ ਬਾਈਟ ਭੇਜਦੇ ਹਨ। 25.3.3 ਨੂੰ ਪੜ੍ਹਨਾ ਜਾਰੀ ਰੱਖੋ “ਮਾਸਟਰ ਮੋਡ ਵਿੱਚ SPI ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨਾ”:

ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ ਆਰਡਰ
ਟ੍ਰਾਂਸਮਿਸ਼ਨ ਉਦੋਂ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਇੱਕ ਬਾਈਟ ਨੂੰ Tx ਬਫਰ ਵਿੱਚ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ।
ਡੇਟਾ ਬਾਈਟ ਨੂੰ ਸ਼ਿਫਟ ਰਜਿਸਟਰ ਵਿੱਚ ਲੋਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਸਮਾਨਾਂਤਰ ਮੋਡ (ਅੰਦਰੂਨੀ ਬੱਸ ਤੋਂ) ਪਹਿਲੇ ਬਿੱਟ ਦੇ ਪ੍ਰਸਾਰਣ ਦੇ ਦੌਰਾਨ, ਜਿਸ ਤੋਂ ਬਾਅਦ ਇਸਨੂੰ ਪ੍ਰਸਾਰਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਕ੍ਰਮਵਾਰ MOSI ਪਿੰਨ ਮੋਡ, CPI_CR1 ਰਜਿਸਟਰ ਵਿੱਚ LSBFIRST ਬਿੱਟ ਦੀ ਸੈਟਿੰਗ ਦੇ ਆਧਾਰ 'ਤੇ ਪਹਿਲਾਂ ਜਾਂ ਆਖਰੀ ਬਿੱਟ ਅੱਗੇ। TXE ਫਲੈਗ ਡਾਟਾ ਸੰਚਾਰ ਦੇ ਬਾਅਦ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ Tx ਬਫਰ ਤੋਂ ਸ਼ਿਫਟ ਰਜਿਸਟਰ ਤੱਕ, ਅਤੇ ਇਹ ਵੀ ਇੱਕ ਰੁਕਾਵਟ ਪੈਦਾ ਕਰਦਾ ਹੈ ਜੇਕਰ CPI_CR1 ਰਜਿਸਟਰ ਵਿੱਚ TXEIE ਬਿੱਟ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ।

ਮੈਂ STM ਕੰਟਰੋਲਰਾਂ ਵਿੱਚ SPI ਲਾਗੂ ਕਰਨ ਦੀ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਵੱਲ ਧਿਆਨ ਖਿੱਚਣ ਲਈ ਅਨੁਵਾਦ ਵਿੱਚ ਕੁਝ ਸ਼ਬਦਾਂ ਨੂੰ ਉਜਾਗਰ ਕੀਤਾ ਹੈ। ਐਟਮੇਗਾ 'ਤੇ TXE ਝੰਡਾ (Tx ਖਾਲੀ, Tx ਖਾਲੀ ਹੈ ਅਤੇ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਤਿਆਰ ਹੈ) ਪੂਰੀ ਬਾਈਟ ਭੇਜੇ ਜਾਣ ਤੋਂ ਬਾਅਦ ਹੀ ਸੈੱਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਬਾਹਰ. ਅਤੇ ਇੱਥੇ ਇਹ ਫਲੈਗ ਅੰਦਰੂਨੀ ਸ਼ਿਫਟ ਰਜਿਸਟਰ ਵਿੱਚ ਬਾਈਟ ਪਾਉਣ ਤੋਂ ਬਾਅਦ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ। ਕਿਉਂਕਿ ਇਹ ਉੱਥੇ ਇੱਕੋ ਸਮੇਂ (ਸਮਾਂਤਰ ਵਿੱਚ) ਸਾਰੇ ਬਿੱਟਾਂ ਦੇ ਨਾਲ ਧੱਕਿਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਫਿਰ ਡੇਟਾ ਨੂੰ ਕ੍ਰਮਵਾਰ ਟ੍ਰਾਂਸਫਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, TXE ਨੂੰ ਬਾਈਟ ਦੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਭੇਜਣ ਤੋਂ ਪਹਿਲਾਂ ਸੈੱਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਸਾਡੇ LED ਡਰਾਈਵਰ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਸਾਨੂੰ ਭੇਜਣ ਤੋਂ ਬਾਅਦ LAT ਪਿੰਨ ਨੂੰ ਖਿੱਚਣ ਦੀ ਲੋੜ ਹੈ всех ਡਾਟਾ, ਯਾਨੀ ਸਿਰਫ਼ TXE ਝੰਡਾ ਸਾਡੇ ਲਈ ਕਾਫ਼ੀ ਨਹੀਂ ਹੋਵੇਗਾ।

ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਸਾਨੂੰ ਇੱਕ ਹੋਰ ਝੰਡੇ ਦੀ ਲੋੜ ਹੈ. ਆਓ 25.3.7 - "ਸਟੇਟਸ ਫਲੈਗ" ਨੂੰ ਵੇਖੀਏ:

<…>

ਵਿਅਸਤ ਝੰਡਾ
BSY ਫਲੈਗ ਨੂੰ ਹਾਰਡਵੇਅਰ ਦੁਆਰਾ ਸੈੱਟ ਅਤੇ ਕਲੀਅਰ ਕੀਤਾ ਗਿਆ ਹੈ (ਇਸ ਨੂੰ ਲਿਖਣ ਦਾ ਕੋਈ ਪ੍ਰਭਾਵ ਨਹੀਂ ਹੈ)। BSY ਫਲੈਗ SPI ਸੰਚਾਰ ਪਰਤ ਦੀ ਸਥਿਤੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।
ਇਹ ਰੀਸੈਟ ਕਰਦਾ ਹੈ:
ਜਦੋਂ ਟ੍ਰਾਂਸਫਰ ਪੂਰਾ ਹੋ ਜਾਂਦਾ ਹੈ (ਮਾਸਟਰ ਮੋਡ ਨੂੰ ਛੱਡ ਕੇ ਜੇਕਰ ਟ੍ਰਾਂਸਫਰ ਨਿਰੰਤਰ ਹੈ)
ਜਦੋਂ SPI ਅਯੋਗ ਹੈ
ਜਦੋਂ ਇੱਕ ਮਾਸਟਰ ਮੋਡ ਗਲਤੀ ਹੁੰਦੀ ਹੈ (MODF=1)
ਜੇਕਰ ਟ੍ਰਾਂਸਫਰ ਨਿਰੰਤਰ ਨਹੀਂ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਹਰੇਕ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਦੇ ਵਿਚਕਾਰ BSY ਫਲੈਗ ਨੂੰ ਸਾਫ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ

ਠੀਕ ਹੈ, ਇਹ ਕੰਮ ਆਵੇਗਾ। ਆਓ ਇਹ ਪਤਾ ਕਰੀਏ ਕਿ Tx ਬਫਰ ਕਿੱਥੇ ਸਥਿਤ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, “SPI ਡੇਟਾ ਰਜਿਸਟਰ” ਪੜ੍ਹੋ:

ਬਿਟਸ 15:0 DR [15:0] ਡਾਟਾ ਰਜਿਸਟਰ
ਪ੍ਰਾਪਤ ਡੇਟਾ ਜਾਂ ਪ੍ਰਸਾਰਿਤ ਕੀਤਾ ਜਾਣ ਵਾਲਾ ਡੇਟਾ।
ਡੇਟਾ ਰਜਿਸਟਰ ਨੂੰ ਦੋ ਬਫਰਾਂ ਵਿੱਚ ਵੰਡਿਆ ਗਿਆ ਹੈ - ਇੱਕ ਲਿਖਣ ਲਈ (ਪ੍ਰਸਾਰਿਤ ਬਫਰ) ਅਤੇ ਇੱਕ ਪੜ੍ਹਨ ਲਈ (ਬਫਰ ਪ੍ਰਾਪਤ ਕਰੋ)। ਡਾਟਾ ਰਜਿਸਟਰ ਨੂੰ ਲਿਖਣਾ Tx ਬਫਰ ਨੂੰ ਲਿਖਦਾ ਹੈ, ਅਤੇ ਡਾਟਾ ਰਜਿਸਟਰ ਤੋਂ ਪੜ੍ਹਨਾ Rx ਬਫਰ ਵਿੱਚ ਮੌਜੂਦ ਮੁੱਲ ਵਾਪਸ ਕਰੇਗਾ।

ਖੈਰ, ਅਤੇ ਸਥਿਤੀ ਰਜਿਸਟਰ, ਜਿੱਥੇ TXE ਅਤੇ BSY ਝੰਡੇ ਮਿਲਦੇ ਹਨ:

ਅਸੀਂ ਲਿਖਦੇ ਹਾਂ:

#define _SPI_DR  0x0C
#define _SPI_SR  0x08

#define BSY         0x0080
#define TXE         0x0002

void dm_shift16(uint16_t value)
{
    _SPI2_(_SPI_DR) = value; //send 2 bytes
    while (!(_SPI2_(_SPI_SR) & TXE)); //wait until they're sent
}

ਖੈਰ, ਕਿਉਂਕਿ ਸਾਨੂੰ LED ਡਰਾਈਵਰ ਆਉਟਪੁੱਟ ਦੀ ਗਿਣਤੀ ਦੇ ਅਨੁਸਾਰ, 16 ਗੁਣਾ ਦੋ ਬਾਈਟਾਂ ਨੂੰ ਪ੍ਰਸਾਰਿਤ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ:

void sendLEDdata()
{
    LAT_low();
    uint8_t k = 16;
    do
    {   k--;
        dm_shift16(leds[k]);
    } while (k);

    while (_SPI2_(_SPI_SR) & BSY); // finish transmission

    LAT_pulse();
}

ਪਰ ਅਸੀਂ ਨਹੀਂ ਜਾਣਦੇ ਕਿ LAT ਪਿੰਨ ਨੂੰ ਕਿਵੇਂ ਖਿੱਚਣਾ ਹੈ, ਇਸ ਲਈ ਅਸੀਂ I/O 'ਤੇ ਵਾਪਸ ਜਾਵਾਂਗੇ।

ਪਿੰਨ ਨਿਰਧਾਰਤ ਕਰਨਾ

STM32F1 ਵਿੱਚ, ਪਿੰਨਾਂ ਦੀ ਸਥਿਤੀ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਰਜਿਸਟਰ ਕਾਫ਼ੀ ਅਸਾਧਾਰਨ ਹਨ। ਇਹ ਸਪੱਸ਼ਟ ਹੈ ਕਿ ਐਟਮੇਗਾ ਨਾਲੋਂ ਉਨ੍ਹਾਂ ਵਿੱਚ ਹੋਰ ਵੀ ਹਨ, ਪਰ ਉਹ ਹੋਰ ਐਸਟੀਐਮ ਚਿਪਸ ਤੋਂ ਵੀ ਵੱਖਰੇ ਹਨ। ਸੈਕਸ਼ਨ 9.1 GPIO ਦਾ ਆਮ ਵਰਣਨ:

ਆਮ ਉਦੇਸ਼ I/O ਪੋਰਟਾਂ ਵਿੱਚੋਂ ਹਰੇਕ (GPIO) ਕੋਲ ਦੋ 32-ਬਿੱਟ ਕੌਂਫਿਗਰੇਸ਼ਨ ਰਜਿਸਟਰ (GPIOx_CRL ਅਤੇ GPIOx_CRH), ਦੋ 32-ਬਿੱਟ ਡੇਟਾ ਰਜਿਸਟਰ (GPIOx_IDR ਅਤੇ GPIOx_ODR), ਇੱਕ 32-ਬਿੱਟ ਸੈੱਟ/ਰੀਸੈਟ ਰਜਿਸਟਰ (GPIOx_BSRR), ਇੱਕ 16-ਬਿੱਟ ਰੀਸੈਟ ਰਜਿਸਟਰ (GPIOx_32BR) ਅਤੇ a-XNUMXBR ਬਿੱਟ ਬਲਾਕਿੰਗ ਰਜਿਸਟਰ (GPIOx_LCKR)।

ਪਹਿਲੇ ਦੋ ਰਜਿਸਟਰ ਅਸਾਧਾਰਨ ਹਨ, ਅਤੇ ਕਾਫ਼ੀ ਅਸੁਵਿਧਾਜਨਕ ਵੀ ਹਨ, ਕਿਉਂਕਿ 16 ਪੋਰਟ ਪਿੰਨ ਉਹਨਾਂ ਵਿੱਚ "ਚਾਰ ਬਿੱਟ ਪ੍ਰਤੀ ਭਰਾ" ਫਾਰਮੈਟ ਵਿੱਚ ਖਿੰਡੇ ਹੋਏ ਹਨ। ਉਹ. ਪਿੰਨ ਜ਼ੀਰੋ ਤੋਂ ਸੱਤ CRL ਵਿੱਚ ਹਨ, ਅਤੇ ਬਾਕੀ CRH ਵਿੱਚ ਹਨ। ਉਸੇ ਸਮੇਂ, ਬਾਕੀ ਬਚੇ ਰਜਿਸਟਰਾਂ ਵਿੱਚ ਸਫਲਤਾਪੂਰਵਕ ਪੋਰਟ ਦੇ ਸਾਰੇ ਪਿੰਨਾਂ ਦੇ ਬਿੱਟ ਹੁੰਦੇ ਹਨ - ਅਕਸਰ ਅੱਧੇ "ਰਾਖਵੇਂ" ਰਹਿੰਦੇ ਹਨ।

ਸਰਲਤਾ ਲਈ, ਆਓ ਸੂਚੀ ਦੇ ਅੰਤ ਤੋਂ ਸ਼ੁਰੂ ਕਰੀਏ.

ਸਾਨੂੰ ਬਲਾਕਿੰਗ ਰਜਿਸਟਰ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।

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

ਪਰਮਾਣੂ ਸੈੱਟ ਜਾਂ ਰੀਸੈਟ
ਬਿੱਟ ਪੱਧਰ 'ਤੇ GPIOx_ODR ਪ੍ਰੋਗਰਾਮਿੰਗ ਕਰਦੇ ਸਮੇਂ ਰੁਕਾਵਟਾਂ ਨੂੰ ਅਯੋਗ ਕਰਨ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ: ਇੱਕ ਜਾਂ ਇੱਕ ਤੋਂ ਵੱਧ ਬਿੱਟਾਂ ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਐਟੋਮਿਕ ਰਾਈਟ ਓਪਰੇਸ਼ਨ APB2 ਨਾਲ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ ਉਸ ਬਿੱਟ ਦੇ ਸੈੱਟ/ਰੀਸੈਟ ਰਜਿਸਟਰ (GPIOx_BSRR ਜਾਂ, ਸਿਰਫ਼ ਰੀਸੈਟ ਲਈ, GPIOx_BRR) 'ਤੇ "1" ਲਿਖ ਕੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਿਸ ਨੂੰ ਬਦਲਣ ਦੀ ਲੋੜ ਹੈ। ਹੋਰ ਬਿੱਟਾਂ ਵਿੱਚ ਕੋਈ ਬਦਲਾਅ ਨਹੀਂ ਹੋਵੇਗਾ।

ਡੇਟਾ ਰਜਿਸਟਰਾਂ ਦੇ ਕਾਫ਼ੀ ਸਵੈ-ਵਿਆਖਿਆਤਮਕ ਨਾਮ ਹਨ - IDR = ਇੰਪੁੱਟ ਦਿਸ਼ਾ ਰਜਿਸਟਰ, ਇਨਪੁਟ ਰਜਿਸਟਰ; ODR = ਆਉਟਪੁੱਟ ਡਾਇਰੈਕਸ਼ਨ ਰਜਿਸਟਰ, ਆਉਟਪੁੱਟ ਰਜਿਸਟਰ। ਸਾਨੂੰ ਮੌਜੂਦਾ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਉਹਨਾਂ ਦੀ ਲੋੜ ਨਹੀਂ ਪਵੇਗੀ।

ਅਤੇ ਅੰਤ ਵਿੱਚ, ਕੰਟਰੋਲ ਰਜਿਸਟਰ. ਕਿਉਂਕਿ ਅਸੀਂ ਦੂਜੇ SPI ਪਿੰਨਾਂ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹਾਂ, ਅਰਥਾਤ PB13, PB14 ਅਤੇ PB15, ਅਸੀਂ ਤੁਰੰਤ CRH ਨੂੰ ਦੇਖਦੇ ਹਾਂ:

ਅਤੇ ਅਸੀਂ ਦੇਖਦੇ ਹਾਂ ਕਿ ਸਾਨੂੰ 20 ਤੋਂ 31 ਤੱਕ ਬਿੱਟਾਂ ਵਿੱਚ ਕੁਝ ਲਿਖਣ ਦੀ ਲੋੜ ਹੋਵੇਗੀ।

ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਇਹ ਪਤਾ ਲਗਾ ਲਿਆ ਹੈ ਕਿ ਅਸੀਂ ਪਿੰਨ ਤੋਂ ਕੀ ਚਾਹੁੰਦੇ ਹਾਂ, ਇਸ ਲਈ ਇੱਥੇ ਮੈਂ ਸਕ੍ਰੀਨਸ਼ੌਟ ਤੋਂ ਬਿਨਾਂ ਕਰਾਂਗਾ, ਮੈਂ ਸਿਰਫ ਇਹ ਕਹਾਂਗਾ ਕਿ MODE ਦਿਸ਼ਾ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ (ਇਨਪੁਟ ਜੇਕਰ ਦੋਵੇਂ ਬਿੱਟ 0 'ਤੇ ਸੈੱਟ ਕੀਤੇ ਗਏ ਹਨ) ਅਤੇ ਪਿੰਨ ਸਪੀਡ (ਸਾਨੂੰ 50MHz ਦੀ ਲੋੜ ਹੈ, ਯਾਨੀ. ਦੋਨੋ ਪਿੰਨ “1”), ਅਤੇ CNF ਮੋਡ ਸੈੱਟ ਕਰਦਾ ਹੈ: ਨਿਯਮਤ “ਪੁਸ਼-ਪੁੱਲ” – 00, “ਵਿਕਲਪਕ” – 10। ਮੂਲ ਰੂਪ ਵਿੱਚ, ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਉੱਪਰ ਵੇਖਦੇ ਹਾਂ, ਸਾਰੀਆਂ ਪਿੰਨਾਂ ਵਿੱਚ ਹੇਠਾਂ ਤੋਂ ਤੀਜਾ ਬਿੱਟ ਹੁੰਦਾ ਹੈ (CNF0), ਇਹ ਉਹਨਾਂ ਨੂੰ ਮੋਡ ਵਿੱਚ ਸੈੱਟ ਕਰਦਾ ਹੈ ਫਲੋਟਿੰਗ ਇੰਪੁੱਟ.

ਕਿਉਂਕਿ ਮੈਂ ਇਸ ਚਿੱਪ ਨਾਲ ਕੁਝ ਹੋਰ ਕਰਨ ਦੀ ਯੋਜਨਾ ਬਣਾ ਰਿਹਾ ਹਾਂ, ਸਾਦਗੀ ਲਈ ਮੈਂ ਹੇਠਲੇ ਅਤੇ ਉੱਪਰਲੇ ਕੰਟਰੋਲ ਰਜਿਸਟਰਾਂ ਦੋਵਾਂ ਲਈ ਸਾਰੇ ਸੰਭਵ ਮੋਡ ਅਤੇ CNF ਮੁੱਲਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਹੈ।

ਕਿਸੇ ਤਰ੍ਹਾਂ ਇਸ ਤਰ੍ਹਾਂ

#define CNF0_0 0x00000004
#define CNF0_1 0x00000008
#define CNF1_0 0x00000040
#define CNF1_1 0x00000080
#define CNF2_0 0x00000400
#define CNF2_1 0x00000800
#define CNF3_0 0x00004000
#define CNF3_1 0x00008000
#define CNF4_0 0x00040000
#define CNF4_1 0x00080000
#define CNF5_0 0x00400000
#define CNF5_1 0x00800000
#define CNF6_0 0x04000000
#define CNF6_1 0x08000000
#define CNF7_0 0x40000000
#define CNF7_1 0x80000000
#define CNF8_0 0x00000004
#define CNF8_1 0x00000008
#define CNF9_0 0x00000040
#define CNF9_1 0x00000080
#define CNF10_0 0x00000400
#define CNF10_1 0x00000800
#define CNF11_0 0x00004000
#define CNF11_1 0x00008000
#define CNF12_0 0x00040000
#define CNF12_1 0x00080000
#define CNF13_0 0x00400000
#define CNF13_1 0x00800000
#define CNF14_0 0x04000000
#define CNF14_1 0x08000000
#define CNF15_0 0x40000000
#define CNF15_1 0x80000000

#define MODE0_0 0x00000001
#define MODE0_1 0x00000002
#define MODE1_0 0x00000010
#define MODE1_1 0x00000020
#define MODE2_0 0x00000100
#define MODE2_1 0x00000200
#define MODE3_0 0x00001000
#define MODE3_1 0x00002000
#define MODE4_0 0x00010000
#define MODE4_1 0x00020000
#define MODE5_0 0x00100000
#define MODE5_1 0x00200000
#define MODE6_0 0x01000000
#define MODE6_1 0x02000000
#define MODE7_0 0x10000000
#define MODE7_1 0x20000000
#define MODE8_0 0x00000001
#define MODE8_1 0x00000002
#define MODE9_0 0x00000010
#define MODE9_1 0x00000020
#define MODE10_0 0x00000100
#define MODE10_1 0x00000200
#define MODE11_0 0x00001000
#define MODE11_1 0x00002000
#define MODE12_0 0x00010000
#define MODE12_1 0x00020000
#define MODE13_0 0x00100000
#define MODE13_1 0x00200000
#define MODE14_0 0x01000000
#define MODE14_1 0x02000000
#define MODE15_0 0x10000000
#define MODE15_1 0x20000000

ਸਾਡੇ ਪਿੰਨ ਪੋਰਟ ਬੀ (ਬੇਸ ਐਡਰੈੱਸ - 0x40010C00), ਕੋਡ 'ਤੇ ਸਥਿਤ ਹਨ:

#define _PORTB_(mem_offset) (*(volatile uint32_t *)(0x40010C00 + (mem_offset)))

#define _BRR  0x14
#define _BSRR 0x10
#define _CRL  0x00
#define _CRH  0x04

//используем стандартный SPI2: MOSI на B15, CLK на B13
//LAT пусть будет на неиспользуемом MISO – B14

//очищаем дефолтный бит, он нам точно не нужен
_PORTB_ (_CRH) &= ~(CNF15_0 | CNF14_0 | CNF13_0 | CNF12_0);

//альтернативные функции для MOSI и SCK
_PORTB_ (_CRH) |= CNF15_1 | CNF13_1;

//50 МГц, MODE = 11
_PORTB_ (_CRH) |= MODE15_1 | MODE15_0 | MODE14_1 | MODE14_0 | MODE13_1 | MODE13_0;

ਅਤੇ, ਇਸਦੇ ਅਨੁਸਾਰ, ਤੁਸੀਂ LAT ਲਈ ਪਰਿਭਾਸ਼ਾਵਾਂ ਲਿਖ ਸਕਦੇ ਹੋ, ਜੋ ਕਿ BRR ਅਤੇ BSRR ਰਜਿਸਟਰਾਂ ਦੁਆਰਾ ਮਰੋੜਿਆ ਜਾਵੇਗਾ:

/*** LAT pulse – high, then low */
#define LAT_pulse() _PORTB_(_BSRR) = (1<<14); _PORTB_(_BRR) = (1<<14)

#define LAT_low() _PORTB_(_BRR) = (1<<14)

(LAT_low ਸਿਰਫ਼ ਜੜਤਾ ਦੁਆਰਾ, ਇਹ ਹਮੇਸ਼ਾਂ ਅਜਿਹਾ ਹੁੰਦਾ ਹੈ, ਇਸਨੂੰ ਰਹਿਣ ਦਿਓ)

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

ਘੜੀ ਚਾਲੂ ਕਰੋ

ਘੜੀ, ਜਿਸ ਨੂੰ ਘੜੀ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਘੜੀ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੈ। ਅਤੇ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਸੰਖੇਪ RCC ਨੂੰ ਨੋਟ ਕਰ ਸਕਦੇ ਹਾਂ। ਅਸੀਂ ਇਸਨੂੰ ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਲੱਭਦੇ ਹਾਂ: ਇਹ ਰੀਸੈਟ ਅਤੇ ਘੜੀ ਨਿਯੰਤਰਣ ਹੈ।

ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਕਿਹਾ ਗਿਆ ਸੀ, ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, ਘੜੀ ਦੇ ਵਿਸ਼ੇ ਦਾ ਸਭ ਤੋਂ ਮੁਸ਼ਕਲ ਹਿੱਸਾ ਸਾਡੇ ਲਈ STM ਦੇ ਲੋਕਾਂ ਦੁਆਰਾ ਕੀਤਾ ਗਿਆ ਸੀ, ਜਿਸ ਲਈ ਅਸੀਂ ਉਹਨਾਂ ਦਾ ਬਹੁਤ ਧੰਨਵਾਦ ਕਰਦੇ ਹਾਂ (ਇੱਕ ਵਾਰ ਫਿਰ ਮੈਂ ਇੱਕ ਲਿੰਕ ਦੇਵਾਂਗਾ Di Halt ਦੀ ਵੈੱਬਸਾਈਟ, ਇਹ ਸਪੱਸ਼ਟ ਕਰਨ ਲਈ ਕਿ ਇਹ ਕਿੰਨਾ ਉਲਝਣ ਵਾਲਾ ਹੈ)। ਸਾਨੂੰ ਸਿਰਫ਼ ਪੈਰੀਫਿਰਲ ਕਲਾਕਿੰਗ (ਪੈਰੀਫਿਰਲ ਕਲਾਕ ਇਨੇਬਲ ਰਜਿਸਟਰਾਂ) ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਣ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਰਜਿਸਟਰਾਂ ਦੀ ਲੋੜ ਹੈ। ਪਹਿਲਾਂ, ਆਓ RCC ਦਾ ਅਧਾਰ ਪਤਾ ਲੱਭੀਏ, ਇਹ "ਮੈਮੋਰੀ ਮੈਪ" ਦੇ ਬਿਲਕੁਲ ਸ਼ੁਰੂ ਵਿੱਚ ਹੈ:

#define _RCC_(mem_offset) (*(volatile uint32_t *)(0x40021000 + (mem_offset)))

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

ਅਤੇ ਉਹਨਾਂ ਵਿੱਚ, ਇਸਦੇ ਅਨੁਸਾਰ, ਬਿੱਟ ਹੁੰਦੇ ਹਨ ਜਿਹਨਾਂ ਵਿੱਚ SPI2, IOPB (I/O ਪੋਰਟ ਬੀ) ਅਤੇ ਵਿਕਲਪਕ ਫੰਕਸ਼ਨਾਂ (AFIO) ਦੀ ਘੜੀ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ।

#define _APB2ENR 0x18
#define _APB1ENR 0x1C

#define IOPBEN 0x0008
#define SPI2EN 0x4000
#define AFIOEN 0x0001

//включаем тактирование порта B и альт. функций
_RCC_(_APB2ENR) |= IOPBEN | AFIOEN;

//включаем  тактирование SPI2
_RCC_(_APB1ENR) |= SPI2EN;

ਅੰਤਮ ਕੋਡ ਲੱਭਿਆ ਜਾ ਸਕਦਾ ਹੈ ਇੱਥੇ.

ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਟੈਸਟ ਕਰਨ ਦਾ ਮੌਕਾ ਅਤੇ ਇੱਛਾ ਹੈ, ਤਾਂ DM634 ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਕਨੈਕਟ ਕਰੋ: DAI ਤੋਂ PB15, DCK ਤੋਂ PB13, LAT ਤੋਂ PB14। ਅਸੀਂ ਡ੍ਰਾਈਵਰ ਨੂੰ 5 ਵੋਲਟਸ ਤੋਂ ਪਾਵਰ ਦਿੰਦੇ ਹਾਂ, ਆਧਾਰ ਨੂੰ ਜੋੜਨਾ ਨਾ ਭੁੱਲੋ.

STM8 PWM

STM8 'ਤੇ PWM

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

ਚਿੱਪ ਵੀ ਹੈ ਡਾਟਾ ਸ਼ੀਟ и ਹਵਾਲਾ ਮੈਨੂਅਲ RM0016, ਪਹਿਲੇ ਵਿੱਚ ਪਿਨਆਉਟ ਅਤੇ ਰਜਿਸਟਰ ਪਤੇ ਹਨ, ਦੂਜੇ ਵਿੱਚ - ਹੋਰ ਸਭ ਕੁਝ। STM8 ਨੂੰ ਇੱਕ ਭਿਆਨਕ IDE ਵਿੱਚ C ਵਿੱਚ ਪ੍ਰੋਗਰਾਮ ਕੀਤਾ ਗਿਆ ਹੈ ST ਵਿਜ਼ੂਅਲ ਡਿਵੈਲਪ.

ਕਲਾਕਿੰਗ ਅਤੇ I/O

ਮੂਲ ਰੂਪ ਵਿੱਚ, STM8 2 MHz ਦੀ ਬਾਰੰਬਾਰਤਾ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ, ਇਸ ਨੂੰ ਤੁਰੰਤ ਠੀਕ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

HSI (ਹਾਈ ਸਪੀਡ ਅੰਦਰੂਨੀ) ਘੜੀ
HSI ਕਲਾਕ ਸਿਗਨਲ ਇੱਕ ਪ੍ਰੋਗਰਾਮੇਬਲ ਡਿਵਾਈਡਰ (16 ਤੋਂ 1) ਦੇ ਨਾਲ ਇੱਕ ਅੰਦਰੂਨੀ 8 MHz RC ਔਸਿਲੇਟਰ ਤੋਂ ਲਿਆ ਗਿਆ ਹੈ। ਇਹ ਕਲਾਕ ਡਿਵਾਈਡਰ ਰਜਿਸਟਰ (CLK_CKDIVR) ਵਿੱਚ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ।
ਨੋਟ: ਸ਼ੁਰੂ ਵਿੱਚ, 8 ਦੇ ਵਿਭਾਜਕ ਦੇ ਨਾਲ ਇੱਕ HSI RC ਔਸਿਲੇਟਰ ਨੂੰ ਕਲਾਕ ਸਿਗਨਲ ਦੇ ਪ੍ਰਮੁੱਖ ਸਰੋਤ ਵਜੋਂ ਚੁਣਿਆ ਗਿਆ ਹੈ।

ਅਸੀਂ ਡੇਟਾਸ਼ੀਟ ਵਿੱਚ ਰਜਿਸਟਰ ਦਾ ਪਤਾ, ਰੈਫਮੈਨ ਵਿੱਚ ਵੇਰਵਾ ਲੱਭਦੇ ਹਾਂ ਅਤੇ ਦੇਖਦੇ ਹਾਂ ਕਿ ਰਜਿਸਟਰ ਨੂੰ ਸਾਫ਼ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:

#define CLK_CKDIVR *(volatile uint8_t *)0x0050C6

CLK_CKDIVR &= ~(0x18);

ਕਿਉਂਕਿ ਅਸੀਂ PWM ਨੂੰ ਚਲਾਉਣ ਜਾ ਰਹੇ ਹਾਂ ਅਤੇ LEDs ਨੂੰ ਜੋੜਨ ਜਾ ਰਹੇ ਹਾਂ, ਆਓ ਪਿਨਆਉਟ ਨੂੰ ਵੇਖੀਏ:

ਚਿੱਪ ਛੋਟੀ ਹੈ, ਬਹੁਤ ਸਾਰੇ ਫੰਕਸ਼ਨ ਇੱਕੋ ਪਿੰਨ 'ਤੇ ਮੁਅੱਤਲ ਕੀਤੇ ਗਏ ਹਨ. ਵਰਗ ਬਰੈਕਟਾਂ ਵਿੱਚ ਜੋ ਹੈ ਉਹ "ਵਿਕਲਪਕ ਕਾਰਜਸ਼ੀਲਤਾ" ਹੈ, ਇਸਨੂੰ "ਵਿਕਲਪ ਬਾਈਟਸ" ਦੁਆਰਾ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ (ਵਿਕਲਪ ਬਾਈਟ) - ਐਟਮੇਗਾ ਫਿਊਜ਼ ਵਰਗੀ ਕੋਈ ਚੀਜ਼। ਤੁਸੀਂ ਉਹਨਾਂ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਪ੍ਰੋਗਰਾਮ ਦੇ ਰੂਪ ਵਿੱਚ ਬਦਲ ਸਕਦੇ ਹੋ, ਪਰ ਇਹ ਜ਼ਰੂਰੀ ਨਹੀਂ ਹੈ, ਕਿਉਂਕਿ ਨਵੀਂ ਕਾਰਜਕੁਸ਼ਲਤਾ ਰੀਬੂਟ ਕਰਨ ਤੋਂ ਬਾਅਦ ਹੀ ਕਿਰਿਆਸ਼ੀਲ ਹੁੰਦੀ ਹੈ। ST ਵਿਜ਼ੂਅਲ ਪ੍ਰੋਗਰਾਮਰ (ਵਿਜ਼ੂਅਲ ਡਿਵੈਲਪ ਨਾਲ ਡਾਊਨਲੋਡ ਕੀਤਾ ਗਿਆ) ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਆਸਾਨ ਹੈ, ਜੋ ਇਹਨਾਂ ਬਾਈਟਾਂ ਨੂੰ ਬਦਲ ਸਕਦਾ ਹੈ। ਪਿਨਆਉਟ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਪਹਿਲੇ ਟਾਈਮਰ ਦੇ CH1 ਅਤੇ CH2 ਪਿੰਨ ਵਰਗ ਬਰੈਕਟਾਂ ਵਿੱਚ ਲੁਕੇ ਹੋਏ ਹਨ; STVP ਵਿੱਚ AFR1 ਅਤੇ AFR0 ਬਿੱਟਾਂ ਨੂੰ ਸੈੱਟ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ, ਅਤੇ ਦੂਜਾ ਇੱਕ ਦੂਜੇ ਟਾਈਮਰ ਦੇ CH1 ਆਉਟਪੁੱਟ ਨੂੰ PD4 ਤੋਂ PC5 ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕਰੇਗਾ।

ਇਸ ਤਰ੍ਹਾਂ, 6 ਪਿੰਨ LEDs ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨਗੇ: ਪਹਿਲੇ ਟਾਈਮਰ ਲਈ PC6, PC7 ਅਤੇ PC3, ਦੂਜੇ ਲਈ PC5, PD3 ਅਤੇ PA3।

STM8 'ਤੇ I/O ਪਿੰਨਾਂ ਨੂੰ ਆਪਣੇ ਆਪ ਸੈੱਟਅੱਪ ਕਰਨਾ STM32 ਦੇ ਮੁਕਾਬਲੇ ਸਰਲ ਅਤੇ ਜ਼ਿਆਦਾ ਤਰਕਪੂਰਨ ਹੈ:

• Atmega DDR ਡਾਟਾ ਦਿਸ਼ਾ ਰਜਿਸਟਰ ਤੋਂ ਜਾਣੂ (ਡਾਟਾ ਦਿਸ਼ਾ ਰਜਿਸਟਰ): 1 = ਆਉਟਪੁੱਟ;
• ਪਹਿਲਾ ਕੰਟਰੋਲ ਰਜਿਸਟਰ CR1, ਜਦੋਂ ਆਉਟਪੁੱਟ ਹੁੰਦਾ ਹੈ, ਪੁਸ਼-ਪੁੱਲ ਮੋਡ (1) ਜਾਂ ਓਪਨ ਡਰੇਨ (0) ਸੈੱਟ ਕਰਦਾ ਹੈ; ਕਿਉਂਕਿ ਮੈਂ LED ਨੂੰ ਚਿੱਪ ਨਾਲ ਕੈਥੋਡਸ ਨਾਲ ਜੋੜਦਾ ਹਾਂ, ਮੈਂ ਇੱਥੇ ਜ਼ੀਰੋ ਛੱਡਦਾ ਹਾਂ;
• ਦੂਜਾ ਕੰਟਰੋਲ ਰਜਿਸਟਰ CR2, ਜਦੋਂ ਆਉਟਪੁੱਟ, ਘੜੀ ਦੀ ਗਤੀ ਸੈੱਟ ਕਰਦਾ ਹੈ: 1 = 10 MHz

#define PA_DDR     *(volatile uint8_t *)0x005002
#define PA_CR2     *(volatile uint8_t *)0x005004
#define PD_DDR     *(volatile uint8_t *)0x005011
#define PD_CR2     *(volatile uint8_t *)0x005013
#define PC_DDR     *(volatile uint8_t *)0x00500C
#define PC_CR2     *(volatile uint8_t *)0x00500E

PA_DDR = (1<<3); //output
PA_CR2 |= (1<<3); //fast
PD_DDR = (1<<3); //output
PD_CR2 |= (1<<3); //fast
PC_DDR = ((1<<3) | (1<<5) | (1<<6) | (1<<7)); //output
PC_CR2 |= ((1<<3) | (1<<5) | (1<<6) | (1<<7)); //fast

PWM ਸੈਟਿੰਗ

ਪਹਿਲਾਂ, ਆਓ ਸ਼ਰਤਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੀਏ:

• ਪੀਡਬਲਯੂਐਮ ਬਾਰੰਬਾਰਤਾ - ਬਾਰੰਬਾਰਤਾ ਜਿਸ ਨਾਲ ਟਾਈਮਰ ਟਿੱਕ ਕਰਦਾ ਹੈ;
• ਆਟੋ-ਰੀਲੋਡ, AR - ਆਟੋਲੋਡ ਹੋਣ ਯੋਗ ਮੁੱਲ ਜਿਸ ਤੱਕ ਟਾਈਮਰ ਗਿਣਿਆ ਜਾਵੇਗਾ (ਪਲਸ ਪੀਰੀਅਡ);
• ਅੱਪਡੇਟ ਇਵੈਂਟ, UEV - ਇੱਕ ਘਟਨਾ ਜੋ ਉਦੋਂ ਵਾਪਰਦੀ ਹੈ ਜਦੋਂ ਟਾਈਮਰ ਨੂੰ AR ਵਿੱਚ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ;
• PWM ਡਿਊਟੀ ਸਾਈਕਲ - PWM ਡਿਊਟੀ ਚੱਕਰ, ਜਿਸ ਨੂੰ ਅਕਸਰ "ਡਿਊਟੀ ਫੈਕਟਰ" ਕਿਹਾ ਜਾਂਦਾ ਹੈ;
• ਮੁੱਲ ਕੈਪਚਰ/ਤੁਲਨਾ ਕਰੋ - ਕੈਪਚਰ/ਤੁਲਨਾ ਲਈ ਮੁੱਲ, ਜਿਸ ਲਈ ਟਾਈਮਰ ਨੇ ਗਿਣਿਆ ਹੈ ਕੁਝ ਕਰੇਗਾ (PWM ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਇਹ ਆਉਟਪੁੱਟ ਸਿਗਨਲ ਨੂੰ ਉਲਟਾਉਂਦਾ ਹੈ);
• ਪ੍ਰੀਲੋਡ ਮੁੱਲ - ਪਹਿਲਾਂ ਤੋਂ ਲੋਡ ਕੀਤਾ ਮੁੱਲ। ਮੁੱਲ ਦੀ ਤੁਲਨਾ ਕਰੋ ਜਦੋਂ ਟਾਈਮਰ ਟਿਕ ਰਿਹਾ ਹੋਵੇ ਤਾਂ ਬਦਲਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ, ਨਹੀਂ ਤਾਂ PWM ਚੱਕਰ ਟੁੱਟ ਜਾਵੇਗਾ। ਇਸ ਲਈ, ਨਵੇਂ ਪ੍ਰਸਾਰਿਤ ਮੁੱਲ ਇੱਕ ਬਫਰ ਵਿੱਚ ਰੱਖੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਜਦੋਂ ਟਾਈਮਰ ਇਸਦੇ ਕਾਊਂਟਡਾਊਨ ਦੇ ਅੰਤ ਤੱਕ ਪਹੁੰਚਦਾ ਹੈ ਅਤੇ ਰੀਸੈਟ ਹੁੰਦਾ ਹੈ ਤਾਂ ਬਾਹਰ ਕੱਢਿਆ ਜਾਂਦਾ ਹੈ;
• ਕਿਨਾਰੇ-ਸੰਗਠਿਤ и ਕੇਂਦਰ-ਅਲਾਈਨ ਮੋਡ - ਸਰਹੱਦ ਦੇ ਨਾਲ ਅਤੇ ਕੇਂਦਰ ਵਿੱਚ ਅਲਾਈਨਮੈਂਟ, ਐਟਮੇਲ ਦੇ ਸਮਾਨ ਤੇਜ਼ ਪੀ.ਡਬਲਯੂ.ਐੱਮ и ਪੜਾਅ-ਸਹੀ PWM.
• OCiREF, ਆਉਟਪੁੱਟ ਸੰਦਰਭ ਸੰਕੇਤ ਦੀ ਤੁਲਨਾ ਕਰੋ - ਹਵਾਲਾ ਆਉਟਪੁੱਟ ਸਿਗਨਲ, ਅਸਲ ਵਿੱਚ, PWM ਮੋਡ ਵਿੱਚ ਸੰਬੰਧਿਤ ਪਿੰਨ 'ਤੇ ਕੀ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ।

ਜਿਵੇਂ ਕਿ ਪਿਨਆਉਟ ਤੋਂ ਪਹਿਲਾਂ ਹੀ ਸਪੱਸ਼ਟ ਹੈ, ਦੋ ਟਾਈਮਰਾਂ ਵਿੱਚ PWM ਸਮਰੱਥਾਵਾਂ ਹਨ - ਪਹਿਲਾ ਅਤੇ ਦੂਜਾ। ਦੋਵੇਂ 16-ਬਿੱਟ ਹਨ, ਪਹਿਲੇ ਵਿੱਚ ਬਹੁਤ ਸਾਰੀਆਂ ਵਾਧੂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹਨ (ਖਾਸ ਤੌਰ 'ਤੇ, ਇਹ ਉੱਪਰ ਅਤੇ ਹੇਠਾਂ ਦੋਵਾਂ ਨੂੰ ਗਿਣ ਸਕਦਾ ਹੈ)। ਸਾਨੂੰ ਦੋਵਾਂ ਨੂੰ ਬਰਾਬਰ ਕੰਮ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਇਸਲਈ ਮੈਂ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਗਰੀਬ ਦੂਜੇ ਨਾਲ ਸ਼ੁਰੂ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ, ਤਾਂ ਜੋ ਗਲਤੀ ਨਾਲ ਕਿਸੇ ਅਜਿਹੀ ਚੀਜ਼ ਦੀ ਵਰਤੋਂ ਨਾ ਕੀਤੀ ਜਾਵੇ ਜੋ ਉੱਥੇ ਨਹੀਂ ਹੈ। ਕੁਝ ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ ਰੈਫਰੈਂਸ ਮੈਨੂਅਲ ਵਿੱਚ ਸਾਰੇ ਟਾਈਮਰਾਂ ਦੀ PWM ਕਾਰਜਕੁਸ਼ਲਤਾ ਦਾ ਵਰਣਨ ਪਹਿਲੇ ਟਾਈਮਰ (17.5.7 PWM ਮੋਡ) ਬਾਰੇ ਅਧਿਆਇ ਵਿੱਚ ਹੈ, ਇਸਲਈ ਤੁਹਾਨੂੰ ਹਰ ਸਮੇਂ ਦਸਤਾਵੇਜ਼ ਵਿੱਚ ਅੱਗੇ-ਪਿੱਛੇ ਜਾਣਾ ਪੈਂਦਾ ਹੈ।

STM8 'ਤੇ PWM ਦਾ Atmega 'ਤੇ PWM ਨਾਲੋਂ ਮਹੱਤਵਪੂਰਨ ਫਾਇਦਾ ਹੈ:

ਸੀਮਾ ਅਲਾਈਨਡ PWM
ਹੇਠਾਂ ਤੋਂ ਉੱਪਰ ਤੱਕ ਖਾਤਾ ਸੰਰਚਨਾ
ਜੇਕਰ TIM_CR1 ਰਜਿਸਟਰ ਵਿੱਚ ਡੀਆਈਆਰ ਬਿੱਟ ਕਲੀਅਰ ਕੀਤਾ ਗਿਆ ਹੈ ਤਾਂ ਹੇਠਾਂ-ਉੱਪਰ ਦੀ ਗਿਣਤੀ ਸਰਗਰਮ ਹੈ
ਉਦਾਹਰਨ:
ਉਦਾਹਰਨ ਪਹਿਲੇ PWM ਮੋਡ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ। PWM ਸੰਦਰਭ ਸਿਗਨਲ OCiREF ਨੂੰ TIM1_CNT < TIM1_CCRi ਤੱਕ ਉੱਚਾ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ। ਨਹੀਂ ਤਾਂ ਇਹ ਇੱਕ ਨੀਵਾਂ ਪੱਧਰ ਲੈਂਦਾ ਹੈ. ਜੇਕਰ TIM1_CCRi ਰਜਿਸਟਰ ਵਿੱਚ ਤੁਲਨਾ ਮੁੱਲ ਆਟੋਲੋਡ ਮੁੱਲ (TIM1_ARR ਰਜਿਸਟਰ) ਤੋਂ ਵੱਧ ਹੈ, ਤਾਂ OCiREF ਸਿਗਨਲ 1 'ਤੇ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ। ਜੇਕਰ ਤੁਲਨਾ ਮੁੱਲ 0 ਹੈ, ਤਾਂ OCiREF ਨੂੰ ਜ਼ੀਰੋ 'ਤੇ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ।...

ਦੌਰਾਨ STM8 ਟਾਈਮਰ ਅੱਪਡੇਟ ਘਟਨਾ ਪਹਿਲਾਂ ਜਾਂਚ ਕਰਦਾ ਹੈ ਮੁੱਲ ਦੀ ਤੁਲਨਾ ਕਰੋ, ਅਤੇ ਕੇਵਲ ਤਦ ਹੀ ਇੱਕ ਹਵਾਲਾ ਸੰਕੇਤ ਪੈਦਾ ਕਰਦਾ ਹੈ। ਐਟਮੇਗਾ ਦਾ ਟਾਈਮਰ ਪਹਿਲਾਂ ਪੇਚ ਕਰਦਾ ਹੈ ਅਤੇ ਫਿਰ ਤੁਲਨਾ ਕਰਦਾ ਹੈ, ਨਤੀਜੇ ਵਜੋਂ compare value == 0 ਆਉਟਪੁੱਟ ਇੱਕ ਸੂਈ ਹੈ, ਜਿਸਨੂੰ ਕਿਸੇ ਤਰ੍ਹਾਂ ਨਾਲ ਨਜਿੱਠਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ (ਉਦਾਹਰਣ ਲਈ, ਤਰਕ ਨੂੰ ਪ੍ਰੋਗਰਾਮੇਟਿਕ ਰੂਪ ਵਿੱਚ ਉਲਟਾ ਕੇ)।

ਇਸ ਲਈ ਅਸੀਂ ਕੀ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ: 8-bit PWM (AR == 255), ਹੇਠਾਂ ਤੋਂ ਉੱਪਰ ਤੱਕ ਗਿਣਨਾ, ਬਾਰਡਰ ਦੇ ਨਾਲ ਇਕਸਾਰਤਾ। ਕਿਉਂਕਿ ਲਾਈਟ ਬਲਬ ਕੈਥੋਡ ਦੁਆਰਾ ਚਿੱਪ ਨਾਲ ਜੁੜੇ ਹੋਏ ਹਨ, ਇਸ ਲਈ PWM ਨੂੰ 0 (LED ਚਾਲੂ) ਤੱਕ ਆਉਟਪੁੱਟ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਮੁੱਲ ਦੀ ਤੁਲਨਾ ਕਰੋ ਅਤੇ 1 ਬਾਅਦ.

ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਕੁਝ ਬਾਰੇ ਪੜ੍ਹ ਚੁੱਕੇ ਹਾਂ PWM ਮੋਡ, ਇਸਲਈ ਸਾਨੂੰ ਇਸ ਵਾਕੰਸ਼ (18.6.8 - TIMx_CCMR1) ਲਈ ਹਵਾਲਾ ਮੈਨੂਅਲ ਵਿੱਚ ਖੋਜ ਕਰਕੇ ਦੂਜੇ ਟਾਈਮਰ ਦਾ ਲੋੜੀਂਦਾ ਰਜਿਸਟਰ ਮਿਲਦਾ ਹੈ:

110: ਪਹਿਲਾ PWM ਮੋਡ - ਜਦੋਂ ਹੇਠਾਂ ਤੋਂ ਉੱਪਰ ਤੱਕ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ, ਪਹਿਲਾ ਚੈਨਲ ਕਿਰਿਆਸ਼ੀਲ ਹੁੰਦਾ ਹੈ ਜਦੋਂ TIMx_CNT < TIMx_CCR1। ਨਹੀਂ ਤਾਂ, ਪਹਿਲਾ ਚੈਨਲ ਅਕਿਰਿਆਸ਼ੀਲ ਹੈ। [ਅੱਗੇ ਦਸਤਾਵੇਜ਼ ਵਿੱਚ ਟਾਈਮਰ 1 ਤੋਂ ਇੱਕ ਗਲਤ ਕਾਪੀ-ਪੇਸਟ ਹੈ] 111: ਦੂਜਾ PWM ਮੋਡ - ਜਦੋਂ ਹੇਠਾਂ ਤੋਂ ਉੱਪਰ ਤੱਕ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਪਹਿਲਾ ਚੈਨਲ ਅਕਿਰਿਆਸ਼ੀਲ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਕਿ TIMx_CNT < TIMx_CCR1। ਨਹੀਂ ਤਾਂ, ਪਹਿਲਾ ਚੈਨਲ ਕਿਰਿਆਸ਼ੀਲ ਹੈ।

ਕਿਉਂਕਿ LEDs ਕੈਥੋਡਸ ਦੁਆਰਾ MK ਨਾਲ ਜੁੜੇ ਹੋਏ ਹਨ, ਦੂਜਾ ਮੋਡ ਸਾਡੇ ਲਈ ਅਨੁਕੂਲ ਹੈ (ਪਹਿਲਾ ਵੀ, ਪਰ ਸਾਨੂੰ ਅਜੇ ਤੱਕ ਇਹ ਨਹੀਂ ਪਤਾ)।

ਬਿੱਟ 3 OC1PE: ਪਿੰਨ 1 ਪ੍ਰੀਲੋਡ ਨੂੰ ਸਮਰੱਥ ਬਣਾਓ
0: TIMx_CCR1 'ਤੇ ਪ੍ਰੀਲੋਡ ਰਜਿਸਟਰ ਅਯੋਗ ਹੈ। ਤੁਸੀਂ ਕਿਸੇ ਵੀ ਸਮੇਂ TIMx_CCR1 ਨੂੰ ਲਿਖ ਸਕਦੇ ਹੋ। ਨਵਾਂ ਮੁੱਲ ਤੁਰੰਤ ਕੰਮ ਕਰਦਾ ਹੈ।
1: TIMx_CCR1 'ਤੇ ਪ੍ਰੀਲੋਡ ਰਜਿਸਟਰ ਸਮਰਥਿਤ ਹੈ। ਪੜ੍ਹੋ/ਲਿਖਣ ਦੇ ਓਪਰੇਸ਼ਨ ਪ੍ਰੀਲੋਡ ਰਜਿਸਟਰ ਤੱਕ ਪਹੁੰਚ ਕਰੋ। ਪਹਿਲਾਂ ਤੋਂ ਲੋਡ ਕੀਤੇ ਮੁੱਲ TIMx_CCR1 ਨੂੰ ਹਰੇਕ ਅੱਪਡੇਟ ਇਵੈਂਟ ਦੌਰਾਨ ਸ਼ੈਡੋ ਰਜਿਸਟਰ ਵਿੱਚ ਲੋਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
*ਨੋਟ: PWM ਮੋਡ ਦੇ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ, ਪ੍ਰੀਲੋਡ ਰਜਿਸਟਰਾਂ ਨੂੰ ਸਮਰੱਥ ਬਣਾਇਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਸਿੰਗਲ ਸਿਗਨਲ ਮੋਡ ਵਿੱਚ ਇਹ ਜ਼ਰੂਰੀ ਨਹੀਂ ਹੈ (OPM ਬਿੱਟ TIMx_CR1 ਰਜਿਸਟਰ ਵਿੱਚ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ)।

ਠੀਕ ਹੈ, ਚਲੋ ਦੂਜੇ ਟਾਈਮਰ ਦੇ ਤਿੰਨ ਚੈਨਲਾਂ ਲਈ ਲੋੜੀਂਦੀ ਹਰ ਚੀਜ਼ ਨੂੰ ਚਾਲੂ ਕਰੀਏ:

#define TIM2_CCMR1 *(volatile uint8_t *)0x005307
#define TIM2_CCMR2 *(volatile uint8_t *)0x005308
#define TIM2_CCMR3 *(volatile uint8_t *)0x005309

#define PWM_MODE2   0x70 //PWM mode 2, 0b01110000
#define OCxPE       0x08 //preload enable

TIM2_CCMR1 = (PWM_MODE2 | OCxPE);
TIM2_CCMR2 = (PWM_MODE2 | OCxPE);
TIM2_CCMR3 = (PWM_MODE2 | OCxPE);

AR ਵਿੱਚ ਦੋ ਅੱਠ-ਬਿੱਟ ਰਜਿਸਟਰ ਹੁੰਦੇ ਹਨ, ਸਭ ਕੁਝ ਸਧਾਰਨ ਹੈ:

#define TIM2_ARRH  *(volatile uint8_t *)0x00530F
#define TIM2_ARRL  *(volatile uint8_t *)0x005310

TIM2_ARRH = 0;
TIM2_ARRL = 255;

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

#define TIM2_PSCR  *(volatile uint8_t *)0x00530E

TIM2_PSCR = 8;

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

#define TIM2_CCER1 *(volatile uint8_t *)0x00530A
#define TIM2_CCER2 *(volatile uint8_t *)0x00530B

#define CC1E  (1<<0) // CCER1
#define CC2E  (1<<4) // CCER1
#define CC3E  (1<<0) // CCER2

TIM2_CCER1 = (CC1E | CC2E);
TIM2_CCER2 = CC3E;

ਅਤੇ ਅੰਤ ਵਿੱਚ, ਅਸੀਂ TIMx_CR1 ਰਜਿਸਟਰ ਵਿੱਚ ਟਾਈਮਰ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ:

#define TIM2_CR1   *(volatile uint8_t *)0x005300

TIM2_CR1 |= 1;

ਆਓ ਐਨਾਲਾਗ ਰਾਈਟ() ਦਾ ਇੱਕ ਸਧਾਰਨ ਐਨਾਲਾਗ ਲਿਖੀਏ, ਜੋ ਤੁਲਨਾ ਲਈ ਅਸਲ ਮੁੱਲਾਂ ਨੂੰ ਟਾਈਮਰ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕਰੇਗਾ। ਰਜਿਸਟਰਾਂ ਵਿੱਚ ਅਨੁਮਾਨ ਅਨੁਸਾਰ ਨਾਮ ਦਿੱਤੇ ਗਏ ਹਨ ਰਜਿਸਟਰਾਂ ਨੂੰ ਕੈਪਚਰ/ਤੁਲਨਾ ਕਰੋ, ਹਰੇਕ ਚੈਨਲ ਲਈ ਉਹਨਾਂ ਵਿੱਚੋਂ ਦੋ ਹਨ: TIM8_CCRxL ਵਿੱਚ ਘੱਟ-ਆਰਡਰ ਵਾਲੇ 2 ਬਿੱਟ ਅਤੇ TIM2_CCRxH ਵਿੱਚ ਉੱਚ-ਆਰਡਰ ਵਾਲੇ। ਕਿਉਂਕਿ ਅਸੀਂ ਇੱਕ 8-ਬਿੱਟ PWM ਬਣਾਇਆ ਹੈ, ਇਹ ਸਿਰਫ ਘੱਟੋ-ਘੱਟ ਮਹੱਤਵਪੂਰਨ ਬਿੱਟ ਲਿਖਣ ਲਈ ਕਾਫੀ ਹੈ:

#define TIM2_CCR1L *(volatile uint8_t *)0x005312
#define TIM2_CCR2L *(volatile uint8_t *)0x005314
#define TIM2_CCR3L *(volatile uint8_t *)0x005316

void setRGBled(uint8_t r, uint8_t g, uint8_t b)
{
    TIM2_CCR1L = r;
    TIM2_CCR2L = g;
    TIM2_CCR3L = b;
}

ਧਿਆਨ ਦੇਣ ਵਾਲਾ ਪਾਠਕ ਧਿਆਨ ਦੇਵੇਗਾ ਕਿ ਸਾਡੇ ਕੋਲ ਇੱਕ ਥੋੜ੍ਹਾ ਨੁਕਸਦਾਰ PWM ਹੈ, ਜੋ 100% ਭਰਨ ਵਿੱਚ ਅਸਮਰੱਥ ਹੈ (255 ਦੇ ਅਧਿਕਤਮ ਮੁੱਲ 'ਤੇ, ਸਿਗਨਲ ਇੱਕ ਟਾਈਮਰ ਚੱਕਰ ਲਈ ਉਲਟਾ ਹੁੰਦਾ ਹੈ)। LEDs ਲਈ ਇਹ ਮਾਇਨੇ ਨਹੀਂ ਰੱਖਦਾ, ਅਤੇ ਧਿਆਨ ਦੇਣ ਵਾਲਾ ਪਾਠਕ ਪਹਿਲਾਂ ਹੀ ਅੰਦਾਜ਼ਾ ਲਗਾ ਸਕਦਾ ਹੈ ਕਿ ਇਸਨੂੰ ਕਿਵੇਂ ਠੀਕ ਕਰਨਾ ਹੈ.

ਦੂਜੇ ਟਾਈਮਰ 'ਤੇ PWM ਕੰਮ ਕਰਦਾ ਹੈ, ਆਓ ਪਹਿਲੇ 'ਤੇ ਚੱਲੀਏ।

ਪਹਿਲੇ ਟਾਈਮਰ ਦੇ ਉਸੇ ਰਜਿਸਟਰਾਂ ਵਿੱਚ ਬਿਲਕੁਲ ਉਹੀ ਬਿੱਟ ਹੁੰਦੇ ਹਨ (ਇਹ ਸਿਰਫ ਇਹ ਹੈ ਕਿ ਉਹ ਬਿੱਟ ਜੋ ਦੂਜੇ ਟਾਈਮਰ ਵਿੱਚ "ਰਿਜ਼ਰਵ" ਰਹੇ ਹਨ, ਹਰ ਕਿਸਮ ਦੀਆਂ ਉੱਨਤ ਚੀਜ਼ਾਂ ਲਈ ਪਹਿਲੇ ਵਿੱਚ ਸਰਗਰਮੀ ਨਾਲ ਵਰਤੇ ਜਾਂਦੇ ਹਨ)। ਇਸ ਲਈ, ਡੇਟਾਸ਼ੀਟ ਵਿੱਚ ਇੱਕੋ ਰਜਿਸਟਰਾਂ ਦੇ ਪਤੇ ਲੱਭਣ ਅਤੇ ਕੋਡ ਦੀ ਨਕਲ ਕਰਨ ਲਈ ਇਹ ਕਾਫ਼ੀ ਹੈ. ਖੈਰ, ਬਾਰੰਬਾਰਤਾ ਵਿਭਾਜਕ ਦਾ ਮੁੱਲ ਬਦਲੋ, ਕਿਉਂਕਿ ... ਪਹਿਲਾ ਟਾਈਮਰ ਦੋ ਦੀ ਸ਼ਕਤੀ ਨਹੀਂ, ਪਰ ਦੋ ਰਜਿਸਟਰਾਂ ਵਿੱਚ ਇੱਕ ਸਹੀ 16-ਬਿੱਟ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹੈ Prescaler ਉੱਚ и ਖੋਜੋ wego.co.in. ਅਸੀਂ ਸਭ ਕੁਝ ਕਰਦੇ ਹਾਂ ਅਤੇ... ਪਹਿਲਾ ਟਾਈਮਰ ਕੰਮ ਨਹੀਂ ਕਰਦਾ। ਕੀ ਗੱਲ ਹੈ?

ਸਮੱਸਿਆ ਨੂੰ ਸਿਰਫ ਟਾਈਮਰ 1 ਦੇ ਕੰਟਰੋਲ ਰਜਿਸਟਰਾਂ ਬਾਰੇ ਪੂਰੇ ਭਾਗ ਨੂੰ ਦੇਖ ਕੇ ਹੱਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜਿੱਥੇ ਅਸੀਂ ਉਸ ਨੂੰ ਲੱਭਦੇ ਹਾਂ ਜੋ ਦੂਜੇ ਟਾਈਮਰ ਕੋਲ ਨਹੀਂ ਹੈ। ਉੱਥੇ ਹੋਵੇਗਾ 17.7.30 ਬਰੇਕ ਰਜਿਸਟਰ (TIM1_BKR), ਜਿੱਥੇ ਇਹ ਬਿੱਟ ਹੈ:

ਮੁੱਖ ਆਉਟਪੁੱਟ ਨੂੰ ਸਮਰੱਥ ਬਣਾਓ

#define TIM1_BKR   *(volatile uint8_t *)0x00526D

TIM1_BKR = (1<<7);

ਇਹ ਯਕੀਨੀ ਤੌਰ 'ਤੇ ਹੁਣ ਸਭ ਕੁਝ ਹੈ, ਕੋਡ ਉੱਥੇ.

STM8 ਮਲਟੀਪਲੈਕਸ

STM8 'ਤੇ ਮਲਟੀਪਲੈਕਸਿੰਗ

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

ਕੰਮ ਦਾ ਐਲਗੋਰਿਦਮ ਇਸ ਤਰ੍ਹਾਂ ਦਿਸਦਾ ਹੈ:

• ਪਹਿਲੇ RGB LED ਦੇ ਐਨੋਡ ਨੂੰ ਜੋੜਿਆ;
• ਇਸ ਨੂੰ ਲਾਈਟ ਕਰੋ, ਕੈਥੋਡਾਂ ਨੂੰ ਜ਼ਰੂਰੀ ਸਿਗਨਲ ਭੇਜੋ;
• PWM ਚੱਕਰ ਦੇ ਅੰਤ ਤੱਕ ਉਡੀਕ ਕੀਤੀ;
• ਦੂਜੇ RGB LED ਦੇ ਐਨੋਡ ਨੂੰ ਜੋੜਿਆ ਗਿਆ;
• ਇਸ ਨੂੰ ਜਗਾਇਆ...

ਖੈਰ, ਆਦਿ। ਬੇਸ਼ੱਕ, ਸੁੰਦਰ ਓਪਰੇਸ਼ਨ ਲਈ ਇਹ ਜ਼ਰੂਰੀ ਹੈ ਕਿ ਐਨੋਡ ਜੁੜਿਆ ਹੋਵੇ ਅਤੇ LED ਉਸੇ ਸਮੇਂ "ਇਗਨੀਟ" ਹੋਵੇ। ਠੀਕ ਹੈ, ਜਾਂ ਲਗਭਗ. ਕਿਸੇ ਵੀ ਸਥਿਤੀ ਵਿੱਚ, ਸਾਨੂੰ ਇੱਕ ਕੋਡ ਲਿਖਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਜੋ ਦੂਜੇ ਟਾਈਮਰ ਦੇ ਤਿੰਨ ਚੈਨਲਾਂ ਵਿੱਚ ਮੁੱਲਾਂ ਨੂੰ ਆਉਟਪੁੱਟ ਕਰੇਗਾ, ਜਦੋਂ UEV ਪਹੁੰਚ ਜਾਂਦਾ ਹੈ ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਬਦਲਦਾ ਹੈ, ਅਤੇ ਉਸੇ ਸਮੇਂ ਮੌਜੂਦਾ ਕਿਰਿਆਸ਼ੀਲ RGB LED ਨੂੰ ਬਦਲਦਾ ਹੈ.

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

uint8_t colors[8][3];

ਇੱਕ ਖਾਸ LED ਦਾ ਰੰਗ ਬਦਲਣ ਲਈ, ਇਸ ਐਰੇ ਵਿੱਚ ਲੋੜੀਂਦੇ ਮੁੱਲਾਂ ਨੂੰ ਲਿਖਣਾ ਕਾਫ਼ੀ ਹੋਵੇਗਾ। ਅਤੇ ਵੇਰੀਏਬਲ ਸਰਗਰਮ LED ਦੀ ਸੰਖਿਆ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੋਵੇਗਾ

uint8_t cnt;

ਡੈਮਕਸ

ਸਹੀ ਮਲਟੀਪਲੈਕਸਿੰਗ ਲਈ, ਸਾਨੂੰ ਅਜੀਬ ਤੌਰ 'ਤੇ, ਇੱਕ CD74HC238 ਡੀਮਲਟੀਪਲੈਕਸਰ ਦੀ ਲੋੜ ਹੈ। Demultiplexer - ਇੱਕ ਚਿੱਪ ਜੋ ਹਾਰਡਵੇਅਰ ਵਿੱਚ ਆਪਰੇਟਰ ਨੂੰ ਲਾਗੂ ਕਰਦੀ ਹੈ <<. ਤਿੰਨ ਇਨਪੁਟ ਪਿੰਨਾਂ (ਬਿੱਟ 0, 1 ਅਤੇ 2) ਦੁਆਰਾ ਅਸੀਂ ਇਸਨੂੰ ਤਿੰਨ-ਬਿੱਟ ਨੰਬਰ X ਫੀਡ ਕਰਦੇ ਹਾਂ, ਅਤੇ ਜਵਾਬ ਵਿੱਚ ਇਹ ਆਉਟਪੁੱਟ ਨੰਬਰ ਨੂੰ ਸਰਗਰਮ ਕਰਦਾ ਹੈ (1<<X). ਚਿੱਪ ਦੇ ਬਾਕੀ ਇੰਪੁੱਟ ਪੂਰੇ ਡਿਜ਼ਾਈਨ ਨੂੰ ਮਾਪਣ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ। ਸਾਨੂੰ ਇਸ ਚਿੱਪ ਦੀ ਲੋੜ ਨਾ ਸਿਰਫ਼ ਮਾਈਕ੍ਰੋਕੰਟਰੋਲਰ ਦੇ ਕਬਜ਼ੇ ਵਾਲੇ ਪਿੰਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ ਹੈ, ਸਗੋਂ ਸੁਰੱਖਿਆ ਲਈ ਵੀ - ਤਾਂ ਜੋ ਗਲਤੀ ਨਾਲ ਸੰਭਵ ਤੋਂ ਵੱਧ LEDs ਚਾਲੂ ਨਾ ਹੋਣ ਅਤੇ MK ਨੂੰ ਨਾ ਸਾੜਿਆ ਜਾਵੇ। ਚਿੱਪ ਦੀ ਕੀਮਤ ਇੱਕ ਪੈਸਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਹਮੇਸ਼ਾ ਤੁਹਾਡੀ ਘਰੇਲੂ ਦਵਾਈ ਕੈਬਿਨੇਟ ਵਿੱਚ ਰੱਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

ਸਾਡਾ CD74HC238 ਲੋੜੀਂਦੇ LED ਦੇ ਐਨੋਡ ਨੂੰ ਵੋਲਟੇਜ ਦੀ ਸਪਲਾਈ ਕਰਨ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੋਵੇਗਾ। ਇੱਕ ਪੂਰੇ ਮਲਟੀਪਲੈਕਸ ਵਿੱਚ, ਇਹ ਇੱਕ P-MOSFET ਦੁਆਰਾ ਕਾਲਮ ਨੂੰ ਵੋਲਟੇਜ ਦੀ ਸਪਲਾਈ ਕਰੇਗਾ, ਪਰ ਇਸ ਡੈਮੋ ਵਿੱਚ ਇਹ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਸੰਭਵ ਹੈ, ਕਿਉਂਕਿ ਇਹ 20 mA ਖਿੱਚਦਾ ਹੈ, ਅਨੁਸਾਰ ਪੂਰਨ ਅਧਿਕਤਮ ਰੇਟਿੰਗ ਡੇਟਾਸ਼ੀਟ ਵਿੱਚ. ਤੋਂ ਡਾਟਾਸ਼ੀਟ CD74HC238 ਸਾਨੂੰ pinouts ਅਤੇ ਇਸ ਚੀਟ ਸ਼ੀਟ ਦੀ ਲੋੜ ਹੈ:

H = ਉੱਚ ਵੋਲਟੇਜ ਪੱਧਰ, L = ਘੱਟ ਵੋਲਟੇਜ ਪੱਧਰ, X - ਪਰਵਾਹ ਨਾ ਕਰੋ

ਅਸੀਂ E2 ਅਤੇ E1 ਨੂੰ ਜ਼ਮੀਨ ਨਾਲ, E3, A0, A1 ਅਤੇ A3 ਨੂੰ STM5 ਦੇ PD3, PC4, PC5 ਅਤੇ PC8 ਨਾਲ ਜੋੜਦੇ ਹਾਂ। ਕਿਉਂਕਿ ਉਪਰੋਕਤ ਸਾਰਣੀ ਵਿੱਚ ਹੇਠਲੇ ਅਤੇ ਉੱਚ ਪੱਧਰ ਦੋਵੇਂ ਸ਼ਾਮਲ ਹਨ, ਅਸੀਂ ਇਹਨਾਂ ਪਿੰਨਾਂ ਨੂੰ ਪੁਸ਼-ਪੁੱਲ ਪਿੰਨ ਵਜੋਂ ਸੰਰਚਿਤ ਕਰਦੇ ਹਾਂ।

PWM

ਦੂਜੇ ਟਾਈਮਰ 'ਤੇ PWM ਨੂੰ ਪਿਛਲੀ ਕਹਾਣੀ ਵਾਂਗ ਹੀ ਸੰਰਚਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਦੋ ਅੰਤਰਾਂ ਨਾਲ:

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

ਵਿਘਨ ਯੋਗ ਰਜਿਸਟਰ

#define TIM2_IER   *(volatile uint8_t *)0x005303

//enable interrupt
TIM2_IER = 1;

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

ਧਰੁਵੀਤਾ ਬਦਲਣਾ:

//set polarity 
    TIM2_CCER1 |= (CC1P | CC2P);
    TIM2_CCER2 |= CC3P;

r, g ਅਤੇ b ਨੂੰ 255 'ਤੇ ਸੈੱਟ ਕਰਨ ਤੋਂ ਬਚੋ ਅਤੇ ਉਹਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਉਹਨਾਂ ਨੂੰ ਉਲਟਾਉਣਾ ਯਾਦ ਰੱਖੋ।

ਵਿਘਨ ਪਾਉਂਦਾ ਹੈ

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

ਜਦੋਂ ਅਸੀਂ ਪਹਿਲੀ ਵਾਰ ST ਵਿਜ਼ੁਅਲ ਡਿਵੈਲਪ ਵਿੱਚ ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਬਣਾਇਆ, ਇਸ ਤੋਂ ਇਲਾਵਾ main.c ਸਾਨੂੰ ਇੱਕ ਰਹੱਸਮਈ ਫਾਈਲ ਵਾਲੀ ਇੱਕ ਵਿੰਡੋ ਮਿਲੀ ਹੈ stm8_interrupt_vector.c, ਆਪਣੇ ਆਪ ਹੀ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਸ ਫਾਈਲ ਵਿੱਚ, ਹਰੇਕ ਰੁਕਾਵਟ ਨੂੰ ਇੱਕ ਫੰਕਸ਼ਨ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ NonHandledInterrupt. ਸਾਨੂੰ ਆਪਣੇ ਫੰਕਸ਼ਨ ਨੂੰ ਲੋੜੀਂਦੇ ਰੁਕਾਵਟ ਨਾਲ ਬੰਨ੍ਹਣ ਦੀ ਲੋੜ ਹੈ।

ਡੇਟਾਸ਼ੀਟ ਵਿੱਚ ਇੰਟਰੱਪਟ ਵੈਕਟਰਾਂ ਦੀ ਇੱਕ ਸਾਰਣੀ ਹੁੰਦੀ ਹੈ, ਜਿੱਥੇ ਸਾਨੂੰ ਲੋੜ ਹੁੰਦੀ ਹੈ:

13 TIM2 ਅੱਪਡੇਟ/ਓਵਰਫਲੋ
14 TIM2 ਕੈਪਚਰ/ਤੁਲਨਾ

ਸਾਨੂੰ UEV 'ਤੇ LED ਨੂੰ ਬਦਲਣ ਦੀ ਲੋੜ ਹੈ, ਇਸ ਲਈ ਸਾਨੂੰ ਇੰਟਰੱਪਟ #13 ਦੀ ਲੋੜ ਹੈ।

ਇਸ ਅਨੁਸਾਰ, ਪਹਿਲਾਂ, ਫਾਈਲ ਵਿੱਚ stm8_interrupt_vector.c ਇੰਟਰੱਪਟ ਨੰਬਰ 13 (IRQ13) ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਫੰਕਸ਼ਨ ਦਾ ਡਿਫੌਲਟ ਨਾਮ ਬਦਲੋ:

{0x82, TIM2_Overflow}, /* irq13 */

ਦੂਜਾ, ਸਾਨੂੰ ਇੱਕ ਫਾਈਲ ਬਣਾਉਣੀ ਪਵੇਗੀ main.h ਹੇਠ ਦਿੱਤੀ ਸਮੱਗਰੀ ਦੇ ਨਾਲ:

#ifndef __MAIN_H
#define __MAIN_H

@far @interrupt void TIM2_Overflow (void);
#endif

ਅਤੇ ਅੰਤ ਵਿੱਚ, ਇਸ ਫੰਕਸ਼ਨ ਨੂੰ ਆਪਣੇ ਵਿੱਚ ਲਿਖੋ main.c:

@far @interrupt void TIM2_Overflow (void)
{
    PD_ODR &= ~(1<<5); // вырубаем демультиплексор
    PC_ODR = (cnt<<3); // записываем в демультиплексор новое значение
    PD_ODR |= (1<<5); // включаем демультиплексор

    TIM2_SR1 = 0; // сбрасываем флаг Update Interrupt Pending

    cnt++; 
    cnt &= 7; // двигаем счетчик LED

    TIM2_CCR1L = ~colors[cnt][0]; // передаем в буфер инвертированные значения
    TIM2_CCR2L = ~colors[cnt][1]; // для следующего цикла ШИМ
    TIM2_CCR3L = ~colors[cnt][2]; // 

    return;
}

ਜੋ ਬਚਦਾ ਹੈ ਉਹ ਰੁਕਾਵਟਾਂ ਨੂੰ ਸਮਰੱਥ ਕਰਨਾ ਹੈ. ਇਹ ਅਸੈਂਬਲਰ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਜਾਂਦਾ ਹੈ rim - ਤੁਹਾਨੂੰ ਇਸ ਵਿੱਚ ਖੋਜ ਕਰਨੀ ਪਵੇਗੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਮੈਨੂਅਲ:

//enable interrupts
_asm("rim");

ਇੱਕ ਹੋਰ ਅਸੈਂਬਲਰ ਕਮਾਂਡ ਹੈ sim - ਰੁਕਾਵਟਾਂ ਨੂੰ ਬੰਦ ਕਰਦਾ ਹੈ। ਉਹਨਾਂ ਨੂੰ ਬੰਦ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਜਦੋਂ ਨਵੇਂ ਮੁੱਲ "ਵੀਡੀਓ ਮੈਮੋਰੀ" ਵਿੱਚ ਲਿਖੇ ਜਾ ਰਹੇ ਹਨ, ਤਾਂ ਜੋ ਗਲਤ ਸਮੇਂ 'ਤੇ ਇੱਕ ਰੁਕਾਵਟ ਐਰੇ ਨੂੰ ਖਰਾਬ ਨਾ ਕਰੇ।

ਸਾਰੇ ਕੋਡ - GitHub 'ਤੇ.

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

ਸਰੋਤ: www.habr.com