ਏਮਬੈਡਡ ਸਿਸਟਮ ਅਤੇ ਮਾਈਕ੍ਰੋਕੰਟਰੋਲਰ ਕੋਡ

ਲਾਭ:

• ਇੱਕ ਸਪਸ਼ਟ ਪ੍ਰੋਂਪਟ ਦੇ ਨਾਲ ਮਾਈਕ੍ਰੋਕੰਟਰੋਲਰ ਲਈ ਰਜਿਸਟਰ, ਰੁਕਾਵਟ ਅਤੇ ਸਮੇਂ ਦੀਆਂ ਲੋੜਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਸਮਰੱਥਾ
• ਰਜਿਸਟਰ ਸੈਟਿੰਗਾਂ, ਬਫਰ ਓਵਰਫਲੋ ਅਤੇ ਅਸਲ ਸਮੇਂ ਦੀਆਂ ਰੁਕਾਵਟਾਂ ਦੇ ਰੂਪ ਵਿੱਚ AI ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ C/Arduino ਕੋਡ ਦੀ ਜਾਂਚ ਕਰਨ ਦੀ ਸਮਰੱਥਾ
• ਹਾਰਡਵੇਅਰ (ਔਸੀਲੋਸਕੋਪ, ਸੀਰੀਅਲ ਪੋਰਟ) 'ਤੇ ਮਾਪ ਕੇ ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਦੀ ਆਦਤ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਸਮਰੱਥਾ

ਏਮਬੈਡਡ ਸਿਸਟਮ ਡਿਵੈਲਪਮੈਂਟ ਉਹ ਹੈ ਜਿੱਥੇ ਸੌਫਟਵੇਅਰ ਅਤੇ ਹਾਰਡਵੇਅਰ ਆਪਸ ਵਿੱਚ ਮਿਲਦੇ ਹਨ: ਇੱਕ ਰਜਿਸਟਰ ਬਿੱਟ ਨੂੰ ਗਲਤ ਢੰਗ ਨਾਲ ਸੈੱਟ ਕਰਨਾ, ਇੱਕ ਰੁਕਾਵਟ ਨੂੰ ਬਹੁਤ ਲੰਮਾ ਰੱਖਣਾ, ਜਾਂ ਇੱਕ ਬਫਰ ਨੂੰ ਓਵਰਫਲੋ ਕਰਨਾ ਫੀਲਡ ਵਿੱਚ ਅਜੀਬ, ਮੁਸ਼ਕਲ-ਮੁੜ-ਪ੍ਰੋਡਿਊਸ ਅਸਫਲਤਾਵਾਂ ਦਾ ਕਾਰਨ ਬਣੇਗਾ, ਭਾਵੇਂ ਕੋਡ "ਕੰਪਾਇਲ" ਅਤੇ ਚੱਲਦਾ ਹੈ। AI ਸੱਚਮੁੱਚ ਇਸ ਖੇਤਰ ਵਿੱਚ ਇੱਕ ਐਕਸਲੇਟਰ ਹੈ; ਇਹ ਸ਼ੁਰੂਆਤੀ ਪਿੰਜਰ, ਹਾਰਡਵੇਅਰ ਐਬਸਟਰੈਕਸ਼ਨ ਫੰਕਸ਼ਨ, ਸਟੇਟ ਮਸ਼ੀਨਾਂ ਅਤੇ ਸੰਚਾਰ ਰੁਟੀਨ ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ। ਪਰ AI ਤੁਹਾਡੇ ਕਾਰਡ ਦੀ ਡੇਟਾਸ਼ੀਟ ਨੂੰ ਨਹੀਂ ਦੇਖਦਾ, ਤੁਹਾਡੀ ਘੜੀ ਦੀ ਬਾਰੰਬਾਰਤਾ ਨੂੰ ਨਹੀਂ ਜਾਣਦਾ, ਅਤੇ ਤੁਹਾਡੀ ਅਸਲ ਸਮੇਂ ਦੀਆਂ ਕਮੀਆਂ ਨੂੰ ਨਹੀਂ ਸਮਝਦਾ। ਇਸ ਯੂਨਿਟ ਵਿੱਚ, ਅਸੀਂ ਕਵਰ ਕਰਾਂਗੇ ਕਿ ਕਿਵੇਂ AI ਨੂੰ ਮਾਈਕ੍ਰੋਕੰਟਰੋਲਰ ਦੇ ਕੰਮ ਨੂੰ ਸਪਸ਼ਟ ਰੂਪ ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਹੈ, ਤਿਆਰ ਕੀਤੇ C/Arduino ਕੋਡ ਦੀ ਜਾਂਚ ਕਿਵੇਂ ਕਰਨੀ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ ਹਾਰਡਵੇਅਰ ਵਿੱਚ ਹਰ ਚੀਜ਼ ਨੂੰ ਕਿਉਂ ਮਾਪਣਾ ਚਾਹੀਦਾ ਹੈ।

ਲੋੜ ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ: ਰਜਿਸਟਰ, ਕੱਟਣਾ, ਸਮਾਂ

AI ਨੂੰ "ਇੱਕ LED ਰੋਸ਼ਨੀ" ਕਰਨ ਲਈ ਕਹਿਣਾ ਕੰਮ ਨਹੀਂ ਕਰੇਗਾ; ਕਿਹੜਾ ਕਾਰਡ, ਕਿਹੜਾ ਪਿੰਨ, ਕਿਹੜੀ ਘੜੀ ਦੀ ਬਾਰੰਬਾਰਤਾ, ਕਿਹੜਾ ਸਮਾਂ? ਏਆਈ ਨੂੰ ਏਮਬੈਡਡ ਕੰਮ ਸੌਂਪਣ ਵੇਲੇ, ਇਸ ਫਰੇਮਵਰਕ ਦੀ ਵਰਤੋਂ ਕਰੋ: ਹਾਰਡਵੇਅਰ (MCU ਪਰਿਵਾਰ, ਘੜੀ, ਪਿੰਨ), ਫੰਕਸ਼ਨ (ਕੀ ਹੋਵੇਗਾ), ਰੁਕਾਵਟ (ਸਮਾਂ, ਪਾਵਰ, ਮੈਮੋਰੀ), ਅਤੇ ਇੰਟਰਫੇਸ (ਰਜਿਸਟਰ, HAL, ਅਰਡਿਊਨੋ ਲਾਇਬ੍ਰੇਰੀ)।

ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ / ਮਜ਼ਬੂਤ ​​ਪ੍ਰੋਂਪਟ

ਕਮਜ਼ੋਰ: "STM32 ਨਾਲ PWM ਪੈਦਾ ਕਰੋ।" (ਨਤੀਜਾ: ਕਿਹੜਾ ਟਾਈਮਰ, ਕਿਹੜੀ ਬਾਰੰਬਾਰਤਾ, ਕਿਹੜੀ ਪਿੰਨ ਅਸਪਸ਼ਟ ਹੈ; ਆਮ, ਸ਼ਾਇਦ ਗਲਤ ਰਜਿਸਟਰ ਨਾਮਕ ਕੋਡ।) STRONG: "STM32F103 (72 MHz ਸਿਸਟਮ ਕਲਾਕ) ਲਈ TIM3 CH1 (PA6) 'ਤੇ 20 kHz, 0-100% ਵਿਵਸਥਿਤ ਡਿਊਟੀ PWM ਪੈਦਾ ਕਰੋ। 20 kHz ਗਣਨਾ ਕਰੋ ਅਤੇ 0-100 ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਫੰਕਸ਼ਨ ਪੈਰਾਮੀਟਰ ਸੈਟ ਕਰੋ - ਨੋਟ ਕਰੋ ਕਿ ਜੇਕਰ ਤੁਹਾਡੀ ਘੜੀ ਦੀ ਧਾਰਨਾ ਗਲਤ ਹੈ ਤਾਂ ਮੁੱਲ ਬਦਲ ਜਾਣਗੇ।

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

20 kHz PWM (72 MHz ਘੜੀ) ਲਈ: ਟਾਈਮਰ_ਕਲਾਕ = 72 MHz ਜੇਕਰ ਅਸੀਂ ਪ੍ਰੀਸਕੇਲਰ = 72-1 → ਕਾਊਂਟਰ ਕਲਾਕ = 1 MHzARR = (1 MHz / 20 kHz) - 1 = 50 - 1 = 49 ਪੁਸ਼ਟੀਕਰਨ: 1e6 / 020 = 020)

ਆਡਿਟਿੰਗ ਏਆਈ ਕੋਡ: ਕੀ ਭਾਲਣਾ ਹੈ?

ਸਿਰਫ਼ ਇਸ ਲਈ ਕਿ ਤਿਆਰ ਕੋਡ ਕੰਪਾਇਲ ਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਹੈ ਕਿ ਇਹ ਸਹੀ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ। ਇਸ ਚੈੱਕਲਿਸਟ ਦੀ ਪਾਲਣਾ ਕਰੋ:

ਕੰਟਰੋਲ ਖੇਤਰ

ਕੀ ਭਾਲਣਾ ਹੈ

ਰਜਿਸਟਰ/ਬਿੱਟ ਸੈਟਿੰਗ

ਡੇਟਾਸ਼ੀਟ ਦੇ ਨਾਲ ਬਿਲਕੁਲ ਅਨੁਕੂਲ, ਸਹੀ ਬਿੱਟ ਮਾਸਕ

ਰੁਕਾਵਟ (ISR)

ਕੀ ਇਹ ਛੋਟਾ ਹੈ? ਕੋਈ ਬਲੌਕਰ ਦੇਰੀ ਨਹੀਂ? ਕੀ ਅਸਥਿਰ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ?

ਬਫਰ/ਐਰੇ

ਕੀ ਬਾਰਡਰ ਕੰਟਰੋਲ ਹੈ? ਓਵਰਫਲੋ ਦਾ ਖਤਰਾ?

ਸਮਾਂ

ਦੇਰੀ ਜਾਂ ਟਾਈਮਰ ਨਾਲ? ਕੀ ਅਸਲ ਸਮੇਂ ਦੀ ਪਾਬੰਦੀ ਪੂਰੀ ਹੋਈ ਹੈ?

ਕਿਸਮ ਅਤੇ ਚੌੜਾਈ

8/16/32-ਬਿੱਟ ਓਵਰਫਲੋ, ਹਸਤਾਖਰਿਤ/ਹਸਤਾਖਰਿਤ ਉਲਝਣ

ਪਾਵਰ/ਵਾਚਡੌਗ

ਅਨੰਤ ਲੂਪ ਫੀਡਿੰਗ ਵਾਚਡੌਗ?

ਇੰਟਰੱਪਟ ਸਰਵਿਸ ਰੂਟੀਨ (ISR) ਤਰੁੱਟੀਆਂ ਦਾ ਸਭ ਤੋਂ ਆਮ ਸਰੋਤ ਹਨ। AI ਕਈ ਵਾਰ ISR ਦੇ ਅੰਦਰ ਦੇਰੀ() ਜਾਂ ਲੰਬੀ ਲੂਪ ਰੱਖਦਾ ਹੈ। ਇਸ ਨਾਲ ਹੋਰ ਰੁਕਾਵਟਾਂ ਖੁੰਝ ਜਾਂਦੀਆਂ ਹਨ ਅਤੇ ਵਾਚਡੌਗ ਰੀਸੈੱਟ ਹੁੰਦੇ ਹਨ। ਨਿਯਮ: ISR ਜਿੰਨਾ ਸੰਭਵ ਹੋ ਸਕੇ ਛੋਟਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ; ਮੁੱਖ ਕੰਮ ਇੱਕ ਝੰਡਾ ਸਥਾਪਤ ਕਰਨਾ ਅਤੇ ਇਸਨੂੰ ਮੁੱਖ ਲੂਪ ਵਿੱਚ ਲਿਜਾਣਾ ਚਾਹੀਦਾ ਹੈ.

// ਕਮਜ਼ੋਰ (AI ਕਈ ਵਾਰ ਇਹ ਪੈਦਾ ਕਰਦਾ ਹੈ): ISR void TIM3_IRQHandler(void) { if (TIM3->SR & TIM_SR_UIF) { TIM3->SR &= ~TIM_SR_UIF; read_sensor(); // ਲੰਮਾ ਸਮਾਂ ਲੱਗ ਸਕਦਾ ਹੈ - BAD CASE_Delay(10); // ISR ਵਿੱਚ ਦੇਰੀ - ਬਹੁਤ ਬੁਰਾ }}// ਮਜ਼ਬੂਤ: ISR ਛੋਟਾ; ਨੌਕਰੀ ਮੁੱਖ ਲੂਪਵੋਲੇਟਾਈਲ uint8_t ਟਿੱਕ_ਫਲੈਗ = 0 'ਤੇ ਚਲੀ ਜਾਂਦੀ ਹੈ; // ਅਸਥਿਰ CONDITIONvoid TIM3_IRQHandler(void) { if (TIM3->SR & TIM_SR_UIF) { TIM3->SR &= ~TIM_SR_UIF; ਟਿਕ_ਫਲੈਗ = 1; //ਸਿਰਫ ਫਲੈਗ ਸੈੱਟ ਕਰੋ }}// ਮੁੱਖ ਲੂਪ ਵਿੱਚ: ਜੇਕਰ (ਟਿਕ_ਫਲੈਗ) {ਟਿਕ_ਫਲੈਗ = 0; read_sensor(); }

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

ਬਫਰ ਓਵਰਫਲੋ ਅਤੇ ਟਾਈਪ ਗਲਤੀਆਂ

AI ਸੀਰੀਅਲ ਪੋਰਟ ਤੋਂ ਬਿਨਾਂ ਸੀਮਾ ਦੀ ਜਾਂਚ ਕੀਤੇ ਇੱਕ ਫਿਕਸਡ-ਸਾਈਜ਼ ਐਰੇ ਵਿੱਚ ਡਾਟਾ ਕਾਪੀ ਕਰ ਸਕਦਾ ਹੈ। ਇੱਕ ਏਮਬੈਡਡ ਸਿਸਟਮ ਵਿੱਚ, ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਲਗਾਤਾਰ ਮੈਮੋਰੀ ਅਤੇ ਅਣਜਾਣ ਕ੍ਰੈਸ਼ਾਂ ਨੂੰ ਕੁਚਲਣਾ। ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਹਰੇਕ strcpy, ਐਰੇ ਇੰਡੈਕਸ ਅਤੇ DMA ਬਫਰ 'ਤੇ ਸੀਮਾ ਦੀ ਜਾਂਚ ਕੀਤੀ ਗਈ ਹੈ। ਇਸੇ ਤਰ੍ਹਾਂ, ਇੱਕ 8-ਬਿੱਟ ਕਾਊਂਟਰ 255 ਤੋਂ ਬਾਅਦ ਰੀਸੈਟ ਹੁੰਦਾ ਹੈ; AI ਇਸ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਇੱਕ ਓਵਰਫਲੋ ਖਾਤੇ 'ਤੇ ਭਰੋਸਾ ਕਰ ਸਕਦਾ ਹੈ।

ਹਾਰਡਵੇਅਰ ਵਿੱਚ ਤਸਦੀਕ: "ਵਰਕਿੰਗ" ਮਾਪੀ ਜਾਂਦੀ ਹੈ, ਮੰਨੀ ਨਹੀਂ ਜਾਂਦੀ

ਏਮਬੈਡਡ ਸਿਸਟਮ ਵਿੱਚ, ਸਭ ਤੋਂ ਭਰੋਸੇਮੰਦ ਸਬੂਤ ਮੀਟਰ ਹੈ, ਕੰਪਾਈਲਰ ਨਹੀਂ। ਇਹਨਾਂ ਤਿੰਨ ਤਰੀਕਿਆਂ ਨਾਲ ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ:

1. ਔਸਿਲੋਸਕੋਪ/ਤਰਕ ਵਿਸ਼ਲੇਸ਼ਕ: PWM ਬਾਰੰਬਾਰਤਾ, ਸਿਗਨਲ ਟਾਈਮਿੰਗ ਅਤੇ ਸੰਚਾਰ ਵੇਵਫਾਰਮ ਨੂੰ ਮਾਪੋ। ਜੇਕਰ ਤੁਸੀਂ 20 kHz ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਸਕ੍ਰੀਨ 'ਤੇ 20 kHz ਦੇਖੋ।
2. ਸੀਰੀਅਲ ਪੋਰਟ (UART) ਲੌਗ: ਵੇਰੀਏਬਲ ਵੈਲਯੂਜ਼, ਸਟੇਟ ਪਰਿਵਰਤਨ, ਅਤੇ ਗਲਤੀ ਕਾਊਂਟਰਾਂ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰੋ ਅਤੇ ਉਮੀਦ ਕੀਤੇ ਵਿਹਾਰ ਨਾਲ ਤੁਲਨਾ ਕਰੋ।
3. ਬਾਊਂਡ ਅਤੇ ਤਣਾਅ ਟੈਸਟਿੰਗ: ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਸਿਸਟਮ ਸਭ ਤੋਂ ਵੱਧ ਲੋਡ, ਸਭ ਤੋਂ ਤੇਜ਼ ਡਾਟਾ ਅਤੇ ਸਭ ਤੋਂ ਖਰਾਬ ਸਮੇਂ ਦੇ ਅਧੀਨ ਹੈ ਜਾਂ ਨਹੀਂ।

ਜੇਕਰ ਮਾਪਿਆ ਮੁੱਲ ਗਣਨਾ ਨਾਲ ਸਹਿਮਤ ਨਹੀਂ ਹੁੰਦਾ, ਤਾਂ ਘੜੀ ਦੀ ਧਾਰਨਾ, ਪ੍ਰੀਸਕੇਲਰ ਮੁੱਲ ਜਾਂ ਰਜਿਸਟਰ ਸੈਟਿੰਗ ਗਲਤ ਹੈ; ਪਿੱਛਾ

ਮਿੰਨੀ ਕੇਸ

ਵਿਦਿਆਰਥੀਆਂ ਦੀ ਇੱਕ ਟੀਮ ਕੋਲ ਇੱਕ HC-SR04 ਅਲਟਰਾਸੋਨਿਕ ਸੈਂਸਰ ਨਾਲ ਇੱਕ ਦੂਰੀ ਮਾਪ ਕੋਡ ਨੂੰ AI ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ। ਕੋਡ ਕੰਪਾਇਲ ਕਰਦਾ ਹੈ ਪਰ ਦੂਰੀ ਹਮੇਸ਼ਾ ਹਾਸੋਹੀਣੇ ਮੁੱਲ ਦਿੰਦੀ ਹੈ। ਜਦੋਂ ਉਹ ਇਸਨੂੰ ਔਸੀਲੋਸਕੋਪ ਨਾਲ ਜੋੜਦੇ ਹਨ, ਤਾਂ ਉਹ ਦੇਖਦੇ ਹਨ ਕਿ ਈਕੋ ਲੇਗ ਮਾਈਕ੍ਰੋਸਕਿੰਡ ਦੀ ਬਜਾਏ ਮਿਲੀਸਕਿੰਟ ਵਿੱਚ ਆਪਣੇ ਸਮੇਂ ਦੀ ਗਣਨਾ ਕਰਦੀ ਹੈ; AI ਨੇ micros() ਦੀ ਬਜਾਏ millis() ਦੀ ਵਰਤੋਂ ਕੀਤੀ। ਇਸ ਇੱਕ-ਸ਼ਬਦ ਦੀ ਗਲਤੀ ਨੇ 1000 ਦੇ ਇੱਕ ਫੈਕਟਰ ਦੁਆਰਾ ਪੂਰੇ ਮਾਪ ਨੂੰ ਉਲਝਾ ਦਿੱਤਾ। ਜਦੋਂ ਉਹ ਸੀਰੀਅਲ ਲੌਗ ਵਿੱਚ ਕੱਚੇ ਈਕੋ ਟਾਈਮ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦੇ ਹਨ ਅਤੇ ਇਸਦੀ ਅਸਲ ਸ਼ਾਸਕ ਨਾਲ ਤੁਲਨਾ ਕਰਦੇ ਹਨ, ਤਾਂ ਉਹ ਗਲਤੀ ਲੱਭਦੇ ਹਨ ਅਤੇ ਇਸਨੂੰ ਠੀਕ ਕਰਦੇ ਹਨ। ਪਾਠ: ਸੰਕਲਿਤ ਕੋਡ ਸਹੀ ਕੋਡ ਨਹੀਂ ਹੈ; ਹਾਰਡਵੇਅਰ ਵਿੱਚ ਮਾਪ ਤੁਰੰਤ ਗਲਤੀ ਨੂੰ ਪ੍ਰਗਟ ਕਰਦਾ ਹੈ.

ਆਮ ਗਲਤੀਆਂ

• ਰਜਿਸਟਰ ਨਾਮ ਅਤੇ ਬਿੱਟ ਮਾਸਕ ਨੂੰ ਡੇਟਾਸ਼ੀਟ ਨਾਲ ਤੁਲਨਾ ਕੀਤੇ ਬਿਨਾਂ ਸਵੀਕਾਰ ਕਰਨਾ।
• ISR ਦੇ ਅੰਦਰ ਬਲਾਕਿੰਗ ਦੇਰੀ ਜਾਂ ਲੰਬੀ ਪ੍ਰਕਿਰਿਆ ਦੀ ਆਗਿਆ ਦੇਣਾ.
• ਸਾਂਝੇ ਵੇਰੀਏਬਲਾਂ 'ਤੇ ਅਸਥਿਰਤਾ ਨੂੰ ਭੁੱਲਣਾ।
• ਬਾਈਪਾਸ ਬਫਰ ਅਤੇ ਐਰੇ ਸੀਮਾਵਾਂ ਦੀ ਜਾਂਚ; ਓਵਰਫਲੋ ਨਹੀਂ ਦੇਖ ਰਿਹਾ।
• ਘੜੀ ਦੀ ਬਾਰੰਬਾਰਤਾ ਅਤੇ ਸਮੇਂ ਦੀਆਂ ਧਾਰਨਾਵਾਂ ਦੀ ਪੁਸ਼ਟੀ ਕੀਤੇ ਬਿਨਾਂ ਉਹਨਾਂ 'ਤੇ ਭਰੋਸਾ ਕਰਨਾ।
• ਕੋਡ ਨੂੰ ਇੱਕ ਔਸਿਲੋਸਕੋਪ/ਸੀਰੀਅਲ ਲੌਗ ਨਾਲ ਮਾਪੇ ਬਿਨਾਂ "ਵਰਕਿੰਗ" 'ਤੇ ਵਿਚਾਰ ਕਰਨਾ।

ਸੰਖੇਪ ਵਿੱਚ

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

ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਕੰਮ

ਤੁਹਾਡੇ ਕੋਲ ਮੌਜੂਦ ਮਾਈਕ੍ਰੋਕੰਟਰੋਲਰ (Arduino, STM32, ESP32) ਨਾਲ, AI ਨੂੰ PWM ਜਾਂ ਇੱਕ ਨਿਸ਼ਚਿਤ ਬਾਰੰਬਾਰਤਾ 'ਤੇ ਇੱਕ ਨਿਯਮਿਤ ਕੰਮ ਲਈ ਪੁੱਛੋ। ਕੋਡ ਨੂੰ ਲੋਡ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ: (1) ਟਿੱਪਣੀ ਲਾਈਨ ਵਿੱਚ ਖਾਤੇ ਤੋਂ ਸੁਤੰਤਰ ਤੌਰ 'ਤੇ ਬਾਰੰਬਾਰਤਾ/ਸਮੇਂ ਦੇ ਮੁੱਲਾਂ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ, (2) ISR ਅਤੇ ਸਾਂਝੇ ਵੇਰੀਏਬਲ ਵਿੱਚ ਅਸਥਿਰ ਅਤੇ ਬਲਾਕਿੰਗ ਦੀ ਜਾਂਚ ਕਰੋ। ਅਪਲੋਡ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਔਸਿਲੋਸਕੋਪ ਜਾਂ ਤਰਕ ਵਿਸ਼ਲੇਸ਼ਕ ਨਾਲ ਅਸਲ ਬਾਰੰਬਾਰਤਾ ਨੂੰ ਮਾਪੋ ਅਤੇ ਟੀਚੇ ਨਾਲ ਤੁਲਨਾ ਕਰੋ। ਜੇਕਰ ਕੋਈ ਭਟਕਣਾ ਹੈ, ਤਾਂ ਸਰੋਤ ਲੱਭੋ ਅਤੇ ਇਸਨੂੰ ਠੀਕ ਕਰੋ, ਅਤੇ ਨੋਟ ਕਰੋ ਕਿ ਕੀ ਗਲਤ ਮੰਨਿਆ ਗਿਆ ਸੀ।