Nyereség:
- Beágyazott kód generálása adott regiszter és hardverkörnyezetben az Arduino/STM32/ESP32 számára AI-val
- Képes felismerni és kijavítani a beágyazott mintákat, például megszakításokat, időzítőket és nem blokkoló hurkokat az AI kimenetben
- Lehetőség a generált kód áttekintésére a memória, a valós idejű és a biztonság szempontjából, mielőtt feltöltené a hardverre
A mechatronikában a mikrokontroller az, ahol az ötletek találkoznak a fizikai világgal. Kártyák, például Arduino, STM32, ESP32; érzékelőket olvas, működtetőket hajt meg, kommunikál, és mindezt korlátozott memória, korlátozott feldolgozási teljesítmény és szigorú időzítési követelmények mellett teszi. A mesterséges intelligencia nagyon hasznos ezen a téren: képes egy szenzor adatlapja alapján regiszterbeállításokat kinyerni, kommunikációs protokollt kódolni, időzítő megszakítást beállítani. De a beágyazott rendszerek az egyik olyan terület, ahol a mesterséges intelligencia a legmeggyőzőbb hamisságot produkálja; mert a regisztercímek, a bitmaszkok és az időzítési viselkedés a kártyára jellemző, és egy bithiba megzavarja az egész viselkedést. Ebben a részben bemutatjuk, hogyan lehet mesterséges intelligencia segítségével beágyazott kódot generálni, és hogyan tekintheti át azt a hardverbe való betöltése előtt.
A beágyazott kód különbsége a tiszta szoftvertől
Az asztali programok rengeteg memóriával, operációs rendszerrel és könnyű hibakereséssel rendelkeznek. A beágyazott kódból a legtöbb hiányzik:
Méret
asztali
beágyazott rendszer
memória
GB szinten
KB szint (pl. 2 KB RAM)
időzítés
Általában rugalmas
Szoros, valós időben
hibakeresés
Egyszerű (hibakereső, naplózás)
Kemény (JTAG, soros, LED)
Hiba eredménye
A program összeomlik
A működtető/hardver megsérülhet
erőforrás hozzáférés
OS absztraktok
Közvetlen hozzáférés a nyilvántartáshoz
Ezek a különbségek határozzák meg az AI-kimenet értékelésének kritériumait: a memóriahasználat, a valós idejű (nem blokkoló) és a hardveres regiszter pontossága mindig az ellenőrzőlista élén áll.
Blokkoló vs nem blokkoló kód
A kezdők által elkövetett leggyakoribb hiba (és gyakran az AI is) a delay(). delay(1000) zárolja a processzort 1 másodpercre; Ebben az időszakban más érzékelők nem olvashatók, gombok nem vezérelhetők. Ez elfogadhatatlan a mechatronikában. Ehelyett egy millis() alapú, nem blokkoló mintát használunk.
// ROSSZ: blokkoló -- a processzor nem tud más munkát végezni 1 másodpercig void loop() { digitalWrite(LED, HIGH); késleltetés(1000); // minden leáll digitalWrite(LED, LOW); késleltetés(1000); // Vészgombot jelenleg nem lehet olvasni!}// JÓ: nem blokkoló -- a hurok nincs blokkolva, más feladatok futnak if (nowMs - previousMs >= interval) { previousMs = nowMs; ledStatus = !ledStatus; digitalWrite(LED, ledStatus); } gombCheck(); // minden ciklusban futhat sensorRead(); //bármilyen ciklusban futhat}
A nem blokkoló minta a beágyazott mechatronika alapja: a vezérlőkör folyamatosan áramlik, egyetlen feladat sem zár ki egy másikat. Ha azt mondjuk az AI-nak, hogy „ne használjon késleltetést, írjon millis-alapú nem blokkolást” kódíráskor, az közvetlenül javítja a kimenet minőségét.
Tipp: Keresse a késleltetést( az AI beágyazott kódjában. Ha késést lát a fő vezérlőhurokban, akkor ez a kód leggyakrabban nem alkalmas valós idejű rendszerhez, és át kell írni.
Megszakítások és időzítők
Az időkritikus eseményeket (kódoló impulzus, gomb, periodikus mintavétel) megszakításokkal rögzítjük a főhurokban való várakozás helyett. A megszakítási rutint (ISR) röviden és körültekintően kell megírni: ne legyen benne késleltetés, Serial.print vagy hosszú számítások; A megosztott változók volatilisnak vannak jelölve.
volatile long encoderCounter = 0; // Az ISR és a ciklus meg van osztva -> volatile feltétel void enkoderISR() { // Rövid ISR: csak számoljon, ne végezzen más munkát 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() { hosszú számláló; noInterrupts(); //rövid megszakítások az atomolvasáshoz számláló = encoderCounter; megszakítja(); //ügyeljen biztonságosan a pulttal...}
Ebben a példában három kritikus pont az, ahol a mesterséges intelligencia gyakran kimarad: (1) a megosztott kódolószámlálónak 'volatile'-nek kell lennie, különben a fordítóoptimalizálás kihagyja a frissítéseket; (2) az ISR-nek rövidnek kell lennie; (3) A főhurokban lévő többbyte-os változó beolvasásakor az atomi olvasás megszakításait rövid időre le kell zárni, ellenkező esetben az ISR beavatkozhat az olvasás során, és fél/sérült érték olvasható ki (versenyfeltétel). Mindenképpen ellenőrizze, hogy ez a három szerepel-e az AI-kódban.
Regisztráljon pontosság és adatlap
Az AI hihetően félre tudja adni egy érzékelő regisztercímét vagy egy MCU konfigurációs bitjét. Például egy MPU6050 IMU energiagazdálkodási regisztere 0x6B; Ha az AI ezt 0x6A-ként adja meg, a kód le van fordítva, úgy tűnik, hogy működik, de az érzékelő nem ébred fel. Ilyen hibákat csak az adatlappal összehasonlítva észlelünk.
// MPU6050 ébresztés: adatlap szerint PWR_MGMT_1 = 0x6B, érték 0x00#define MPU_ADDR 0x68#define PWR_MGMT_1 0x6B // <-- VERIFY from datasheetWire.beginTransmission(MPU_ADDR);Wire.write(PWR_MGMT_1);Wire.write(0x00); // felébredés alvó módbólWire.endTransmission(true);
Figyelem: Ellenőrizze az AI által megadott minden regisztercímet, bitmaszkot és I2C/SPI-címet az adatlapon. Ezek az értékek kártya- és chip-specifikusak; Az az érték, amelyre az AI „emlékezik”, egy másik chip-változatból származhat. A helytelen regiszter csendben helytelen viselkedéshez vezet.
Gyenge felszólítás / Erős felszólítás
GYENGE:"Hőmérséklet-érzékelő olvasása az ESP32-n."(Melyik érzékelő? Melyik protokoll? Melyik érintkező? Általános, valószínűleg rossz kód.)STRONG:"Olvasson be egy DS18B20 hőmérséklet-érzékelőt ESP32-n (Arduino-keretrendszer) a GPIO4-ről OneWire-rel. Írjon nem blokkolást, mintát 1 másodpercenként (késleltetéssel, millis-alapú). Olvassa el a -1-es hibaértéket, kérjük, javítsa ki a 8-as értéket. az első megjegyzésben adja meg az összes használt könyvtárat és pin-kapcsolatot.
Erőteljes felszólítás; Megadja a chipet, a keretrendszert, az érzékelőt, a protokollt, a tűt, a mintavételi mintát, a hibaállapotot és a memóriakorlátot. Így a kimenet egyszerre ellenőrizhető és valósághű.
Tekintse át a beágyazott kód ellenőrzőlistáját
Mielőtt betöltené az AI-kimenetet, nézze át ezt a listát:
- Blokkolás: Van késés vagy hosszú blokkolás a főhurokban?
- volatilis: Az ISR-rel megosztott változók volatilisak?
- Atomic hozzáférés: A több bájtos megosztott változó biztonságosan olvasható?
- Regisztráció: A címek és bitmaszkok kompatibilisek az adatlappal?
- Memória: Karakterlánc, nagy tömbök, a rekurzió létrehoz KB szintű túlcsordulást?
- Hibakezelés: Az érzékelő olvasási hibáit, a kommunikációs időtúllépéseket kezelik?
- Biztonságos indítás: Az indítószerkezet kimenetei biztonságos (passzív) állapotba kerülnek indításkor?
Mini tok
A beágyazott rendszerek mérnöke, Baran megkérte az AI-t, hogy írja meg a kódot, amely beolvassa a drón IMU-ját. A kód összeáll, és úgy tűnik, hogy működik, de a szögértékek értelmetlenek. Baran alkalmazza az ellenőrzőlistát: összehasonlítja a regisztercímeket az adatlappal, és megállapítja, hogy az AI hibásan adja ki a giroszkóp konfigurációs regiszterét (0x1A helyett 0x1B), így az érzékenységi skála rossz. A javítás után az értékek rendeződnek. Ezután a delay(10) észrevételek a főhurokban; ezt millis alapú szerkezetté alakítani, mert a repülésirányító hurok blokkolása elfogadhatatlan. Végül látja, hogy a megosztott számlálóváltozó nem ingadozó, és hozzáadja. Az AI gyorsan megadta a csontvázat; A felülvizsgálati lista azonban három különálló hibát talált: regisztráció, blokkolás és illékony, és a hardver egyáltalán nem volt veszélyben.
Gyakori hibák
- A valós idejű válasz leállítása a delay() használatával a fő vezérlőkörben.
- Kerülje el, hogy az ISR-rel megosztott változó ingatag legyen, és ne tapasztaljon néma adatsérülést.
- Több bájtos megosztott változó nem atomi beolvasása és versenyfeltétel generálása.
- Az AI által megadott regiszter/bitmaszkok nem ellenőrzése az adatlappal.
- Memóriatúlcsordulás létrehozása karakterláncok és nagy tömbök használatával korlátozott RAM-ban.
- Elfelejti az indítóelemek kezdeti rögzítését.
Összefoglalva
- Beágyazott kód; Korlátozott memóriával, szűk időzítéssel és közvetlen regisztereléréssel működik.
- A fő hurokban késleltetés helyett millis alapú nem blokkoló mintát használnak.
- Az ISR rövid; a megosztott változóknak illékonynak és atomi hozzáférésűeknek kell lenniük.
- A regisztercímek és bitmaszkok mindig az adatlapon ellenőrzöttek; Az AI tévedhet.
- A memória, a hibakezelés és a biztonságos indítási állapot mindig ellenőrzött.
- Erőteljes felszólítás; Tartalmazza a chipet, a keretrendszert, az érzékelőt, a protokollt, a PIN-kódot és a korlátozásokat.
Pályázati feladat
Válasszon egy érzékelőt (pl. DS18B20, MPU6050 vagy HC-SR04) és egy mikrovezérlőt (Arduino/ESP32/STM32). A mesterséges intelligencia generáljon egy nem blokkoló olvasási kódot az egységben található hatékony prompt sablon segítségével. Ezután kövessük egyenként az áttekintési ellenőrzőlista hét pontját: hasonlítsunk össze legalább egy regiszter/pin értéket az adatlappal, ellenőrizzük a hurok késéseket, ellenőrizzük a megosztott változók volatilis állapotát. Hány tétel „ment át” az első próbálkozásra, és hány volt szükség javításra? Jegyezze fel minden talált problémát és annak megoldását.