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

ਲਾਭ:

• AI ਨਾਲ Arduino/STM32/ESP32 ਲਈ ਦਿੱਤੇ ਗਏ ਰਜਿਸਟਰ ਅਤੇ ਹਾਰਡਵੇਅਰ ਸੰਦਰਭ ਵਿੱਚ ਏਮਬੈਡਡ ਕੋਡ ਤਿਆਰ ਕਰਨ ਦੀ ਸਮਰੱਥਾ
• ਏਆਈ ਆਉਟਪੁੱਟ ਵਿੱਚ ਏਮਬੈਡਡ ਪੈਟਰਨਾਂ ਜਿਵੇਂ ਕਿ ਇੰਟਰੱਪਟਸ, ਟਾਈਮਰ ਅਤੇ ਗੈਰ-ਬਲਾਕਿੰਗ ਲੂਪਸ ਨੂੰ ਪਛਾਣਨ ਅਤੇ ਠੀਕ ਕਰਨ ਦੀ ਸਮਰੱਥਾ
• ਹਾਰਡਵੇਅਰ 'ਤੇ ਅੱਪਲੋਡ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਮੈਮੋਰੀ, ਰੀਅਲ-ਟਾਈਮ ਅਤੇ ਸੁਰੱਖਿਆ ਦੇ ਰੂਪ ਵਿੱਚ ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਦੀ ਸਮੀਖਿਆ ਕਰਨ ਦੀ ਸਮਰੱਥਾ

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

ਸ਼ੁੱਧ ਸਾਫਟਵੇਅਰ ਤੋਂ ਏਮਬੈਡਡ ਕੋਡ ਦਾ ਅੰਤਰ

ਇੱਕ ਡੈਸਕਟੌਪ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਬਹੁਤ ਸਾਰੀ ਮੈਮੋਰੀ, ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਅਤੇ ਡੀਬੱਗਿੰਗ ਦੀ ਸੌਖ ਹੁੰਦੀ ਹੈ। ਏਮਬੈਡਡ ਕੋਡ ਵਿੱਚ ਇਹਨਾਂ ਵਿੱਚੋਂ ਜ਼ਿਆਦਾਤਰ ਦੀ ਘਾਟ ਹੈ:

ਆਕਾਰ

ਡੈਸਕਟਾਪ

ਏਮਬੈਡਡ ਸਿਸਟਮ

ਮੈਮੋਰੀ

GB ਪੱਧਰ

KB ਪੱਧਰ (ਜਿਵੇਂ ਕਿ RAM ਦਾ 2 KB)

ਸਮਾਂ

ਆਮ ਤੌਰ 'ਤੇ ਲਚਕਦਾਰ

ਤੰਗ, ਅਸਲ ਸਮਾਂ

ਡੀਬੱਗਿੰਗ

ਆਸਾਨ (ਡੀਬਗਰ, ਲੌਗ)

ਹਾਰਡ (JTAG, ਸੀਰੀਅਲ, LED)

ਗਲਤੀ ਨਤੀਜਾ

ਪ੍ਰੋਗਰਾਮ ਕਰੈਸ਼ ਹੋ ਜਾਂਦਾ ਹੈ

ਐਕਟੁਏਟਰ/ਹਾਰਡਵੇਅਰ ਨੂੰ ਨੁਕਸਾਨ ਹੋ ਸਕਦਾ ਹੈ

ਸਰੋਤ ਪਹੁੰਚ

OS ਐਬਸਟਰੈਕਟ

ਰਜਿਸਟਰ ਤੱਕ ਸਿੱਧੀ ਪਹੁੰਚ

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

ਬਲੌਕਰ ਬਨਾਮ ਗੈਰ-ਬਲਾਕਿੰਗ ਕੋਡ

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

// BAD: ਬਲੌਕਰ -- ਪ੍ਰੋਸੈਸਰ 1 ਸਕਿੰਟ ਵਾਇਡ ਲੂਪ () { digitalWrite(LED, HIGH) ਲਈ ਕੋਈ ਹੋਰ ਕੰਮ ਨਹੀਂ ਕਰ ਸਕਦਾ ਹੈ; ਦੇਰੀ(1000); // ਸਭ ਕੁਝ ਡਿਜੀਟਲ ਰਾਈਟ (LED, LOW) ਨੂੰ ਰੋਕਦਾ ਹੈ; ਦੇਰੀ(1000); // ਇੱਕ ਐਮਰਜੈਂਸੀ ਬਟਨ ਨੂੰ ਇਸ ਸਮੇਂ ਪੜ੍ਹਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ ਹੈ!}// ਚੰਗਾ: ਨਾਨ-ਬਲਾਕਿੰਗ -- ਲੂਪ ਬਲੌਕ ਨਹੀਂ ਹੈ, ਹੋਰ ਕੰਮ ਚੱਲਦੇ ਹਨ ਜੇਕਰ (ਹੁਣ ਐਮਐਸ - ਪਿਛਲੀਆਂMs >= ਅੰਤਰਾਲ) { previousMs = nowMs; ledStatus = !ledStatus; ਡਿਜੀਟਲ ਰਾਈਟ (LED, ledStatus); } buttonCheck(); // ਹਰੇਕ ਚੱਕਰ ਸੈਂਸਰ ਰੀਡ () ਵਿੱਚ ਚੱਲ ਸਕਦਾ ਹੈ; //ਕਿਸੇ ਵੀ ਲੂਪ ਵਿੱਚ ਚੱਲ ਸਕਦਾ ਹੈ}

ਗੈਰ-ਬਲਾਕ ਕਰਨ ਵਾਲਾ ਪੈਟਰਨ ਏਮਬੈਡਡ ਮੇਕੈਟ੍ਰੋਨਿਕਸ ਦਾ ਆਧਾਰ ਹੈ: ਕੰਟਰੋਲ ਲੂਪ ਲਗਾਤਾਰ ਵਹਿੰਦਾ ਹੈ, ਕੋਈ ਵੀ ਕੰਮ ਦੂਜੇ ਨੂੰ ਬੰਦ ਨਹੀਂ ਕਰਦਾ। AI ਨੂੰ ਦੱਸਣਾ ਕਿ "ਦੇਰੀ ਨਾ ਕਰੋ, ਮਿਲਿਸ-ਅਧਾਰਿਤ ਨਾਨ-ਬਲੌਕਿੰਗ ਲਿਖੋ" ਜਦੋਂ ਕੋਡ ਲਿਖਣਾ ਸਿੱਧਾ ਆਉਟਪੁੱਟ ਦੀ ਗੁਣਵੱਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦਾ ਹੈ।

ਸੰਕੇਤ: ਦੇਰੀ ਲਈ ਵੇਖੋ (AI ਤੋਂ ਏਮਬੈਡਡ ਕੋਡ ਵਿੱਚ। ਜੇਕਰ ਤੁਸੀਂ ਮੁੱਖ ਕੰਟਰੋਲ ਲੂਪ ਵਿੱਚ ਦੇਰੀ ਦੇਖਦੇ ਹੋ, ਤਾਂ ਅਕਸਰ ਉਹ ਕੋਡ ਅਸਲ-ਸਮੇਂ ਦੇ ਸਿਸਟਮ ਲਈ ਢੁਕਵਾਂ ਨਹੀਂ ਹੁੰਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਦੁਬਾਰਾ ਲਿਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

ਰੁਕਾਵਟਾਂ ਅਤੇ ਟਾਈਮਰ

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

ਅਸਥਿਰ ਲੰਬੇ ਐਨਕੋਡਰਕਾਊਂਟਰ = 0; // ISR ਅਤੇ ਲੂਪ ਸਾਂਝੇ ਕੀਤੇ ਗਏ ਹਨ -> ਅਸਥਿਰ ਸਥਿਤੀ void enkoderISR() {// ਛੋਟਾ ISR: ਸਿਰਫ਼ ਗਿਣਤੀ ਕਰੋ, ਕੋਈ ਹੋਰ ਕੰਮ ਨਾ ਕਰੋ ਜੇ (digitalRead(ENC_B)) enkoderCounter++; else encoderCounter--;} void setup() { pinMode(ENC_A, INPUT_PULLUP); ਪਿਨਮੋਡ(ENC_B, INPUT_PULLUP); attachInterrupt(digitalPinToInterrupt(ENC_A), enkoderISR, RISING);}void loop() { long counter; ਕੋਈ ਰੁਕਾਵਟ ਨਹੀਂ (); // ਪਰਮਾਣੂ ਰੀਡਿੰਗ ਕਾਊਂਟਰ = ਏਨਕੋਡਰਕਾਊਂਟਰ ਲਈ ਛੋਟਾ ਰੁਕਾਵਟ; ਰੁਕਾਵਟਾਂ (); //ਕਾਊਂਟਰ ਨਾਲ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਲੈਣ-ਦੇਣ ਕਰੋ...}

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ ਤਿੰਨ ਨਾਜ਼ੁਕ ਬਿੰਦੂ ਹਨ ਜਿੱਥੇ AI ਅਕਸਰ ਖੁੰਝ ਜਾਂਦਾ ਹੈ: (1) ਸਾਂਝਾ ਐਨਕੋਡਰਕਾਊਂਟਰ ਲਾਜ਼ਮੀ ਤੌਰ 'ਤੇ `ਅਸਥਿਰ` ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜਾਂ ਕੰਪਾਈਲਰ ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਅੱਪਡੇਟ ਤੋਂ ਖੁੰਝ ਜਾਵੇਗਾ; (2) ISR ਛੋਟਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ; (3) ਮੁੱਖ ਲੂਪ ਵਿੱਚ ਮਲਟੀ-ਬਾਈਟ ਵੇਰੀਏਬਲ ਨੂੰ ਪੜ੍ਹਦੇ ਸਮੇਂ, ਪਰਮਾਣੂ ਰੀਡਿੰਗ ਲਈ ਰੁਕਾਵਟਾਂ ਨੂੰ ਥੋੜ੍ਹੇ ਸਮੇਂ ਲਈ ਬੰਦ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਨਹੀਂ ਤਾਂ ISR ਰੀਡਿੰਗ ਦੌਰਾਨ ਦਖਲ ਦੇ ਸਕਦਾ ਹੈ ਅਤੇ ਅੱਧਾ/ਭ੍ਰਿਸ਼ਟ ਮੁੱਲ ਪੜ੍ਹਿਆ ਜਾ ਸਕਦਾ ਹੈ (ਰੇਸ ਕੰਡੀਸ਼ਨ)। ਇਹ ਜਾਂਚ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਕੀ ਇਹ ਤਿੰਨ AI ਕੋਡ ਵਿੱਚ ਮੌਜੂਦ ਹਨ।

ਸ਼ੁੱਧਤਾ ਅਤੇ ਡੇਟਾਸ਼ੀਟ ਰਜਿਸਟਰ ਕਰੋ

AI ਭਰੋਸੇਯੋਗ ਤੌਰ 'ਤੇ ਇੱਕ ਸੈਂਸਰ ਦੇ ਰਜਿਸਟਰ ਪਤੇ ਜਾਂ MCU ਦੇ ਸੰਰਚਨਾ ਬਿੱਟ ਨੂੰ ਗਲਤ ਢੰਗ ਨਾਲ ਪੇਸ਼ ਕਰ ਸਕਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ MPU6050 IMU ਦਾ ਪਾਵਰ ਪ੍ਰਬੰਧਨ ਰਜਿਸਟਰ 0x6B ਹੈ; ਜੇਕਰ AI ਇਸ ਨੂੰ 0x6A ਦੇ ਤੌਰ 'ਤੇ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਕੋਡ ਕੰਪਾਇਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਇਹ ਕੰਮ ਕਰਨ ਲੱਗਦਾ ਹੈ, ਪਰ ਸੈਂਸਰ ਨਹੀਂ ਜਾਗਦਾ। ਡਾਟਾਸ਼ੀਟ ਦੀ ਤੁਲਨਾ ਕਰਨ 'ਤੇ ਹੀ ਅਜਿਹੀਆਂ ਗਲਤੀਆਂ ਦਾ ਪਤਾ ਲਗਾਇਆ ਜਾਂਦਾ ਹੈ।

// MPU6050 ਵੇਕ-ਅੱਪ: ਡੇਟਾਸ਼ੀਟ PWR_MGMT_1 = 0x6B ਦੇ ਅਨੁਸਾਰ, ਮੁੱਲ 0x00#define MPU_ADDR 0x68#define PWR_MGMT_1 0x6B // <-- ਤਸਦੀਕ ਕਰੋ datasheetWire.beginTransmission(MPU_ADDR);Wire.write(PWR_MGMT_1);Wire.write(0x00); // ਨੀਂਦ modeWire.endTransmission(true);

ਧਿਆਨ ਦਿਓ: ਡੇਟਾਸ਼ੀਟ ਤੋਂ AI ਦੁਆਰਾ ਦਿੱਤੇ ਹਰੇਕ ਰਜਿਸਟਰ ਪਤੇ, ਬਿੱਟ ਮਾਸਕ ਅਤੇ I2C/SPI ਪਤੇ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ। ਇਹ ਮੁੱਲ ਕਾਰਡ ਅਤੇ ਚਿੱਪ ਖਾਸ ਹਨ; AI "ਯਾਦ" ਦਾ ਮੁੱਲ ਕਿਸੇ ਹੋਰ ਚਿੱਪ ਸੰਸ਼ੋਧਨ ਤੋਂ ਹੋ ਸਕਦਾ ਹੈ। ਗਲਤ ਰਜਿਸਟਰ ਚੁੱਪਚਾਪ ਗਲਤ ਵਿਹਾਰ ਵੱਲ ਖੜਦਾ ਹੈ।

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

ਕਮਜ਼ੋਰ:"ESP32 'ਤੇ ਤਾਪਮਾਨ ਸੈਂਸਰ ਪੜ੍ਹੋ।"(ਕੌਣ ਸੈਂਸਰ? ਕਿਹੜਾ ਪ੍ਰੋਟੋਕੋਲ? ਕਿਹੜਾ ਪਿੰਨ? ਆਮ, ਸ਼ਾਇਦ ਗਲਤ ਕੋਡ।)STRONG:"OneWire ਦੇ ਨਾਲ GPIO4 ਤੋਂ ESP32 (Arduino ਫਰੇਮਵਰਕ) 'ਤੇ DS18B20 ਤਾਪਮਾਨ ਸੈਂਸਰ ਪੜ੍ਹੋ। ਗੈਰ-ਬਲੌਕਿੰਗ ਲਿਖੋ, ਹਰ ਇੱਕ ਨਮੂਨਾ, ਡੀ-ਮਿਲੀਸ ਬੇਸਲੇਅਸ ਏਰਰ। ਪੜ੍ਹਨ ਦੀ ਗਲਤੀ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਫਲੈਗ (ਸਥਿਰ ਮੁੱਲ -127 ਜਾਂ 85) ਕਿਰਪਾ ਕਰਕੇ ਹਰ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਅਤੇ ਪਿੰਨ ਕਨੈਕਸ਼ਨ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰੋ ਜੋ ਤੁਸੀਂ ਪਹਿਲੀ ਟਿੱਪਣੀ ਵਿੱਚ ਵਰਤਦੇ ਹੋ, ਸਟ੍ਰਿੰਗ ਦੀ ਬਜਾਏ ਚਾਰ ਬਫਰ ਦੀ ਵਰਤੋਂ ਕਰੋ।"

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

ਏਮਬੈਡਡ ਕੋਡ ਲਈ ਚੈੱਕਲਿਸਟ ਦੀ ਸਮੀਖਿਆ ਕਰੋ

AI ਆਉਟਪੁੱਟ ਨੂੰ ਲੋਡ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਇਸਨੂੰ ਇਸ ਸੂਚੀ ਵਿੱਚੋਂ ਪਾਸ ਕਰੋ:

1. ਬਲਾਕਿੰਗ: ਕੀ ਮੁੱਖ ਲੂਪ ਵਿੱਚ ਕੋਈ ਦੇਰੀ ਜਾਂ ਲੰਮੀ ਬਲਾਕਿੰਗ ਹੈ?
2. ਅਸਥਿਰ: ਕੀ ਵੇਰੀਏਬਲ ISR ਅਸਥਿਰ ਹਨ?
3. ਪਰਮਾਣੂ ਪਹੁੰਚ: ਕੀ ਮਲਟੀ-ਬਾਈਟ ਸਾਂਝਾ ਵੇਰੀਏਬਲ ਪੜ੍ਹਨ ਲਈ ਸੁਰੱਖਿਅਤ ਹੈ?
4. ਰਜਿਸਟਰ ਕਰੋ: ਕੀ ਪਤੇ ਅਤੇ ਬਿੱਟ ਮਾਸਕ ਡੇਟਾਸ਼ੀਟ ਦੇ ਅਨੁਕੂਲ ਹਨ?
5. ਮੈਮੋਰੀ: ਸਟ੍ਰਿੰਗ, ਵੱਡੇ ਐਰੇ, ਕੀ ਰੀਕਰਸ਼ਨ KB ਲੈਵਲ ਓਵਰਫਲੋ ਬਣਾਉਂਦਾ ਹੈ?
6. ਗਲਤੀ ਹੈਂਡਲਿੰਗ: ਕੀ ਸੈਂਸਰ ਰੀਡਿੰਗ ਗਲਤੀਆਂ, ਸੰਚਾਰ ਟਾਈਮਆਉਟ ਨੂੰ ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ?
7. ਸੁਰੱਖਿਅਤ ਸ਼ੁਰੂਆਤ: ਕੀ ਐਕਟੁਏਟਰ ਆਉਟਪੁੱਟ ਸਟਾਰਟਅਪ 'ਤੇ ਸੁਰੱਖਿਅਤ (ਪੈਸਿਵ) ਸਥਿਤੀ ਵਿੱਚ ਰੱਖੇ ਗਏ ਹਨ?

ਮਿੰਨੀ ਕੇਸ

ਏਮਬੈਡਡ ਸਿਸਟਮ ਇੰਜੀਨੀਅਰ ਬਾਰਨ ਕੋਲ ਏਆਈ ਕੋਡ ਲਿਖਦਾ ਹੈ ਜੋ ਡਰੋਨ ਲਈ IMU ਪੜ੍ਹਦਾ ਹੈ। ਕੋਡ ਕੰਪਾਇਲ ਕਰਦਾ ਹੈ ਅਤੇ ਕੰਮ ਕਰਦਾ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ, ਪਰ ਕੋਣ ਮੁੱਲ ਅਰਥਹੀਣ ਹਨ। ਬਾਰਨ ਚੈਕਲਿਸਟ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ: ਡੈਟਾਸ਼ੀਟ ਨਾਲ ਰਜਿਸਟਰ ਪਤਿਆਂ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ ਅਤੇ ਪਤਾ ਕਰਦਾ ਹੈ ਕਿ AI ਗਲਤ ਢੰਗ ਨਾਲ ਜਾਇਰੋਸਕੋਪ ਕੌਂਫਿਗਰੇਸ਼ਨ ਰਜਿਸਟਰ (0x1B ਦੀ ਬਜਾਏ 0x1A) ਨੂੰ ਆਉਟਪੁੱਟ ਕਰਦਾ ਹੈ, ਇਸਲਈ ਸੰਵੇਦਨਸ਼ੀਲਤਾ ਪੈਮਾਨਾ ਗਲਤ ਹੈ। ਇੱਕ ਵਾਰ ਠੀਕ ਹੋ ਜਾਣ ਤੇ, ਮੁੱਲ ਸੈਟਲ ਹੋ ਜਾਂਦੇ ਹਨ। ਫਿਰ ਮੁੱਖ ਲੂਪ ਵਿੱਚ ਦੇਰੀ(10) ਨੋਟਿਸ; ਇਸ ਨੂੰ ਮਿਲਿਸ-ਅਧਾਰਿਤ ਢਾਂਚੇ ਵਿੱਚ ਬਦਲਣਾ, ਕਿਉਂਕਿ ਫਲਾਈਟ ਕੰਟਰੋਲ ਲੂਪ ਨੂੰ ਬਲੌਕ ਕਰਨਾ ਅਸਵੀਕਾਰਨਯੋਗ ਹੈ। ਅੰਤ ਵਿੱਚ, ਇਹ ਵੇਖਦਾ ਹੈ ਕਿ ਸਾਂਝਾ ਕਾਊਂਟਰ ਵੇਰੀਏਬਲ ਅਸਥਿਰ ਨਹੀਂ ਹੈ ਅਤੇ ਇਸਨੂੰ ਜੋੜਦਾ ਹੈ। AI ਨੇ ਪਿੰਜਰ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਦਿੱਤਾ; ਪਰ ਸਮੀਖਿਆ ਸੂਚੀ ਵਿੱਚ ਤਿੰਨ ਵੱਖ-ਵੱਖ ਗਲਤੀਆਂ ਫੜੀਆਂ ਗਈਆਂ: ਰਜਿਸਟਰ, ਬਲਾਕਿੰਗ ਅਤੇ ਅਸਥਿਰ, ਅਤੇ ਹਾਰਡਵੇਅਰ ਨੂੰ ਬਿਲਕੁਲ ਵੀ ਖਤਰਾ ਨਹੀਂ ਸੀ।

ਆਮ ਗਲਤੀਆਂ

• ਮੁੱਖ ਕੰਟਰੋਲ ਲੂਪ ਵਿੱਚ delay() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਸਲ-ਸਮੇਂ ਦੇ ਜਵਾਬ ਨੂੰ ਖਤਮ ਕਰਨਾ।
• ISR ਨਾਲ ਸਾਂਝੇ ਕੀਤੇ ਵੇਰੀਏਬਲ ਨੂੰ ਅਸਥਿਰ ਬਣਾਉਣ ਅਤੇ ਚੁੱਪ ਡਾਟਾ ਭ੍ਰਿਸ਼ਟਾਚਾਰ ਦਾ ਅਨੁਭਵ ਕਰਨ ਤੋਂ ਬਚੋ।
• ਇੱਕ ਮਲਟੀ-ਬਾਈਟ ਸ਼ੇਅਰਡ ਵੇਰੀਏਬਲ ਨੂੰ ਗੈਰ-ਪ੍ਰਮਾਣੂ ਰੂਪ ਵਿੱਚ ਪੜ੍ਹਨਾ ਅਤੇ ਇੱਕ ਰੇਸ ਕੰਡੀਸ਼ਨ ਤਿਆਰ ਕਰਨਾ।
• ਡੇਟਾਸ਼ੀਟ ਦੇ ਨਾਲ ਏਆਈ ਦੁਆਰਾ ਦਿੱਤੇ ਗਏ ਰਜਿਸਟਰ/ਬਿਟ ਮਾਸਕ ਦੀ ਪੁਸ਼ਟੀ ਨਹੀਂ ਕੀਤੀ ਜਾ ਰਹੀ।
• ਸੀਮਤ RAM ਵਿੱਚ ਸਟ੍ਰਿੰਗਸ ਅਤੇ ਵੱਡੇ ਐਰੇ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਮੈਮੋਰੀ ਓਵਰਫਲੋ ਬਣਾਉਣਾ।
• ਸ਼ੁਰੂ ਵਿੱਚ ਐਕਟੁਏਟਰ ਆਉਟਪੁੱਟ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨਾ ਭੁੱਲ ਜਾਣਾ।

ਸੰਖੇਪ ਵਿੱਚ

• ਏਮਬੈਡਡ ਕੋਡ; ਇਹ ਸੀਮਤ ਮੈਮੋਰੀ, ਤੰਗ ਸਮਾਂ, ਅਤੇ ਸਿੱਧੀ ਰਜਿਸਟਰ ਐਕਸੈਸ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ।
• ਮੁੱਖ ਲੂਪ ਵਿੱਚ, ਦੇਰੀ ਦੀ ਬਜਾਏ ਇੱਕ ਮਿਲੀਸ-ਅਧਾਰਤ ਗੈਰ-ਬਲਾਕਿੰਗ ਪੈਟਰਨ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
• ISR ਛੋਟਾ ਰੱਖਿਆ ਗਿਆ ਹੈ; ਸ਼ੇਅਰਡ ਵੇਰੀਏਬਲ ਅਸਥਿਰ ਅਤੇ ਪਰਮਾਣੂ ਪਹੁੰਚ ਵਾਲੇ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ।
• ਰਜਿਸਟਰ ਪਤੇ ਅਤੇ ਬਿੱਟ ਮਾਸਕ ਹਮੇਸ਼ਾ ਡੇਟਾਸ਼ੀਟ ਦੇ ਵਿਰੁੱਧ ਪ੍ਰਮਾਣਿਤ ਹੁੰਦੇ ਹਨ; AI ਗਲਤ ਹੋ ਸਕਦਾ ਹੈ।
• ਮੈਮੋਰੀ, ਐਰਰ ਹੈਂਡਲਿੰਗ ਅਤੇ ਸੁਰੱਖਿਅਤ ਸ਼ੁਰੂਆਤੀ ਸਥਿਤੀ ਦੀ ਹਮੇਸ਼ਾ ਜਾਂਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
• ਸ਼ਕਤੀਸ਼ਾਲੀ ਪ੍ਰੋਂਪਟ; ਇਸ ਵਿੱਚ ਚਿੱਪ, ਫਰੇਮਵਰਕ, ਸੈਂਸਰ, ਪ੍ਰੋਟੋਕੋਲ, ਪਿੰਨ ਅਤੇ ਰੁਕਾਵਟਾਂ ਸ਼ਾਮਲ ਹਨ।

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

ਇੱਕ ਸੈਂਸਰ (ਉਦਾਹਰਨ ਲਈ DS18B20, MPU6050 ਜਾਂ HC-SR04) ਅਤੇ ਇੱਕ ਮਾਈਕ੍ਰੋਕੰਟਰੋਲਰ (Arduino/ESP32/STM32) ਚੁਣੋ। AI ਨੂੰ ਇਸ ਯੂਨਿਟ ਵਿੱਚ ਸ਼ਕਤੀਸ਼ਾਲੀ ਪ੍ਰੋਂਪਟ ਟੈਂਪਲੇਟ ਦੇ ਨਾਲ ਇੱਕ ਗੈਰ-ਬਲੌਕਿੰਗ ਰੀਡ ਕੋਡ ਤਿਆਰ ਕਰਨ ਲਈ ਕਹੋ। ਫਿਰ ਸਮੀਖਿਆ ਚੈੱਕਲਿਸਟ ਦੀਆਂ ਸੱਤ ਆਈਟਮਾਂ ਦਾ ਇੱਕ-ਇੱਕ ਕਰਕੇ ਪਾਲਣਾ ਕਰੋ: ਡੈਟਾਸ਼ੀਟ ਨਾਲ ਘੱਟੋ-ਘੱਟ ਇੱਕ ਰਜਿਸਟਰ/ਪਿੰਨ ਮੁੱਲ ਦੀ ਤੁਲਨਾ ਕਰੋ, ਲੂਪ ਦੇਰੀ ਦੀ ਜਾਂਚ ਕਰੋ, ਸਾਂਝੇ ਵੇਰੀਏਬਲਾਂ ਦੀ ਅਸਥਿਰ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰੋ। ਪਹਿਲੀ ਕੋਸ਼ਿਸ਼ ਵਿੱਚ ਕਿੰਨੀਆਂ ਆਈਟਮਾਂ "ਪਾਸ" ਹੋਈਆਂ ਅਤੇ ਕਿੰਨੀਆਂ ਸੋਧਾਂ ਦੀ ਲੋੜ ਹੈ? ਹਰ ਸਮੱਸਿਆ ਦਾ ਨੋਟ ਕਰੋ ਜੋ ਤੁਸੀਂ ਲੱਭਦੇ ਹੋ ਅਤੇ ਇਸਦਾ ਹੱਲ ਕਰੋ.