Mga yunit
1. Panimula sa Artificial Intelligence sa Mechatronics, Security at Verification Framework 2. Artificial Intelligence sa Robotics at Motion Control 3. Mga Naka-embed na System at Microcontroller Code Generation 4. Sensor Fusion at IoT Data Integration 5. Control Algorithm: PID at AI Supported Tuning 6. Industrial Automation at PLC Programming 7. Disenyo at Simulation na Batay sa Modelo 8. Predictive Maintenance 9. Machine Vision at Quality Control
Yunit 3 / 9

Mga Naka-embed na System at Microcontroller Code Generation

Mga nadagdag:

  • Kakayahang bumuo ng naka-embed na code na ibinigay ng rehistro at konteksto ng hardware para sa Arduino/STM32/ESP32 na may AI
  • Kakayahang kilalanin at itama ang mga naka-embed na pattern tulad ng mga interrupt, timer at hindi naka-block na mga loop sa output ng AI
  • Kakayahang suriin ang nabuong code sa mga tuntunin ng memorya, real-time at seguridad bago ito i-upload sa hardware

Sa mechatronics, ang microcontroller ay kung saan ang mga ideya ay nakakatugon sa pisikal na mundo. Mga card tulad ng Arduino, STM32, ESP32; nagbabasa ito ng mga sensor, nagtutulak ng mga actuator, nakikipag-usap, at ginagawa ang lahat ng ito sa ilalim ng limitadong memorya, limitadong kapangyarihan sa pagpoproseso, at mahigpit na mga kinakailangan sa timing. Napaka-kapaki-pakinabang ng artificial intelligence sa larangang ito: maaari itong mag-extract ng mga setting ng rehistro batay sa datasheet ng sensor, mag-code ng protocol ng komunikasyon, magtakda ng timer interrupt. Ngunit ang mga naka-embed na system ay isa sa mga lugar kung saan ang AI ay gumagawa ng pinaka "nakakumbinsi na mga kasinungalingan"; dahil ang mga register address, bit mask at timing behavior ay partikular sa board at ang isang bit na error ay nakakagambala sa buong pag-uugali. Sa unit na ito, saklaw namin kung paano magkaroon ng naka-embed na code na nabuo gamit ang AI at kung paano ito suriin bago i-load ito sa hardware.

Pagkakaiba ng Naka-embed na Code mula sa Pure Software

Ang isang desktop program ay may maraming memorya, operating system, at kadalian sa pag-debug. Ang naka-embed na code ay kulang sa karamihan sa mga ito:

Sukat

desktop

naka-embed na sistema

alaala

antas ng GB

Antas ng KB (hal. 2 KB ng RAM)

timing

Sa pangkalahatan ay nababaluktot

Mahigpit, totoong oras

pag-debug

Madali (debugger, log)

Matigas (JTAG, serial, LED)

Resulta ng error

Nag-crash ang program

Maaaring masira ang actuator/hardware

pag-access sa mapagkukunan

Mga abstract ng OS

Direktang pag-access sa Register

Tinutukoy ng mga pagkakaibang ito ang iyong pamantayan para sa pagsusuri ng output ng AI: ang paggamit ng memorya, real-time (hindi pag-block), at katumpakan ng rehistro ng hardware ay palaging nasa tuktok ng iyong checklist.

Blocker vs Non-Blocking Code

Ang pinakakaraniwang pagkakamali ng mga nagsisimula (at madalas na ginagawa ng AI) ay ang paggamit ng pagkaantala(). delay(1000) lock ang processor para sa 1 segundo; Sa panahong ito, walang ibang sensor ang mababasa, walang mga button na makokontrol. Ito ay hindi katanggap-tanggap sa mechatronics. Sa halip, ginagamit ang millis() based na non-blocking pattern.

// BAD: blocker -- hindi makakagawa ang processor ng anumang iba pang gawain para sa 1 second void loop() { digitalWrite(LED, HIGH); pagkaantala(1000); // everything stops digitalWrite(LED, LOW); pagkaantala(1000); // Hindi mababasa ang emergency button sa ngayon!}// MABUTI: hindi nakaharang -- hindi naka-block ang loop, tumatakbo ang ibang mga gawain kung (nowMs - previousMs >= interval) { previousMs = nowMs; ledStatus = !ledStatus; digitalWrite(LED, ledStatus); } buttonCheck(); // ay maaaring tumakbo sa bawat cycle sensorRead(); //maaaring tumakbo sa anumang loop}

Ang pattern na hindi humaharang ay ang batayan ng naka-embed na mechatronics: ang control loop ay patuloy na dumadaloy, walang gawain ang nagla-lock ng isa pa. Ang pagsasabi sa AI na "huwag gumamit ng delay, magsulat ng millis-based non-blocking" kapag direktang nagsusulat ng code ay nagpapabuti sa kalidad ng output.

Tip: Maghanap ng pagkaantala( sa naka-embed na code mula sa AI. Kung makakita ka ng pagkaantala sa pangunahing control loop, kadalasan ang code na iyon ay hindi angkop para sa isang real-time na system at dapat itong muling isulat.

Mga Interrupt at Timer

Kinukuha namin ang mga kaganapang kritikal sa oras (pulso ng encoder, button, panaka-nakang sampling) na may mga interrupts sa halip na maghintay sa pangunahing loop. Ang interrupt routine (ISR) ay dapat isulat nang maikli at maingat: walang mga pagkaantala, Serial.print o mahabang kalkulasyon dito; Ang mga nakabahaging variable ay minarkahan na pabagu-bago.

pabagu-bago ng isip mahabang encoderCounter = 0; // ISR and loop are shared -> volatile condition void enkoderISR() { // Short ISR: just count, do no other work if (digitalRead(ENC_B)) enkoderCounter++; else encoderCounter--;}void setup() { pinMode(ENC_A, INPUT_PULLUP); pinMode(ENC_B, INPUT_PULLUP); attachInterrupt(digitalPinToInterrupt(ENC_A), enkoderISR, RISING);}void loop() { long counter; noInterrupts(); //maikling interrupts para sa atomic reading counter = encoderCounter; interrupts(); //transact nang ligtas sa counter...}

Tatlong kritikal na punto sa halimbawang ito ay kung saan ang AI ay madalas na nakakaligtaan: (1) ang nakabahaging encoderCounter ay dapat na `volatile` o ang compiler optimization ay makakaligtaan ng mga update; (2) ang ISR ay dapat na maikli; (3) Kapag nagbabasa ng multi-byte na variable sa pangunahing loop, ang mga interrupt para sa atomic na pagbabasa ay dapat isara sa maikling panahon, kung hindi, ang ISR ay maaaring mamagitan habang binabasa at ang kalahati/corrupt na halaga ay maaaring basahin (kondisyon ng lahi). Siguraduhing suriin kung ang tatlong ito ay naroroon sa AI code.

Irehistro ang Katumpakan at Datasheet

Maaaring maling representasyon ng AI ang register address ng isang sensor o ang configuration bit ng isang MCU. Halimbawa, ang power management register ng MPU6050 IMU ay 0x6B; Kung ibinigay ito ng AI bilang 0x6A, ang code ay pinagsama-sama, tila gumagana, ngunit ang sensor ay hindi gumising. Ang ganitong mga error ay makikita lamang kapag inihambing sa datasheet.

// MPU6050 wake-up: ayon sa datasheet PWR_MGMT_1 = 0x6B, value 0x00#define MPU_ADDR 0x68#define PWR_MGMT_1 0x6B // <-- VERIFY mula sa datasheetWire.beginTransmission(MPU_ADDR);Wire.write(1);Wire.write(1); // gumising mula sa sleep modeWire.endTransmission(true);

Pansin: I-verify ang bawat address ng rehistro, bit mask at I2C/SPI address na ibinigay ng AI mula sa datasheet. Ang mga halagang ito ay partikular sa card at chip; Ang halaga na "naaalala" ng AI ay maaaring mula sa isa pang rebisyon ng chip. Ang maling rehistro ay tahimik na humahantong sa maling pag-uugali.

Mahina Prompt / Malakas na Prompt

MAHINA:"Basahin ang temperature sensor sa ESP32."(Aling sensor? Aling protocol? Aling pin? Generic, malamang na maling code.) MALAKAS:"Magbasa ng DS18B20 temperature sensor sa ESP32 (Arduino framework) mula sa GPIO4 na may OneWire. Sumulat ng hindi naka-block, sample bawat 1 segundo (gamit ang pagkaantala, millis-based na error) - Itakda ang error sa 18 na pagbabasa (2 kalimitang may flag na error). Pakitukoy ang bawat library at pin na koneksyon na ginagamit mo sa unang komento Para sa mga kadahilanang memorya, gamitin ang char buffer sa halip na String."

Napakahusay na prompt; Nagbibigay ito ng chip, framework, sensor, protocol, pin, sampling pattern, error status at memory constraint. Sa ganitong paraan ang output ay parehong nabe-verify at makatotohanan.

Suriin ang Checklist para sa Naka-embed na Code

Bago i-load ang output ng AI, ipasa ito sa listahang ito:

  1. Pag-block: Mayroon bang pagkaantala o mahabang pagharang sa pangunahing loop?
  2. pabagu-bago ng isip: Ang mga variable ba ay ibinabahagi sa ISR na pabagu-bago ng isip?
  3. Atomic access: Ligtas bang basahin ang multi-byte shared variable?
  4. Magrehistro: Ang mga address at bit mask ba ay tugma sa datasheet?
  5. Memorya: String, malalaking array, ang recursion ba ay lumilikha ng KB level overflow?
  6. Paghawak ng error: Ang mga error sa pagbabasa ng sensor, mga timeout ng komunikasyon ba ay pinangangasiwaan?
  7. Ligtas na pagsisimula: Ang mga output ba ng actuator ay inilalagay sa isang ligtas (passive) na estado sa pagsisimula?

Mini Case

Ang naka-embed na system engineer na si Baran ay may AI na isulat ang code na nagbabasa ng IMU para sa isang drone. Ang code ay nag-compile at mukhang gumagana, ngunit ang mga halaga ng anggulo ay walang kahulugan. Inilapat ni Baran ang checklist: ikinukumpara ang mga address ng rehistro sa datasheet at nalaman na mali ang output ng AI sa rehistro ng configuration ng gyroscope (0x1A sa halip na 0x1B), kaya mali ang sensitivity scale. Kapag naitama, ang mga halaga ay tumira. Pagkatapos ay antalahin (10) ang mga abiso sa pangunahing loop; ginagawa itong millis-based na istraktura, dahil hindi katanggap-tanggap ang pagharang sa flight control loop. Sa wakas, nakikita nito na ang nakabahaging counter variable ay hindi pabagu-bago at idinagdag ito. Binigyan ng AI ang balangkas ng mabilis; Ngunit ang listahan ng pagsusuri ay nakakuha ng tatlong magkahiwalay na mga error: magparehistro, pagharang at pabagu-bago ng isip, at ang hardware ay wala sa panganib.

Mga Karaniwang Pagkakamali

  • Pagpatay sa real-time na tugon sa pamamagitan ng paggamit ng delay() sa pangunahing control loop.
  • Iwasang gawing pabagu-bago ang variable na ibinahagi sa ISR at makaranas ng silent data corruption.
  • Pagbabasa ng multi-byte na nakabahaging variable na hindi atomically at pagbuo ng kundisyon ng lahi.
  • Hindi bini-verify ang register/bit mask na ibinigay ng AI gamit ang datasheet.
  • Paglikha ng memory overflow sa pamamagitan ng paggamit ng Strings at malalaking arrays sa limitadong RAM.
  • Nakakalimutang i-secure muna ang mga output ng actuator.

Sa buod

  • Naka-embed na code; Gumagana ito nang may limitadong memorya, mahigpit na timing, at direktang pag-access sa pagpaparehistro.
  • Sa pangunahing loop, isang millis-based na non-blocking pattern ang ginagamit sa halip na pagkaantala.
  • Ang ISR ay pinananatiling maikli; ang mga nakabahaging variable ay dapat na pabagu-bago at atomic na na-access.
  • Ang mga address sa pagpaparehistro at bit mask ay palaging nabe-verify laban sa datasheet; Maaaring mali ang AI.
  • Ang memorya, paghawak ng error at ligtas na katayuan sa pagsisimula ay palaging sinusuri.
  • Napakahusay na prompt; Kabilang dito ang chip, framework, sensor, protocol, pin, at mga hadlang.

Gawain ng aplikasyon

Pumili ng sensor (hal. DS18B20, MPU6050 o HC-SR04) at isang microcontroller (Arduino/ESP32/STM32). Hayaang bumuo ang AI ng isang hindi naka-block na read code gamit ang malakas na template ng prompt sa unit na ito. Pagkatapos ay sundin ang pitong item ng checklist ng pagsusuri nang paisa-isa: ihambing ang hindi bababa sa isang halaga ng rehistro/pin sa datasheet, tingnan kung may mga pagkaantala sa loop, tingnan ang pabagu-bagong katayuan ng mga nakabahaging variable. Ilang mga item ang "pumasa" sa unang pagsubok at gaano karaming mga kinakailangang pagwawasto? Itala ang bawat problemang makikita mo at ang pag-aayos nito.

Nakaraang Susunod