ഉൾച്ചേർത്ത സിസ്റ്റങ്ങളും മൈക്രോകൺട്രോളർ കോഡും

നേട്ടങ്ങൾ:

• വ്യക്തമായ പ്രോംപ്റ്റോടെ മൈക്രോകൺട്രോളറിനായുള്ള രജിസ്റ്റർ, തടസ്സം, സമയ ആവശ്യകതകൾ എന്നിവ നിർവചിക്കാനുള്ള കഴിവ്
• രജിസ്റ്റർ ക്രമീകരണങ്ങൾ, ബഫർ ഓവർഫ്ലോ, തത്സമയ പരിമിതികൾ എന്നിവയുടെ അടിസ്ഥാനത്തിൽ AI നിർമ്മിച്ച C/Arduino കോഡ് പരിശോധിക്കാനുള്ള കഴിവ്
• ഹാർഡ്‌വെയറിൽ (ഓസിലോസ്കോപ്പ്, സീരിയൽ പോർട്ട്) അളന്ന് ജനറേറ്റുചെയ്‌ത കോഡ് പരിശോധിക്കുന്ന ശീലം പ്രയോഗിക്കാനുള്ള കഴിവ്

സോഫ്‌റ്റ്‌വെയറും ഹാർഡ്‌വെയറും കൂടിച്ചേരുന്നിടത്താണ് എംബഡഡ് സിസ്റ്റം ഡെവലപ്‌മെൻ്റ്: ഒരു രജിസ്‌റ്റർ ബിറ്റ് തെറ്റായി സജ്ജീകരിക്കുക, ഒരു തടസ്സം അധികനേരം പിടിക്കുക, അല്ലെങ്കിൽ ഒരു ബഫർ ഓവർഫ്ലോ എന്നിവ കോഡ് "കംപൈൽ" ചെയ്‌ത് പ്രവർത്തിക്കുന്നുവെങ്കിലും, ഫീൽഡിൽ വിചിത്രവും പുനർനിർമ്മിക്കാൻ പ്രയാസമുള്ളതുമായ പരാജയങ്ങൾക്ക് കാരണമാകും. ഈ മേഖലയിൽ AI ശരിക്കും ഒരു ആക്സിലറേറ്ററാണ്; ഇതിന് പ്രാരംഭ അസ്ഥികൂടങ്ങൾ, ഹാർഡ്‌വെയർ അബ്‌സ്‌ട്രാക്ഷൻ ഫംഗ്‌ഷനുകൾ, സ്റ്റേറ്റ് മെഷീനുകൾ, ആശയവിനിമയ ദിനചര്യകൾ എന്നിവ നിർമ്മിക്കാൻ കഴിയും. എന്നാൽ AI നിങ്ങളുടെ കാർഡിൻ്റെ ഡാറ്റാഷീറ്റ് കാണുന്നില്ല, നിങ്ങളുടെ ക്ലോക്ക് ഫ്രീക്വൻസി അറിയുന്നില്ല, നിങ്ങളുടെ തത്സമയ പരിമിതികൾ മനസ്സിലാക്കുന്നില്ല. ഈ യൂണിറ്റിൽ, മൈക്രോകൺട്രോളർ വർക്ക് എങ്ങനെ AI-ലേക്ക് വ്യക്തമായി നിർവചിക്കാം, ജനറേറ്റ് ചെയ്‌ത C/Arduino കോഡ് എങ്ങനെ പരിശോധിക്കാം, ഹാർഡ്‌വെയറിൽ നിങ്ങൾ എന്തിനാണ് എല്ലാം അളക്കേണ്ടത്.

ആവശ്യകത വ്യക്തമായി നിർവചിക്കുന്നു: രജിസ്റ്റർ, മുറിക്കൽ, സമയം

"എൽഇഡി പ്രകാശിപ്പിക്കാൻ" എഐയോട് പറയുന്നത് പ്രവർത്തിക്കില്ല; ഏത് കാർഡ്, ഏത് പിൻ, ഏത് ക്ലോക്ക് ഫ്രീക്വൻസി, ഏത് സമയം? AI-യ്‌ക്ക് ഒരു ഉൾച്ചേർത്ത ടാസ്‌ക് അസൈൻ ചെയ്യുമ്പോൾ, ഈ ചട്ടക്കൂട് ഉപയോഗിക്കുക: ഹാർഡ്‌വെയർ (MCU ഫാമിലി, ക്ലോക്ക്, പിൻ), ഫംഗ്‌ഷൻ (എന്ത് സംഭവിക്കും), പരിമിതി (ടൈമിംഗ്, പവർ, മെമ്മറി), ഇൻ്റർഫേസ് (രജിസ്റ്റർ, HAL, Arduino ലൈബ്രറി).

ദുർബലമായ പ്രോംപ്റ്റ് / ശക്തമായ പ്രോംപ്റ്റ്

ദുർബലമായത്: "STM32 ഉപയോഗിച്ച് PWM നിർമ്മിക്കുക." (ഫലം: ഏത് ടൈമർ, ഏത് ആവൃത്തി, ഏത് പിൻ വ്യക്തമല്ല; പൊതുവായത്, പേരുനൽകിയ കോഡ് തെറ്റാണ്.) STRONG: "20 kHz, 0-100% ക്രമീകരിക്കാവുന്ന ഡ്യൂട്ടി PWM-ൽ TIM3 CH1 (PA6)-ൽ STM32F103 (72 MHz സിസ്റ്റം ക്ലോക്ക്) നിർമ്മിക്കുക (72 MHz സിസ്റ്റം ക്ലോക്ക്). രജിസ്‌റ്റർ തലത്തിൽ എഴുതുക (HAL, K20 മൂല്യങ്ങൾ അല്ല). കമൻറ് ലൈനിൽ കണക്കുകൂട്ടൽ കാണിക്കുക - 0-100 ന് ഇടയിലുള്ള ഒരു ഫംഗ്‌ഷൻ പാരാമീറ്റർ ഉപയോഗിച്ച് ഡ്യൂട്ടി സജ്ജീകരിക്കുക - നിങ്ങളുടെ ക്ലോക്ക് അനുമാനം തെറ്റാണെങ്കിൽ മൂല്യങ്ങൾ മാറും.

ശക്തമായ പ്രോംപ്റ്റ് മോഡലിനെ കണക്കുകൂട്ടൽ കാണിക്കുകയും ക്ലോക്ക് അനുമാനം വെളിപ്പെടുത്തുകയും ചെയ്യുന്നു എന്നതാണ് വ്യത്യാസം. അതിനാൽ നിങ്ങൾക്ക് സ്വതന്ത്രമായി prescaler/ARR മൂല്യങ്ങൾ പരിശോധിക്കാം:

20 kHz PWM-ന് (72 MHz ക്ലോക്ക്):Timer_clock = 72 MHzനമുക്ക് പ്രീ സ്‌കെയിലർ വേണമെങ്കിൽ = 72-1 → കൗണ്ടർ ക്ലോക്ക് = 1 MHzARR = (1 MHz / 20 kHz) - 1 = 50 - 1 = 49പരിശോധനം: 1e✓ 0 (49+10) =

ഓഡിറ്റിംഗ് AI കോഡ്: എന്താണ് തിരയേണ്ടത്?

ജനറേറ്റ് ചെയ്ത കോഡ് കംപൈൽ ചെയ്യുന്നതുകൊണ്ട് അത് ശരിയായി പ്രവർത്തിക്കുന്നു എന്നല്ല അർത്ഥമാക്കുന്നത്. ഈ ചെക്ക്‌ലിസ്റ്റ് പിന്തുടരുക:

നിയന്ത്രണ മേഖല

എന്താണ് അന്വേഷിക്കേണ്ടത്

രജിസ്റ്റർ/ബിറ്റ് ക്രമീകരണങ്ങൾ

ഡാറ്റാഷീറ്റുമായി കൃത്യമായി പൊരുത്തപ്പെടുന്നു, ശരിയായ ബിറ്റ് മാസ്ക്

ഇൻ്ററപ്റ്റ് (ISR)

ഇത് ചെറുതാണോ? ബ്ലോക്കർ കാലതാമസം ഇല്ലേ? അസ്ഥിരമായി ഉപയോഗിക്കുന്നുണ്ടോ?

ബഫർ/അറേ

അതിർത്തി നിയന്ത്രണമുണ്ടോ? ഓവർഫ്ലോ അപകടസാധ്യത?

സമയം

കാലതാമസമോ ടൈമറോ? യഥാർത്ഥ സമയ പരിമിതി പാലിക്കുന്നുണ്ടോ?

തരവും വീതിയും

8/16/32-ബിറ്റ് ഓവർഫ്ലോ, ഒപ്പിട്ട/ ഒപ്പിടാത്ത ആശയക്കുഴപ്പം

ശക്തി/കാവൽ നായ

അനന്തമായ ലൂപ്പ് ഫീഡിംഗ് വാച്ച്ഡോഗ്?

ഇൻ്ററപ്റ്റ് സർവീസ് റൂട്ടീനുകൾ (ISR) ആണ് പിശകുകളുടെ ഏറ്റവും സാധാരണമായ ഉറവിടം. AI ചിലപ്പോൾ കാലതാമസം() അല്ലെങ്കിൽ നീണ്ട ലൂപ്പ് ISR-ൽ ഇടുന്നു. ഇത് മറ്റ് തടസ്സങ്ങൾ നഷ്‌ടപ്പെടുന്നതിനും വാച്ച്‌ഡോഗ് പുനഃസജ്ജമാക്കുന്നതിനും ഇടയാക്കുന്നു. നിയമം: ISR കഴിയുന്നത്ര ചെറുതായിരിക്കണം; പ്രധാന ജോലി ഒരു ഫ്ലാഗ് സജ്ജീകരിക്കുകയും അത് പ്രധാന ലൂപ്പിലേക്ക് മാറ്റുകയും വേണം.

// WEAK (AI ചിലപ്പോൾ ഇത് നിർമ്മിക്കുന്നു): ISR അസാധുവായ TIM3_IRQHandler (അസാധു) { if (TIM3->SR & TIM_SR_UIF) { TIM3->SR &= ~TIM_SR_UIF; read_sensor(); // വളരെ സമയമെടുത്തേക്കാം - BAD CASE_Delay(10); // ISR-ലെ കാലതാമസം - വളരെ മോശം }}// ശക്തമായത്: ISR ഹ്രസ്വം; ജോലി പ്രധാന loopvolatile uint8_t tick_flag = 0 ലേക്ക് നീങ്ങുന്നു; // അസ്ഥിര അവസ്ഥ tick_flag = 1; //മെയിൻ ലൂപ്പിൽ ഫ്ലാഗ് സജ്ജീകരിക്കുക }}//:if (tick_flag) {tick_flag = 0; read_sensor(); }

മുന്നറിയിപ്പ്: ഇൻ്ററപ്റ്റിനും മെയിൻ ലൂപ്പിനും ഇടയിൽ പങ്കിടുന്ന ഏതൊരു വേരിയബിളും അസ്ഥിരമായിരിക്കണം. അല്ലെങ്കിൽ, കംപൈലർ രജിസ്റ്ററിലെ വേരിയബിൾ കാഷെ ചെയ്‌ത് അപ്‌ഡേറ്റ് നഷ്‌ടപ്പെടുത്തിയേക്കാം. AI പലപ്പോഴും ഈ കീവേഡ് മറക്കുന്നു; കോഡ് വായിക്കുമ്പോൾ അത് പ്രത്യേകം നോക്കുക.

ബഫർ ഓവർഫ്ലോയും ടൈപ്പ് പിശകുകളും

പരിധികൾ പരിശോധിക്കാതെ തന്നെ AI-ന് സീരിയൽ പോർട്ടിൽ നിന്ന് ഒരു നിശ്ചിത വലുപ്പത്തിലുള്ള അറേയിലേക്ക് ഡാറ്റ പകർത്താനാകും. ഒരു ഉൾച്ചേർത്ത സിസ്റ്റത്തിൽ, ഇതിനർത്ഥം തുടർച്ചയായ മെമ്മറിയും വിശദീകരിക്കാത്ത ക്രാഷുകളും തകർക്കുന്നു എന്നാണ്. ഓരോ strcpy, അറേ സൂചികയിലും DMA ബഫറിലും പരിധി പരിശോധിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക. അതുപോലെ, 255-ന് ശേഷം ഒരു 8-ബിറ്റ് കൌണ്ടർ റീസെറ്റ് ചെയ്യുന്നു; AI-ക്ക് ഇത് അവഗണിക്കാനും ഓവർഫ്ലോയിംഗ് അക്കൗണ്ടിനെ ആശ്രയിക്കാനും കഴിയും.

ഹാർഡ്‌വെയറിലെ സ്ഥിരീകരണം: "വർക്കിംഗ്" അളക്കുന്നത്, അനുമാനിക്കപ്പെടുന്നില്ല

ഒരു എംബഡഡ് സിസ്റ്റത്തിൽ, ഏറ്റവും വിശ്വസനീയമായ തെളിവ് മീറ്ററാണ്, കമ്പൈലറല്ല. ഈ മൂന്ന് വഴികളിലൂടെ ജനറേറ്റ് ചെയ്ത കോഡ് പരിശോധിക്കുക:

1. ഓസിലോസ്കോപ്പ്/ലോജിക് അനലൈസർ: PWM ഫ്രീക്വൻസി, സിഗ്നൽ ടൈമിംഗ്, ആശയവിനിമയ തരംഗരൂപം എന്നിവ അളക്കുക. നിങ്ങൾക്ക് 20 kHz വേണമെങ്കിൽ, സ്ക്രീനിൽ 20 kHz കാണുക.
2. സീരിയൽ പോർട്ട് (UART) ലോഗ്: വേരിയബിൾ മൂല്യങ്ങൾ, സംസ്ഥാന ട്രാൻസിഷനുകൾ, പിശക് കൗണ്ടറുകൾ എന്നിവ പ്രിൻ്റ് ചെയ്ത് പ്രതീക്ഷിക്കുന്ന സ്വഭാവവുമായി താരതമ്യം ചെയ്യുക.
3. ബൗണ്ട് ആൻഡ് സ്ട്രെസ് ടെസ്റ്റിംഗ്: സിസ്റ്റം ഏറ്റവും ഉയർന്ന ലോഡിലും വേഗതയേറിയ ഡാറ്റയിലും മോശം സമയത്തിലും നിലനിർത്തുന്നുണ്ടോയെന്ന് പരിശോധിക്കുക.

അളന്ന മൂല്യം കണക്കുകൂട്ടലുമായി യോജിക്കുന്നില്ലെങ്കിൽ, ക്ലോക്ക് അനുമാനം, പ്രീ സ്കെയിലർ മൂല്യം അല്ലെങ്കിൽ രജിസ്റ്റർ ക്രമീകരണം എന്നിവ തെറ്റാണ്; പിന്തുടരുക.

മിനി കേസ്

HC-SR04 അൾട്രാസോണിക് സെൻസർ ഉപയോഗിച്ച് AI പ്രിൻ്റ് ചെയ്യാനുള്ള ദൂരം അളക്കാനുള്ള കോഡ് വിദ്യാർത്ഥികളുടെ ഒരു ടീമിന് ഉണ്ട്. കോഡ് കംപൈൽ ചെയ്യുന്നു, പക്ഷേ ദൂരം എപ്പോഴും പരിഹാസ്യമായ മൂല്യങ്ങൾ നൽകുന്നു. അവർ അതിനെ ഓസിലോസ്കോപ്പുമായി ബന്ധിപ്പിക്കുമ്പോൾ, എക്കോ ലെഗ് അതിൻ്റെ സമയം മൈക്രോസെക്കൻഡിന് പകരം മില്ലിസെക്കൻഡിൽ കണക്കാക്കുന്നത് അവർ കാണുന്നു; AI മൈക്രോസിന് () പകരം മില്ലിസ്() ഉപയോഗിച്ചു. ഈ ഒറ്റവാക്കിലെ പിശക് മുഴുവൻ അളവുകളെയും 1000 എന്ന ഘടകം കൊണ്ട് ആശയക്കുഴപ്പത്തിലാക്കി. അവർ റോ എക്കോ ടൈം സീരിയൽ ലോഗിലേക്ക് പ്രിൻ്റ് ചെയ്യുകയും ഒരു യഥാർത്ഥ ഭരണാധികാരിയുമായി താരതമ്യം ചെയ്യുകയും ചെയ്യുമ്പോൾ, അവർ പിശക് കണ്ടെത്തി അത് പരിഹരിക്കുന്നു. പാഠം: സമാഹരിച്ച കോഡ് ശരിയായ കോഡല്ല; ഹാർഡ്‌വെയറിലെ അളക്കൽ പിശക് ഉടനടി വെളിപ്പെടുത്തുന്നു.

സാധാരണ തെറ്റുകൾ

• ഡാറ്റാഷീറ്റുമായി താരതമ്യം ചെയ്യാതെ രജിസ്റ്റർ നാമങ്ങളും ബിറ്റ് മാസ്കുകളും സ്വീകരിക്കുന്നു.
• ISR-നുള്ളിൽ തടയൽ കാലതാമസം അല്ലെങ്കിൽ നീണ്ട പ്രോസസ്സിംഗ് അനുവദിക്കുന്നു.
• പങ്കിട്ട വേരിയബിളുകളിലെ അസ്ഥിരത മറക്കുന്നു.
• ബൈപാസ് ബഫറും അറേ ബൗണ്ടുകളും പരിശോധിക്കുന്നു; കവിഞ്ഞൊഴുകുന്നത് കാണുന്നില്ല.
• ക്ലോക്ക് ഫ്രീക്വൻസിയും സമയ അനുമാനങ്ങളും പരിശോധിച്ചുറപ്പിക്കാതെ ആശ്രയിക്കുന്നു.
• ഒരു ഓസിലോസ്‌കോപ്പ്/സീരിയൽ ലോഗ് ഉപയോഗിച്ച് അളക്കാതെ "പ്രവർത്തിക്കുന്നു" എന്ന കോഡ് പരിഗണിക്കുന്നു.

ചുരുക്കത്തിൽ

• ഹാർഡ്‌വെയർ, ഫംഗ്‌ഷൻ, നിയന്ത്രണങ്ങൾ, ഇൻ്റർഫേസ് എന്നിവയുടെ അടിസ്ഥാനത്തിൽ എംബഡഡ് ടാസ്‌ക് വ്യക്തമായി നിർവ്വചിക്കുക.
• പ്രീ സ്കെയിലർ/എആർആർ പോലുള്ള സമയ മൂല്യങ്ങൾ AI കണക്കാക്കുകയും അവ സ്വതന്ത്രമായി പരിശോധിക്കുകയും ചെയ്യുക.
• ISR-കൾ ഹ്രസ്വമായി സൂക്ഷിക്കുക, പങ്കിട്ട വേരിയബിളുകളിൽ അസ്ഥിരമായി ഉപയോഗിക്കുക.
• രജിസ്റ്റർ, ബഫർ പരിധി, ടൈപ്പ് വീതി പിശകുകൾ എന്നിവയ്ക്കായി പ്രത്യേകം നോക്കുക.
• "ഇത് പ്രവർത്തിക്കുന്നു" എന്നത് ഒരു ഓസിലോസ്കോപ്പ്, ലോജിക് അനലൈസർ, സീരിയൽ ലോഗ് എന്നിവ ഉപയോഗിച്ച് തെളിയിക്കപ്പെട്ടതാണ്, കംപൈലർ ഉപയോഗിച്ചല്ല.
• അളന്ന മൂല്യം കണക്കുകൂട്ടലുമായി യോജിക്കുന്നില്ലെങ്കിൽ, അനുമാനങ്ങൾ പിന്തുടരുക.

ആപ്ലിക്കേഷൻ ടാസ്ക്

നിങ്ങളുടെ പക്കലുള്ള ഒരു മൈക്രോകൺട്രോളർ ഉപയോഗിച്ച് (Arduino, STM32, ESP32), ഒരു നിശ്ചിത ആവൃത്തിയിൽ PWM അല്ലെങ്കിൽ ഒരു ആനുകാലിക ടാസ്‌ക്കിനായി AI-യോട് ആവശ്യപ്പെടുക. കോഡ് ലോഡുചെയ്യുന്നതിന് മുമ്പ്: (1) കമൻ്റ് ലൈനിലെ അക്കൗണ്ടിൽ നിന്ന് സ്വതന്ത്രമായി ഫ്രീക്വൻസി/ടൈമിംഗ് മൂല്യങ്ങൾ പരിശോധിക്കുക, (2) ISR-ലും പങ്കിട്ട വേരിയബിളുകളിലും അസ്ഥിരവും തടയുന്നതും പരിശോധിക്കുക. അപ്‌ലോഡ് ചെയ്‌തതിന് ശേഷം, ഒരു ഓസിലോസ്‌കോപ്പ് അല്ലെങ്കിൽ ലോജിക് അനലൈസർ ഉപയോഗിച്ച് യഥാർത്ഥ ആവൃത്തി അളക്കുകയും ലക്ഷ്യവുമായി താരതമ്യം ചെയ്യുകയും ചെയ്യുക. ഒരു വ്യതിയാനം ഉണ്ടെങ്കിൽ, ഉറവിടം കണ്ടെത്തി അത് ശരിയാക്കുക, എന്താണ് തെറ്റായി കണക്കാക്കിയതെന്ന് ശ്രദ്ധിക്കുക.