Úgy tűnik, mindent leírtunk, ami kellett, még a kelleténél is többet (a cikk keretein belül). Most örököljük belőle a hajóosztályt Hajó, amelynek képesnek kell lennie mozogni és elfordulni:

SpaceShip.cs

UnityEngine használata; a System.Collections használatával; a System.Collections.Generic használatával; névtér Assets.Scripts.SpaceShooter.Bodies ( nyilvános osztály Szállítás: BaseBody ( public Vector2 _movement = new Vector2(); public Vector2 _target = new Vector2(); public float _rotation = 0f; public void FixedUpdate()) ( float torque = ControlRotate() _rotation); Vector2 force = ControlForce(_movement); _rb2d.AddTorque(torque); _rb2d.AddRelativeForce(force); ) public float ControlRotate(Vector2 rotate) ( lebegő eredmény = 0f; visszatérési eredmény; ) public Vector2 ControlForce(Vector2 mozgás) ( Vektor2 eredmény = new Vector2(); eredményt ad vissza; ) ) )

Bár nincs benne semmi érdekes, jelenleg ez csak egy csonkosztály.

Leírjuk az alap (absztrakt) osztályt is minden bemeneti vezérlőhöz BaseInputController:

BaseInputController.cs

UnityEngine használata; az Assets.Scripts.SpaceShooter.Bodies használatával; névtér Assets.Scripts.SpaceShooter.InputController ( public enum eSpriteRotation (jobb = 0, fel = -90, bal = -180, le = -270 ) nyilvános absztrakt osztály BaseInputController: MonoBehaviour ( public GameObject _agentdyp_bject; //B public GameObject _agentdyp_bjecta; a hajó logikai komponenséhez public eSpriteRotation _spriteOrientation = eSpriteRotation.Up; //Ez annak köszönhető, hogy a sprite nem szabványos // orientációja "fel" a "jobb" helyett public abstract void ControlRotate(float dt); public abstract void ControlForce (float dt); nyilvános virtuális void Start() ( _agentObject = gameObject; _agentBody = gameObject.GetComponent (); ) public virtual void FixedUpdate() ( float dt = Time.fixedDeltaTime; ControlRotate(dt); ControlForce(dt); ) public virtual void Update() ( //TO DO ) ) )

És végül a lejátszóvezérlő osztály PlayerFigtherInput:

PlayerInput.cs

UnityEngine használata; az Assets.Scripts.SpaceShooter.Bodies használatával; névtér Assets.Scripts.SpaceShooter.InputController ( nyilvános osztály PlayerFigtherInput: BaseInputController ( public override void ControlRotate(float dt) ( // Határozza meg az egér helyzetét a lejátszóhoz képest Vector3 worldPos = Input.mousePosition; worldPos =ToWorldScreenPositionToWorl.main. (worldPos); / / Mentse el az egérmutató koordinátáit float dx = -this.transform.position.x + worldPos.x; float dy = -this.transform.position.y + worldPos.y; //Adja át a Vector2 cél irányát = new Vector2(dx, dy ); _agentBody._target = cél; //A forgatás kiszámítása a billentyűleütések szerint float targetAngle = Mathf.Atan2(dy, dx) * Mathf.Rad2Deg; _agentBody._targetAngle = targetAngle)_spriteOrientation ; ) public override void ControlForce( float dt) ( //A mozgás átadása _agentBody._movement = Input.GetAxis("Függőleges") * Vector2.up + Input.GetAxis("Vízszintes") * Vector2.right; ) ) )

Úgy tűnik, befejeztük, most végre áttérhetünk arra, amiért mindez elkezdődött, i. PID vezérlők (remélem nem felejtetted el?). A megvalósítás pokolian egyszerűnek tűnik:

Az együtthatók alapértelmezett értékeit a semmiből vesszük: ez a Kp = 1 arányos szabályozási törvény triviális egyetlen együtthatója lesz, a Kd = 0,2 differenciálszabályozási törvény együtthatójának kicsi értéke, aminek ki kell zárnia. a várható ingadozásokat és a Ki nulla értékét, amit azért választottunk, mert szoftverünkben a modellben nincsenek statikus hibák (de ezeket mindig be lehet vezetni, majd az integrátor segítségével hősiesen harcolni).

Most térjünk vissza a SpaceShip osztályunkhoz, és próbáljuk meg alkotásunkat űrhajó forgásvezérlőként használni a ControlRotate metódusban:

A PID vezérlő precíz szögpozicionálást végez az űrszondán pusztán nyomaték felhasználásával. Minden korrekt, a fizika és az önjáró fegyverek, majdnem úgy, mint a való életben.

És ezek nélkül a Quaternion.Lerp a tied

if (!_rb2d.freezeRotation) rb2d.freezeRotation = igaz; float deltaAngle = Mathf.DeltaAngle(_myTransform.eulerAngles.z, targetAngle); float T = dt * Mathf.Abs(_rotationSpeed ​​​​/ deltaAngle); // A szög átalakítása vektorrá Quaternion rot = Quaternion.Lerp(_myTransform.rotation, Quaternion.Euler(new Vector3(0, 0, targetAngle)), T); // Az objektum elforgatásának módosítása _myTransform.rotation = rot;

A Ship.cs eredő forráskódja a spoiler alatt található

UnityEngine használata; az Assets.Scripts.Regulator használatával; névtér Assets.Scripts.SpaceShooter.Bodies ( nyilvános osztály Hajó: BaseBody ( public GameObject _flame; public Vector2 _movement = new Vector2(); public Vector2 _target = new Vector2(); public float _targetAngle = 0f; public float _angle = 0f; public SimplePID _angleController = new SimplePID(); public void FixedUpdate() ( float torque = ControlRotate(_targetAngle); Vector2 force = ControlForce(_movement); _rb2d.AddTorque(torque); _rb2d.AddRelativeRotate public(floatce); forgatás) ( float MV = 0f; float dt = Time.fixedDeltaTime; _angle = _myTransform.eulerAngles.z; //A hiba kiszámítása float angleError = Mathf.DeltaAngle(_angle, rotate); //A korrekciós gyorsulás MV = beszerzése Update( angleError, dt); return MV; ) public Vector2 ControlForce(Vector2 mozgás) ( Vector2 MV = new Vector2(); //Egy kódrészlet egy futó motor speciális effektusához az if kedvéért (mozgás != Vector2.zero) ( if (_flame != null) ( _flame.SetActive(true); ) ) else ( if (_flame != null) ( _flame.SetActive(false); ) ) MV = mozgás; visszatérő MV; ) ) )

Minden? Menjünk haza?

WTF! Mi történik? Miért fordul furcsán a hajó? És miért pattan vissza más tárgyakról olyan élesen? Ez a hülye PID szabályzó nem működik?

Ne essen pánikba! Próbáljuk kitalálni, mi történik.

Abban a pillanatban, amikor egy új SP érték érkezik, éles (lépcsős) ugrás következik be a hibahibában, amelyet, mint emlékszünk, a következőképpen számítanak ki: ennek megfelelően éles ugrás következik be a derivált hibában, amit kiszámolunk ez a kódsor:

Természetesen más megkülönböztetési sémákat is kipróbálhat, például hárompontos, ötpontos, vagy... de ez még mindig nem segít. Nos, nem szeretik az éles ugrások származékait - ilyen pontokon a függvény nem differenciálható. Azonban kísérletezzen különböző sémák a differenciálás és az integráció megéri, de akkor és nem ebben a cikkben.

Azt hiszem, eljött az idő az átmeneti folyamat grafikonjainak felépítésére: lépésenkénti mozgás S(t) = 0-ról SP(t) = 90 fokra egy 1 kg súlyú testnél, egy 1 méteres erőkar hossza és egy differenciáló rács lépés 0,02 s - csakúgy, mint a mi példánkban a Unity3D-ben (sőt, nem teljesen; ezeknek a grafikonoknak az elkészítésekor nem vettük figyelembe, hogy a tehetetlenségi nyomaték a geometriától függ szilárd, tehát az átállás folyamata kissé eltérő lesz, de a demonstrációhoz még mindig elég hasonló). A diagramon szereplő összes érték abszolút értékben van megadva:


Hmm, mi folyik itt? Hová tűnt a PID szabályozó válasza?

Gratulálunk, most találkoztunk egy ilyen jelenséggel, mint a „rúgás”. Nyilvánvalóan abban az időpontban, amikor a folyamat még PV = 0, és az alapjel már SP = 90, akkor numerikus differenciálással egy 4500-as nagyságrendű derivált értéket kapunk, amelyet megszorozunk Kd=0,2és adjunk össze egy arányos theromot, hogy a kimeneten 990-es szöggyorsulási értéket kapjunk, és ez már teljes felháborodás a Unity3D fizikai modellen (a szögsebességek elérik a 18000 fok/s-t... szerintem ez a RigidBody2D szögsebesség határértéke).

• Talán érdemes manuálisan kiválasztani az együtthatókat, hogy ne legyen olyan erős az ugrás?
• Nem! A legjobb, amit így elérhetünk, az a derivált ugrás kis amplitúdója, de maga az ugrás marad olyan, mint volt, és ebben az esetben a differenciálkomponens teljesen hatástalanná válhat.

Azonban lehet kísérletezni.

A második számú kísérlet. Telítettség

Ez logikus meghajtó egység(esetünkben a SpaceShip virtuális manőverező motorjai), nem képesek kezelni semmilyen nagy értéket, amit őrült szabályozónk képes előállítani. Tehát először telítjük a szabályozó kimenetét:

És még egyszer az átírt Hajó osztály így néz ki:

névtér Assets.Scripts.SpaceShooter.Bodies ( nyilvános osztály Hajó: BaseBody ( public GameObject _flame; public Vector2 _movement = new Vector2(); public Vector2 _target = new Vector2(); public float _targetAngle = 0f; public float _angle = 0f; public float _thrust = 1f; public SimplePID _angleController = new SimplePID(0.1f,0f,0.05f); public void FixedUpdate() ( _torque = ControlRotate(_targetAngle, _thrust); _force = ControlForce(_movement);.AdquerTb2d); _rb2d.AddRelativeForce(_force); ) public float ControlRotate(float targetAngle, float tolóerő) ( float CO = 0f; float MV = 0f; float dt = Time.fixedDeltaTime; //A hiba kiszámítása float angleError_Tran Mathlef.Delta. eulerAngles .z, targetAngle); //A korrekciós gyorsulás lekérése CO = _angleController.Update(angleError, dt); //Saturate MV = CO; if (MV > thrust) MV = tolóerő; if (MV< -thrust) MV = -thrust; return MV; } public Vector2 ControlForce(Vector2 movement) { Vector2 MV = new Vector2(); if (movement != Vector2.zero) { if (_flame != null) { _flame.SetActive(true); } } else { if (_flame != null) { _flame.SetActive(false); } } MV = movement * _thrust; return MV; } public void Update() { } } }

Önjáró fegyvereink végső sémája ezután így fog kinézni

Ugyanakkor világossá válik, hogy a vezérlő kimenete Gyermekágy) kissé eltér a folyamat szabályozott változójától MV(t).

Valójában erről a helyről már felvehet egy új játék entitást - meghajtó egység, amelyen keresztül a folyamat vezérelve lesz, amelynek logikája bonyolultabb lehet, mint a Mathf.Clamp(), például bevezetheti az értékek diszkretizálását (hogy ne terhelje túl a játék fizikáját az érkező értékekkel). a tizedesvessző utáni hatodban) egy holt zóna (ismét nem. Értelmes túlterhelni a fizikát ultrakis reakciókkal), késleltetést adunk be a hajtás vezérlésébe és nemlinearitásába (például szigmoid), majd lásd mi sül ki belőle.

A játék elindítása után azt tapasztaljuk, hogy az űrhajó végre irányíthatóvá vált:

Ha grafikonokat készít, láthatja, hogy a vezérlő válasza a következő:


Itt már normalizált értékeket használnak, a szögeket elosztják az SP értékkel, és a vezérlő kimenetét normalizálják ahhoz a maximális értékhez képest, amelynél a telítés már előfordul.

Az alábbiakban egy jól ismert táblázat látható a PID szabályozó paramétereinek növelésének hatásáról ( Hogyan tudom kicsinyíteni a betűtípust, különben nem fér bele a habcsók elválasztási táblázat?):

És a PID-szabályozó kézi hangolásának általános algoritmusa a következő:

1. Kiválasztjuk az arányos együtthatókat a differenciál- és integrálkapcsolatokkal, amíg az önrezgések meg nem kezdődnek.
2. A differenciálkomponens fokozatos növelésével megszabadulunk az önrezgésektől
3. Ha maradványszabályozási hiba (elmozdulás) van, akkor azt az integrál komponens segítségével kiküszöböljük.

Néhány általános értékeket Nincsenek PID-szabályozó paraméterei: az egyes értékek kizárólag a folyamat paramétereitől (az átviteli jellemzőitől) függenek: az egyik vezérlőobjektummal tökéletesen működő PID-szabályozó nem működik a másikkal. Ezenkívül az arányos, az integrál és a differenciális komponensek együtthatói is kölcsönösen függenek egymástól.

Harmadik próbálkozás. Még egyszer származékok

A vezérlő kimeneti értékeinek korlátozása formájában egy mankó felszerelése után még mindig nem oldottuk meg a vezérlőnk legfontosabb problémáját - a differenciálkomponens nem működik jól, ha a vezérlő bemeneti hibája fokozatosan változik. Valójában sok más mankó is létezik, például az SP hirtelen megváltozásakor „kapcsolja ki” a differenciál alkatrészt, vagy szereljen be aluláteresztő szűrőket. SP(t)és egy művelet, ami miatt a hiba fokozatosan növekszik, vagy teljesen megfordulhat, és valódi Kalman-szűrővel simíthatja a bemeneti adatokat. Általában sok mankó van, és hozzá megfigyelő Természetesen szeretném, de most nem.

Ezért térjünk vissza az eltérési hiba származékához, és nézzük meg alaposan:

Észrevettél valamit? Ha alaposan megnézzük, azt tapasztaljuk, hogy az SP(t) általában nem változik az idő múlásával (kivéve a lépésváltás pillanatait, amikor a vezérlő új parancsot kap), pl. származéka nulla:

Más szóval, differenciálható derivált hiba helyett nem mindenhol egy folyamat deriváltját használhatjuk, amely a klasszikus mechanika világában általában mindenhol folyamatos és differenciált, és automata vezérlőrendszerünk diagramja már a következő formát ölti majd:

Módosítsuk a vezérlő kódját:

És változtassunk egy kicsit a ControlRotate metóduson:

És-és-és-és... ha elindítja a játékot, rá fog jönni, hogy valójában semmi sem változott az utolsó próbálkozás óta, amit bizonyítani kellett. Ha azonban eltávolítja a telítettséget, a szabályozó válaszdiagramja így fog kinézni:


Ugrás Gyermekágy) még mindig jelen van, de már nem akkora, mint a legelején volt, és ami a legfontosabb, kiszámíthatóvá vált, mert kizárólag az arányos komponens biztosítja, és a maximális lehetséges eltérési hiba és a PID-szabályozó arányos erősítése korlátozza (és ez már arra utal, hogy Kpésszerű az egységnél kisebbet választani, például 1/90f-t, de ez nem függ a differenciálási rács lépésétől (pl. dt). Általában azt javaslom, hogy a hiba helyett inkább a folyamat-származékot használja.

Szerintem most senkit nem fog meglepni, de ugyanígy lecserélheted -ra, de ezen nem fogunk kitérni, kísérletezhetsz és kommentben elmondhatod, mi sült ki belőle (a legérdekesebb)

Negyedik próbálkozás. A PID szabályozó alternatív megvalósításai

A PID szabályozó fent leírt ideális ábrázolása mellett a gyakorlatban gyakran a szabványos formát használják, együtthatók nélkül. KiÉs Kd, amelyek helyett ideiglenes konstansokat használnak.

Ez a megközelítés annak a ténynek köszönhető, hogy számos PID-szabályozó hangolási technika a PID-szabályozó és a folyamat frekvenciakarakterisztikáján alapul. Tulajdonképpen az egész TAU a folyamatok frekvenciakarakterisztikája körül forog, így aki mélyebbre akar menni, és hirtelen egy alternatív nómenklatúrával találkozik, annak hozok egy példát az ún. alapforma PID szabályzó:

ahol az a differenciációs állandó, amely befolyásolja a rendszer állapotának a szabályozó általi előrejelzését,
- integrációs állandó, amely befolyásolja a hibaátlagolási intervallumot az integrál link által.

A PID-szabályozó szabványos formátumú hangolásának alapelvei hasonlóak az idealizált PID-szabályozóhoz:

• az arányos együttható növelése növeli a teljesítményt és csökkenti a stabilitási rátát;
• az integrált komponens csökkenésével a szabályozási hiba idővel gyorsabban csökken;
• az integrációs állandó csökkentése csökkenti a stabilitási rátát;
• a differenciálkomponens növekedése növeli a stabilitási rátát és a teljesítményt

A szabványos űrlap forráskódja a spoiler alatt található

névtér Assets.Scripts.Regulator ( nyilvános osztály StandartPID ( public float Kp, Ti, Td; public float error, CO; public float P, I, D; private float lastPV = 0f; public StandartPID() ( Kp = 0.1f; Ti = 10000f; Td = 0.5f; torzítás = 0f; ) public StandardPID(float Kp, float Ti, float Td) ( this.Kp = Kp; this.Ti = Ti; this.Td = Td; ) public float Update(float hiba, float PV, float dt) ( this.error = hiba; P = hiba; I += (1 / Ti) * hiba * dt; D = -Td * (PV - lastPV) / dt; CO = Kp * ( P + I + D); utolsó PV = PV; CO visszatérés; ) ) )

Az alapértelmezett értékek: Kp = 0,01, Ti = 10000, Td = 0,5 - ezekkel az értékekkel a hajó meglehetősen gyorsan fordul, és van egy bizonyos stabilitási határa.

A PID szabályzó ezen formája mellett az ún visszatérő forma:

Nem foglalkozunk vele, mert… elsősorban az FPGA-kkal és mikrokontrollerekkel dolgozó hardverprogramozók számára releváns, ahol egy ilyen megvalósítás sokkal kényelmesebb és hatékonyabb. Esetünkben - adjunk valamit a Unity3D-n lévő kupacoknak - ez csak egy újabb PID-vezérlő megvalósítása, ami semmivel sem jobb, mint mások, és még kevésbé érthető, úgyhogy még egyszer örüljünk, hogy milyen jó hangulatos C#-ban programozni. , és nem például hátborzongató és szörnyű VHDL-ben.

Konklúzió helyett. Hova adnál még PID vezérlőt?

Most próbáljuk meg egy kicsit bonyolítani a hajó vezérlését kéthurkos szabályozással: az egyik, számunkra már jól ismert _angleController PID vezérlő továbbra is a szögpozicionálásért felel, de a második - új, _angularVelocityController - a forgási sebességet szabályozza:

A második szabályozó célja a felesleg elnyomása szögsebességek, a nyomaték változása miatt - ez a szögsúrlódás jelenlétéhez hasonlít, amelyet a játékobjektum létrehozásakor kikapcsoltunk. Egy ilyen vezérlési séma [esetleg] lehetővé teszi a hajó stabilabb viselkedését, és még csak arányos szabályozási együtthatókkal is meg lehet boldogulni - a második szabályozó csillapítja az összes ingadozást, és az első szabályozó differenciálkomponenséhez hasonló funkciót lát el. .

Ezen kívül tegyük hozzá új osztály játékos bemenet - PlayerInputCorvette, amelyben a jobb-bal gombok lenyomásával hajtjuk végre a kanyarokat, és az egérrel meghagyjuk a célmegjelölést valami hasznosabb dologhoz, például egy torony vezérléséhez. Ugyanakkor most már van egy olyan paraméterünk is, mint a _turnRate, amely a kanyar sebességéért/reakcióiért felelős (nem világos, hogy az InputCONtrollerben vagy a Shipben hova érdemesebb elhelyezni).

Az egyértelműség kedvéért egy szkriptet is térdünkre teszünk a hibakeresési információk megjelenítéséhez

névtér Assets.Scripts.SpaceShooter.UI ( nyilvános osztály Hibakereső: MonoBehaviour ( Szállítás _ship; BaseInputController _controller; List _pids = új lista (); Lista _names = új lista (); Vector2 _orientáció = new Vector2(); // Használja ezt az inicializáláshoz void Start() ( _ship = GetComponent (); _controller = GetComponent (); _pids.Add(_ship._angleController); _names.Add("Szögvezérlő"); _pids.Add(_ship._angularVelocityController); _names.Add("Szögsebesség vezérlő"); ) // A frissítést keretenként egyszer hívják meg void Update() ( DrawDebug(); ) Vector3 GetDiretion(eSpriteRotation spriteRotation) ( kapcsoló (_controller._spriteOrientation) ( case eSpriteRotation.Rigth: return transform.right; case eSpriteRotation.Up: return .up; case eSpriteRotation.Left: return -transform.right; case eSpriteRotation.Down: return -transform.up; ) return Vector3.zero; ) void DrawDebug() ( //Forgatás iránya Vector3 vectorToTarget = transzform.pozíció + 5f * new Vector3(-Mathf.Sin(_ship._targetAngle * Mathf.Deg2Rad), Mathf.Cos(_ship._targetAngle * Mathf.Deg2Rad), 0f); // Aktuális irány Vector3 heading = transform.position + 4f * GetDiretion(_controller. _spriteOrientation); //Szöggyorsulás Vector3 torque = irány - transzformáció.jobbra * _hajó._Torque; Debug.DrawLine(transform.position, vectorToTarget, Color.white); Debug.DrawLine(transform.position, heading, Color.green); Debug.DrawLine(címsor, nyomaték, Color.red); ) void OnGUI() ( float x0 = 10; float y0 = 100; float dx = 200; float dy = 40; float SliderKpMax = 1; float SliderKpMin = 0; float SliderKiMax = .5f; float SliderKiMin = -.5f; float SliderKdMax = .5f; float SliderKdMin = 0; int i = 0; foreach (SimplePID pid a _pids-ben) ( y0 += 2 * dy; GUI.Box(new Rect(25 + x0, 5 + y0, dx, dy), ""); pid.Kp = GUI.HorizontalSlider(new Rect( 25 + x0, 5 + y0, 200, 10), pid.Kp, SliderKpMin, SliderKpMax); pid.Ki = GUI.HorizontalSlider(new Rect(25 + x0, 20 + y0, 200, 10), pid.Ki, SliderKiMin, SliderKiMax); pid.Kd = GUI.HorizontalSlider(new Rect(25 + x0, 35 + y0, 200, 10), pid.Kd, SliderKdMin, SliderKdMax); GUIStyle style1 = new GUIStyle.alignment( = style1.alignment(); TextAnchor.MiddleRight; style1.fontStyle = FontStyle.Bold; style1.normal.textColor = Color.yellow; style1.fontSize = 9; GUI.Label(new Rect(0 + x0, 5 + y0, 20, 10), "Kp ", style1); GUI.Label(new Rect(0 + x0, 20 + y0, 20, 10), "Ki", ​​​​style1); GUI.Label(new Rect(0 + x0, 35 + y0, 20 , 10 ), "Kd", style1); GUIStyle style2 = új GUIStyle(); style2.alignment = TextAnchor.MiddleLeft; style2.fontStyle = FontStyle.Bold; style2.normal.textColor = Color.yellow; style2.fontSize = 9 GUI .TextField(new Rect(235 + x0, 5 + y0, 60, 10), pid.Kp.ToString(), style2); GUI.TextField(new Rect(235 + x0, 20 + y0, 60, 10), pid. Ki.ToString(), stílus2); GUI.TextField(new Rect(235 + x0, 35 + y0, 60, 10), pid.Kd.ToString(), style2); GUI.Label(new Rect(0 + x0, -8 + y0, 200, 10), _nevek, style2); ) ) ) )

A Ship osztály is visszafordíthatatlan mutációkon ment keresztül, és most így kell kinéznie:

névtér Assets.Scripts.SpaceShooter.Bodies ( nyilvános osztály Hajó: BaseBody ( public GameObject _flame; public Vector2 _movement = new Vector2(); public Vector2 _target = new Vector2(); public float _targetAngle = 0f; public float _angle = 0f; public float _thrust = 1f; nyilvános SimplePID _angleController = new SimplePID(0.1f,0f,0.05f); public SimplePID _angularVelocityController = new SimplePID(0f,0f,0f); privát lebegés _torque = 0f; nyilvános float _Torque_ ) ) private Vector2 _force = new Vector2(); public Vector2 _Force ( get ( return _force; ) ) public void FixedUpdate() ( _torque = ControlRotate(_targetAngle, _thrust); _force = ControlForce(_movement, _thrust);Ad _rborque2d; _torque); _rb2d.AddRelativeForce(_force); ) public float ControlRotate(float targetAngle, float tolóerő) ( float CO = 0f; float MV = 0f; float dt = Time.fixedDeltaTime; _angle = _myTransformlesz.eu; elforgatási szög float angleError = Mathf.DeltaAngle(_angle, targetAngle); float torqueCorrectionForAngle = _angleController.Update(angleError, _angle, dt); //Sebességstabilizáló vezérlő float angularVelocityError = -_rb2d.angularVelocity; float torqueCorrectionForAngularVelocity = _angularVelocityController.Update(angularVelocityError, -angularVelocityError, dt); //A vezérlő teljes kimenete CO = torqueCorrectionForAngle + torqueCorrectionForAngularVelocity; //Diszkretizálás 100 CO-os lépésekben = Mathf.Round(100f * CO) / 100f; //telített MV = CO; if (CO > tolóerő) MV = tolóerő; if(CO< -thrust) MV = -thrust; return MV; } public Vector2 ControlForce(Vector2 movement, float thrust) { Vector2 MV = new Vector2(); if (movement != Vector2.zero) { if (_flame != null) { _flame.SetActive(true); } } else { if (_flame != null) { _flame.SetActive(false); } } MV = movement * thrust; return MV; } public void Update() { } } }

AZ AUTOMATIKUS VEZÉRLÉS ELMÉLETE A „BABUKKOKHOZ”

K.Yu. Poljakov

Szentpétervár

© K.Yu. Poljakov, 2008

„Egy egyetemen magas szakmai színvonalon kell bemutatni az anyagot. De mivel ez a szint jóval az átlagos diák feje fölé megy, ujjamon magyarázom. Nem túl profi, de érthető.”

Ismeretlen tanár

Előszó

Ez a kézikönyv a témával való első megismerkedésre szolgál. Feladata az alapfogalmak „ujjakon” magyarázata az automatikus vezérlés elméleteés győződjön meg arról, hogy elolvasása után képes lesz felfogni a témával kapcsolatos szakirodalmat. Ezt a kézikönyvet csak alapnak, indítópadnak kell tekinteni egy komoly téma komoly tanulmányozásához, amely nagyon érdekessé és izgalmassá válhat.

Több száz tankönyv létezik az automatikus vezérlésről. De az egész probléma az, hogy amikor az agy új információt észlel, akkor valami ismerőst keres, amit „bekaphat”, és ez alapján „összekapcsolja” az újat a már ismert fogalmakkal. A gyakorlat azt mutatja, hogy komoly tankönyvek olvasása nehéz egy modern diák számára. Nincs mit megragadni. A szigorú tudományos bizonyítékok mögött pedig gyakran megkerül a dolog lényege, amely általában meglehetősen egyszerű. A szerző megpróbált „lemenni” egy alacsonyabb szintre, és láncot építeni a „mindennapi” fogalmaktól a menedzsmentelmélet fogalmaiig.

A prezentáció minden lépésénél hiányzik a szigor, nem adnak bizonyítékot, képleteket csak ott alkalmaznak, ahol nélkülük lehetetlen. A matematikus sok következetlenséget és hiányosságot talál itt, hiszen (a kézikönyv céljainak megfelelően) a szigorúság és az érthetőség között mindig az érthetőség javára kell választani.

Kevés előzetes tudás szükséges az olvasótól. Kell egy ötlet

O a felsőbb matematika kurzus néhány része:

1) származékok és integrálok;

2) differenciál egyenletek;

3) lineáris algebra, mátrixok;

4) komplex számok.

Köszönetnyilvánítás

A szerző mély köszönetét fejezi ki dr. A.N. Churilov, Ph.D. V.N. Kalinicsenko és Ph.D. BAN BEN. Rybinsky, aki figyelmesen elolvasta a kézikönyv előzetes verzióját, és sok értékes megjegyzést tett, amelyek lehetővé tették a prezentáció javítását és érthetőbbé tételét.

© K.Yu. Poljakov, 2008

© K.Yu. Poljakov, 2008

1. Alapfogalmak

1.1. Bevezetés

Az ember ősidők óta szeretné a természet tárgyait, erőit saját céljaira felhasználni, vagyis irányítani. Irányíthatja az élettelen tárgyakat (például egy kő másik helyre gurítása), az állatokat (képzés), az embereket (főnök - beosztott). A modern világban sok irányítási feladat kapcsolódik műszaki rendszerekhez - autók, hajók, repülőgépek, szerszámgépek. Például fenn kell tartania egy hajó adott irányát, egy repülőgép magasságát, a motor fordulatszámát vagy a hűtőben vagy sütőben lévő hőmérsékletet. Ha ezeket a feladatokat emberi részvétel nélkül oldják meg, arról beszélnek automatikus vezérlés.

A menedzsmentelmélet arra a kérdésre próbál választ adni, hogy „hogyan kell gazdálkodni?” A 19. századig az irányítás tudománya nem létezett, pedig az első automata vezérlőrendszerek már léteztek (például a szélmalmokat „megtanították” a szél felé fordulni). A menedzsmentelmélet fejlődése az ipari forradalom idején kezdődött. Eleinte ezt az irányt a tudományban a mechanika fejlesztette ki a szabályozási problémák megoldására, vagyis a forgási sebesség, hőmérséklet, nyomás adott értékének fenntartására a műszaki eszközökben (például gőzgépekben). Innen származik az „automatikus szabályozás elmélete” elnevezés.

Később kiderült, hogy a vezetési elvek nemcsak a technikában, hanem a biológiában, a közgazdaságtanban és a társadalomtudományokban is sikeresen alkalmazhatók. A kibernetika tudománya az ellenőrzési és információfeldolgozási folyamatokat vizsgálja bármilyen jellegű rendszerben. Egyik főként műszaki rendszerekkel kapcsolatos szakasza az ún automatikus vezérlés elmélet. A klasszikus szabályozási problémák mellett az irányítási törvényszerűségek optimalizálásával és az alkalmazkodóképesség (adaptáció) kérdéseivel is foglalkozik.

Néha az „automatikus vezérlés elmélete” és az „automatikus vezérlés elmélete” elnevezéseket felcserélhetően használják. Például a modern külföldi irodalomban csak egy kifejezést talál - az irányításelméletet.

1.2. Irányító rendszerek

1.2.1. Miből áll a vezérlőrendszer?

BAN BEN Az irányítási feladatokban mindig két objektum van – a kezelt és a menedzser. A kezelt objektumot általában hívjákvezérlő objektum vagy egyszerűen egy tárgy, a vezérlőobjektum pedig egy szabályozó. Például a forgási sebesség szabályozásánál a vezérlőobjektum egy motor (villanymotor, turbina); a hajó menetének stabilizálásának problémájában - vízbe merült hajó; a hangerő szinten tartása feladatában – dinamikus

© K.Yu. Poljakov, 2008

ka. Egy modern autó szó szerint „meg van tömve” vezérlőelektronikával, egészen a fedélzeti számítógépekig.

A szabályozó jellemzően nem közvetlenül, hanem aktuátorokon (meghajtókon) keresztül hat a vezérelt tárgyra, amelyek felerősíthetik és átalakíthatják a vezérlőjelet, például elektromos jel „átalakulhat” egy üzemanyag-fogyasztást szabályozó szelep mozgásává, ill. a kormánykerék bizonyos szögben történő elfordításába.

Ahhoz, hogy a szabályozó „lássa”, mi történik valójában az tárggyal, szenzorokra van szükség. Az érzékelőket leggyakrabban egy objektum azon jellemzőinek mérésére használják, amelyeket ellenőrizni kell. Ezen túlmenően a menedzsment minősége javítható további információk megszerzésével - az objektum belső tulajdonságainak mérésével.

1.2.2. A rendszer felépítése

Tehát egy tipikus vezérlőrendszer tartalmaz egy berendezést, egy vezérlőt, egy működtetőt és érzékelőket. Ezen elemek halmaza azonban még nem rendszer. A rendszerré alakításhoz kommunikációs csatornákra van szükség, amelyeken keresztül információcsere zajlik az elemek között. Információ továbbítására elektromos áram, levegő (pneumatikus rendszerek), folyadék (hidraulikus rendszerek) és számítógépes hálózatok használhatók.

Az összekapcsolt elemek már olyan rendszernek minősülnek, amely (a kapcsolatok miatt) olyan speciális tulajdonságokkal rendelkezik, amelyekkel az egyes elemek és ezek bármilyen kombinációja nem.

A menedzsment fő intrikája azzal a ténnyel kapcsolatos, hogy a környezet hatással van az objektumra - külső zavarok, amelyek „megakadályozzák” a szabályozót a rábízott feladat ellátásában. A legtöbb zavar előre megjósolhatatlan, azaz véletlenszerű természetű.

Ráadásul az érzékelők nem pontosan mérik a paramétereket, de némi hibával, bár kicsivel. Ebben az esetben „mérési zajról” beszélnek a rádiótechnikában a jeleket torzító zaj analógiájával.

Összefoglalva, megrajzolhatjuk a vezérlőrendszer blokkdiagramját, így:

Például egy hajó irányirányító rendszerében

vezérlő objektum- ez maga a hajó, amely a vízben található; irányának szabályozására kormányt használnak a víz áramlási irányának megváltoztatására;

szabályozó – digitális számítógép;

hajtás - egy kormányberendezés, amely felerősíti a vezérlő elektromos jelet és átalakítja azt kormányfordulattá;

érzékelők - mérőrendszer, amely meghatározza a tényleges irányt;

külső zavarok- ezek tengerhullámok és szél, amelyek eltérítik a hajót az adott iránytól;

a mérési zaj az érzékelő hibája.

Úgy tűnik, hogy a vezérlőrendszerben lévő információk „körbe járnak”: a szabályozó jelet ad ki

vezérlés a meghajtón, amely közvetlenül az objektumra hat; majd az objektumra vonatkozó információ az érzékelőkön keresztül visszakerül a vezérlőhöz, és minden kezdődik elölről. Azt mondják, hogy a rendszernek van visszacsatolása, vagyis a szabályozó az objektum állapotára vonatkozó információkat használja fel a vezérlés fejlesztésére. A visszacsatoló rendszereket zártnak nevezik, mivel az információ továbbítása zárt hurokban történik.

© K.Yu. Poljakov, 2008

1.2.3. Hogyan működik a szabályozó?

A vezérlő összehasonlítja a beállítási jelet ("alapjel", "alapjel", "kívánt érték") az érzékelők visszacsatoló jeleivel, és meghatározza eltérés(vezérlési hiba) – az adott és a tényleges állapot különbsége. Ha nulla, nincs szükség vezérlésre. Ha eltérés van, a szabályozó vezérlőjelet ad ki, amely az eltérést nullára kívánja csökkenteni. Ezért sok esetben a szabályozó áramkört így lehet megrajzolni:

Visszacsatolás

Ez a diagram azt mutatja hibakezelés(vagy eltéréssel). Ez azt jelenti, hogy ahhoz, hogy a szabályozó működni kezdjen, a szabályozott értéknek el kell térnie a beállított értéktől. A ≠-vel jelölt blokk megtalálja az eltérést. A legegyszerűbb esetben egy visszacsatoló jelet (mért értéket) von le egy adott értékből.

Lehetséges egy objektumot vezérelni anélkül, hogy hibát okozna? Valós rendszerekben nem. Elsősorban az előre ismeretlen külső hatások és zajok miatt. Ezenkívül a vezérlőobjektumok tehetetlenséggel rendelkeznek, vagyis nem tudnak azonnal egyik állapotból a másikba mozogni. A vezérlő és a hajtások képességei (vagyis a vezérlőjel teljesítménye) mindig korlátozottak, ezért a vezérlőrendszer sebessége (új üzemmódba való átállás sebessége) is korlátozott. Például egy hajó kormányzásakor a kormánylapát szöge általában nem haladja meg a 30-35°-ot, ez korlátozza az irányváltás sebességét.

Megfontoltuk azt a lehetőséget, amikor visszacsatolást használunk a vezérlőobjektum megadott és tényleges állapota közötti különbség csökkentésére. Az ilyen visszacsatolást negatív visszacsatolásnak nevezzük, mivel a visszacsatoló jelet levonják a parancsjelből. Lehet fordítva is? Kiderül, hogy igen. Ebben az esetben a visszacsatolást pozitívnak nevezzük, növeli az eltérést, vagyis hajlamos „megingatni” a rendszert. A gyakorlatban a pozitív visszacsatolást például generátoroknál alkalmazzák a csillapítatlan elektromos rezgések fenntartására.

1.2.4. Nyílt hurkú rendszerek

Lehetséges a vezérlés visszacsatolás nélkül? Elvileg lehetséges. Ebben az esetben a vezérlő nem kap információt az objektum valós állapotáról, így pontosan tudni kell, hogyan viselkedik ez az objektum. Csak ezután lehet előre kiszámolni, hogyan kell irányítani (felépíteni a szükséges vezérlőprogramot). A feladat elvégzésére azonban nincs garancia. Az ilyen rendszereket ún programvezérlő rendszerek vagy nyílt hurkú rendszerek, mivel az információ továbbítása nem zárt hurokban, hanem csak egy irányban történik.

Vak vagy süket sofőr is vezethet autót. Egy ideig. Mindaddig, amíg emlékszik az útra, és helyesen tudja kiszámítani a helyét. Egészen addig, amíg nem találkozik olyan gyalogosokkal vagy más autókkal az úton, amelyekről nem tudhat előre. Ebből az egyszerű példából világos, hogy anélkül

© K.Yu. Poljakov, 2008

visszacsatolás (érzékelőktől származó információ) nem tudjuk figyelembe venni az ismeretlen tényezők hatását és tudásunk hiányosságát.

E hátrányok ellenére a gyakorlatban nyílt hurkú rendszereket alkalmaznak. Például egy információs tábla a vasútállomáson. Vagy egy egyszerű motorvezérlő rendszer, amelyben nem szükséges nagyon pontosan tartani a fordulatszámot. Ellenőrzéselméleti szempontból azonban a nyílt hurkú rendszerek kevéssé érdekesek, róluk többet nem is beszélünk.

1.3. Milyen típusú vezérlőrendszerek léteznek?

Automata rendszer olyan rendszer, amely emberi beavatkozás nélkül működik. Van még néhány automatizált rendszerek, amelyekben a rutinfolyamatokat (információgyűjtés és -elemzés) számítógép hajtja végre, de a teljes rendszert egy emberi kezelő irányítja, aki döntéseket hoz. Csak az automata rendszereket vizsgáljuk tovább.

1.3.1. Az irányítási rendszerek céljai

Az automatikus vezérlőrendszereket háromféle probléma megoldására használják:

stabilizálás, vagyis egy adott üzemmód fenntartása, amely hosszú ideig nem változik (a beállítási jel állandó, gyakran nulla);

szoftveres vezérlés– vezérlés egy korábban ismert program szerint (a beállítási jel változik, de előre ismert);

ismeretlen mesterjel követése.

NAK NEK stabilizáló rendszerek közé tartoznak például a hajókon lévő robotpilóták (adott irány megtartása), a turbina fordulatszám-szabályozó rendszerei. A programozott vezérlőrendszereket széles körben használják háztartási készülékekben, például mosógépekben. A szervorendszerek jelek erősítésére és konvertálására szolgálnak, meghajtókban és parancsok továbbítására szolgálnak kommunikációs vonalakon, például az interneten keresztül.

1.3.2. Egydimenziós és többdimenziós rendszerek

A bemenetek és kimenetek száma szerint vannak

egydimenziós rendszerek, amelyeknek egy bemenete és egy kimenete van (ezeket az ún. klasszikus vezérléselmélet tekinti);

többdimenziós rendszerek több bemenettel és/vagy kimenettel (a modern szabályozáselmélet fő vizsgálati tárgya).

Csak olyan egydimenziós rendszereket fogunk vizsgálni, ahol az objektumnak és a vezérlőnek is egy bemeneti és egy kimeneti jele van. Például, amikor egy hajót egy pályán kormányozunk, feltételezhetjük, hogy van egy vezérlő művelet (a kormány elfordítása) és egy vezérelt változó (pálya).

A valóságban azonban ez nem teljesen igaz. A helyzet az, hogy amikor az irány megváltozik, a hajó dőlése és trimme is megváltozik. Az egydimenziós modellben ezeket a változásokat figyelmen kívül hagyjuk, bár nagyon jelentősek lehetnek. Például éles kanyar során a dobás elfogadhatatlan értéket érhet el. Ellenben a vezérléshez nem csak a kormányt használhatod, hanem különféle tolóerőket, dőlésszög-stabilizátorokat stb., vagyis az objektumnak több bemenete is van. Így a valós pályairányító rendszer többdimenziós.

A többdimenziós rendszerek tanulmányozása meglehetősen összetett feladat, és túlmutat e kézikönyv keretein. Ezért a mérnöki számításokban néha megpróbálnak egy többdimenziós rendszert több egydimenziós rendszerré egyszerűsíteni, és gyakran ez a módszer sikerre vezet.

1.3.3. Folyamatos és diszkrét rendszerek

A rendszerjelek jellege szerint lehetnek

folytonos, amelyben minden jel a folyamatos idő függvénye, meghatározott intervallumon belül;

diszkrét, amelyben diszkrét jeleket (számsorokat) használnak, csak bizonyos időpontokban definiálva;

© K.Yu. Poljakov, 2008

folytonos-diszkrét, amelyek folyamatos és diszkrét jeleket is tartalmaznak. A folyamatos (vagy analóg) rendszereket általában differenciálegyenletekkel írják le. Ezek mind olyan mozgásvezérlő rendszerek, amelyek nem tartalmaznak számítógépeket vagy egyéb elemeket.

diszkrét műveleti eszközök (mikroprocesszorok, logikai integrált áramkörök). A mikroprocesszorok és a számítógépek különálló rendszerek, mert minden információt tartalmaznak

a máció tárolása és feldolgozása diszkrét formában történik. A számítógép nem tudja feldolgozni a folyamatos jeleket, mert csak azzal működik sorozatok számok. A diszkrét rendszerekre példákat találhatunk a közgazdaságtanban (referencia időszak - negyedév vagy év) és a biológiában (ragadozó-zsákmány modell). Leírásukra differenciálegyenleteket használnak.

Vannak hibridek is folytonos-diszkrét rendszerek, például számítógépes rendszerek mozgó tárgyak (hajók, repülőgépek, autók stb.) vezérlésére. Ezekben az elemek egy részét differenciálegyenletek, más részüket pedig differenciálegyenletek írják le. Matematikai szempontból ez nagy nehézségeket okoz a vizsgálatukban, ezért a folytonos-diszkrét rendszerek sok esetben leegyszerűsített tisztán folytonos vagy tisztán diszkrét modellekre redukálódnak.

1.3.4. Helyhez kötött és nem helyhez kötött rendszerek

A menedzsment számára nagyon fontos az a kérdés, hogy egy objektum jellemzői idővel változnak-e. Azokat a rendszereket, amelyekben minden paraméter állandó marad, stacionáriusnak nevezzük, ami azt jelenti, hogy „időben nem változik”. Ez az oktatóanyag csak a helyhez kötött rendszerekre vonatkozik.

A gyakorlati problémákban a dolgok gyakran nem ilyen rózsásak. Például egy repülő rakéta üzemanyagot fogyaszt, és ennek következtében a tömege megváltozik. Így a rakéta nem álló objektum. Olyan rendszereket hívunk, amelyekben egy objektum vagy vezérlő paraméterei idővel változnak nem helyhez kötött. Bár létezik a nem stacionárius rendszerek elmélete (a képleteket megírták), a gyakorlatban való alkalmazása nem olyan egyszerű.

1.3.5. A bizonyosság és a véletlenszerűség

A legegyszerűbb megoldás az, ha feltételezzük, hogy az objektum minden paramétere pontosan meghatározott (beállítva), akárcsak a külső hatások. Ebben az esetben arról beszélünk meghatározó olyan rendszerek, amelyeket a klasszikus irányításelméletben figyelembe vettek.

Valós problémák esetén azonban nem rendelkezünk pontos adatokkal. Először is ez a külső hatásokra vonatkozik. Például egy hajó ringatásának tanulmányozásához az első szakaszban feltételezhetjük, hogy a hullám ismert amplitúdójú és frekvenciájú szinusz alakú. Ez egy determinisztikus modell. Igaz ez a gyakorlatban? Természetesen nem. Ezzel a megközelítéssel csak hozzávetőleges, hozzávetőleges eredmények érhetők el.

A modern fogalmak szerint a hullámformát megközelítőleg szinuszok összegeként írják le, amelyeknek véletlenszerű, azaz előre ismeretlen frekvenciái, amplitúdói és fázisai vannak. Az interferencia és a mérési zaj is véletlenszerű jel.

Olyan rendszereket nevezünk, amelyekben véletlenszerű zavarok működnek, vagy egy objektum paraméterei véletlenszerűen változhatnak sztochasztikus(valószínűségi). A sztochasztikus rendszerek elmélete csak valószínűségi eredmények elérését teszi lehetővé. Például nem tudja garantálni, hogy a hajó irányeltérése mindig nem haladja meg a 2°-ot, de megpróbálhatja bizonyos valószínűséggel biztosítani ezt az eltérést (99%-os valószínűség azt jelenti, hogy a követelmény 100-ból 99 esetben teljesül). ).

1.3.6. Optimális rendszerek

A rendszerkövetelmények gyakran úgy fogalmazhatók meg optimalizálási problémák. Optimális rendszerekben a szabályozó úgy van kialakítva, hogy bizonyos minőségi kritériumok minimumát vagy maximumát biztosítsa. Nem szabad elfelejteni, hogy az „optimális rendszer” kifejezés nem jelenti azt, hogy valóban ideális. Mindent az elfogadott kritérium határoz meg - ha sikeresen választják, akkor a rendszer jó lesz, ha nem, akkor fordítva.

© K.Yu. Poljakov, 2008

1.3.7. A rendszerek speciális osztályai

Ha az objektum vagy a zavarok paraméterei nem ismertek pontosan, vagy idővel változhatnak (nem stacionárius rendszerekben), akkor adaptív vagy önbeálló vezérlőket alkalmaznak, amelyekben a szabályozási törvény megváltozik a körülmények változásával. A legegyszerűbb esetben (amikor több korábban ismert működési mód van) egyszerű váltás történik több szabályozási törvény között. Az adaptív rendszerekben gyakran a vezérlő valós időben értékeli az objektum paramétereit, és ennek megfelelően módosítja a szabályozási törvényt egy adott szabály szerint.

Az olyan önhangoló rendszert, amely megpróbálja úgy beállítani a szabályozót, hogy „megtalálja” valamilyen minőségi kritérium maximumát vagy minimumát, extrémnek nevezzük (az extrémum szóból, ami maximumot vagy minimumot jelent).

Sok modern háztartási eszközt (például mosógépet) használnak fuzzy vezérlők, amely a fuzzy logika elveire épül. Ez a megközelítés lehetővé teszi számunkra, hogy formalizáljuk az emberi döntéshozatali módot: „ha a hajó túlságosan jobbra ment, akkor a kormányt nagyon balra kell mozgatni.”

A modern elmélet egyik népszerű iránya a mesterséges intelligencia vívmányainak felhasználása a technikai rendszerek irányítására. A szabályozó neurális hálózatra épül (vagy éppen konfigurálva), amelyet egy humán szakértő előzetesen betanít.

© K.Yu. Poljakov, 2008

2. Matematikai modellek

2.1. Mit kell tudni a kezeléshez?

Bármely vezérlés célja egy objektum állapotának a kívánt módon (a feladatnak megfelelően) megváltoztatása. Az automatikus vezérlés elméletének meg kell válaszolnia a kérdést: „hogyan építsünk olyan szabályozót, amely képes egy adott objektumot úgy irányítani, hogy az elérje a célt?” Ehhez a fejlesztőnek tudnia kell, hogy a vezérlőrendszer hogyan reagál a különböző hatásokra, vagyis szükség van a rendszer modelljére: objektum, hajtás, érzékelők, kommunikációs csatornák, zavarok, zaj.

A modell egy objektum, amelyet egy másik objektum (eredeti) tanulmányozására használunk. A modellnek és az eredetinek valamilyen módon hasonlónak kell lennie, hogy a modell tanulmányozásából levont következtetéseket (bizonyos valószínűséggel) át lehessen vinni az eredetire. Minket elsősorban az érdekel majd matematikai modellek, képletekkel kifejezve. Emellett a leíró (verbális), grafikus, táblázatos és egyéb modelleket is használják a tudományban.

2.2. Bemeneti és kimeneti csatlakozás

Bármely objektum kölcsönhatásba lép a külső környezettel bemenetek és kimenetek segítségével. A bemenetek az objektumra gyakorolt ​​lehetséges hatások, a kimenetek pedig azok a jelek, amelyek mérhetők. Például egy villanymotornál a bemenetek lehetnek tápfeszültség és terhelés, valamint a kimenetek

– tengely forgási sebessége, hőmérséklete.

A bemenetek függetlenek, a külső környezetből „jönnek”. Amikor a bemeneten lévő információ megváltozik, a belső tárgy állapot(így hívják a változó tulajdonságait), és ennek következtében a kimenetek:

Ez azt jelenti, hogy van valami szabály, amely alapján az elem az x bemenetet y kimenetté alakítja. Ezt a szabályt operátornak nevezzük. Ha y = U-t írunk, az azt jelenti, hogy y kimenet érkezik

az U operátor x bemenetre való alkalmazásának eredménye.

A modell felépítése azt jelenti, hogy keresünk egy operátort, amely összeköti a bemeneteket és a kimeneteket. Segítségével megjósolhatja egy objektum reakcióját bármilyen bemeneti jelre.

Vegyünk egy egyenáramú villanymotort. Ennek az objektumnak a bemenete a tápfeszültség (voltban), a kimenete a forgási sebesség (fordulat per másodperc). Feltételezzük, hogy 1 V feszültségnél a forgási frekvencia 1 ford./perc, 2 V – 2 ford./perc feszültségnél, vagyis a forgási frekvencia nagyságrendileg megegyezik a feszültség1-gyel. Könnyen belátható, hogy egy ilyen operátor művelete az űrlapba írható

U[ x] = x .

Most tegyük fel, hogy ugyanaz a motor forgatja a kereket, és a keréknek a kezdeti helyzethez viszonyított fordulatszámát választottuk (t = 0 pillanatban) az objektum kimeneteként. Ebben az esetben egyenletes forgás mellett az x ∆ t szorzat megadja a fordulatok számát ∆ t időben, azaz y (t) = x ∆ t (itt az y (t) jelölés egyértelműen a kimenet függőségét jelöli. időben

sem t). Tekinthetjük-e, hogy ezzel a képlettel definiáltuk az U operátort? Nyilván nem, mert az így keletkező függés csak állandó bemeneti jelre érvényes. Ha az x(t) bemenet feszültsége megváltozik (nem mindegy, hogyan!), akkor a forgásszöget integrálként írjuk.

1 Természetesen ez csak egy bizonyos feszültségtartományon lesz igaz.

AZ OROSZ FÖDERÁCIÓ OKTATÁSI ÉS TUDOMÁNYOS MINISZTÉRIUMA

Szövetségi Állami Autonóm oktatási intézmény felsőfokú szakmai végzettség

"Szentpétervár Állami Egyetem repülési műszerek"

_________________________________________________________________

M. V. Burakov

Az automatikus vezérlés elmélete.

oktatóanyag

Szentpétervár

Ellenőrzők:

Jelölt műszaki tudományok D. O. Yakimovsky (Szövetségi Állami Vállalat „Parancsnoksági Eszközök Kutatóintézete”). A műszaki tudományok kandidátusa, egyetemi docens A. A. Martynov

(Szentpétervári Állami Repülési Műszerészeti Egyetem)

Jóváhagyta az Egyetem Szerkesztői és Kiadói Tanácsa

oktatási segédanyagként

Burakov M.V.

D79 Automatikus vezérlés elmélete: tankönyv. juttatás. 1. rész / M. V. Burakov; – Szentpétervár: GUAP, 2013. -258 p.: ill.

BAN BEN tankönyv Az automatikus vezérlés elméletének alapjait tárgyalják - egy alaptanfolyam mérnökök képzéséhez az automatizálás és vezérlés területén.

Bemutatjuk a vezérlés alapfogalmait, elveit, áttekintjük az átviteli függvények apparátusán alapuló lineáris és diszkrét vezérlőrendszerek matematikai modelljeit, elemzési és szintézismódszereit.

A tankönyv a 220400 „Menedzsment in”. műszaki rendszerek", valamint más szakterületek hallgatói, akik az "Automatikus vezérlés elmélete" és "Az irányításelmélet alapjai" tudományágakat tanulják.

− ALAPVETŐ FOGALMAK ÉS DEFINÍCIÓK

o Az automatika elméletének rövid fejlődéstörténete

skogo menedzsment

Az automatikus vezérlés elmélete úgy definiálható, mint bármely objektum vezérlési törvényeinek meghatározására szolgáló módszerek tudománya, amely technikai eszközökkel megvalósítható.

Az első automata eszközöket az ókorban az ember fejlesztette ki, amint azt a hozzánk eljutott írásos bizonyítékok is bizonyítják. Az ókori görög és római tudósok munkáiban különféle automata eszközök leírását adják meg: hodométer - egy automatikus távolságmérési eszköz, amely a kocsi kerék fordulatszámának újraszámításán alapul; gépek ajtónyitásra és vízárusításra templomokban; automata színházak bütykös mechanizmusokkal; automata adagolású nyíldobó eszköz. Korunk fordulóján az arabok vízórákat szereltek fel úszószint-szabályozóval (1.1. ábra).

A középkorban fejlődött ki az „androidos” automatizálás, amikor a gépészeti tervezők olyan eszközöket hoztak létre, amelyek utánozták az egyéni emberi cselekvéseket. Az „android” név a gép humanoid jellegét hangsúlyozza. Az Androidok óramechanizmusok alapján működtek.

Számos olyan tényező azonosítható, amely a 17-18. században szükségessé tette az irányítási rendszerek kialakítását:

1. az óragyártás fejlődése, amelyet a gyorsan fejlődő hajózás szükségletei vezérelnek;

2. a lisztőrlő ipar fejlődése és a vízimalmok működésének szabályozásának szükségessége;

3. a gőzgép feltalálása.

Rizs. 1.1. Vízóra kialakítás

Bár köztudott, hogy már a középkorban is használtak centrifugális fordulatszám-kiegyenlítőket a vízi malmokban, az első visszacsatolásos szabályozó rendszernek a holland Cornelius Drebbel (1600) hőmérséklet-szabályozóját tartják. 1675-ben X. Huygens ingaszabályzót épített az órába. Denis Papin 1681-ben találta fel az első nyomásszabályozót gőzkazánokhoz.

A gőzgép lett az ipari szabályozók első célpontja, mivel nem volt képes önállóan stabilan működni, i.e. nem volt „önszintező”

mi" (1.2. ábra).

1.2. Gőzgép szabályozóval

Az első ipari szabályozók a gőzgép kazánjának táplálására szolgáló, I. I. Polzunov által 1765-ben épített automatikus úszószabályzó, valamint a gőzgép centrifugális fordulatszám-szabályozója, amelyre J. Watt 1784-ben szabadalmat kapott (1.3. ábra). .

Ezek az első szabályozók közvetlen vezérlőrendszerek voltak, azaz a szabályozók működtetéséhez nem volt szükség további energiaforrásokra - az érzékelő elem közvetlenül mozgatta a szabályozót ( modern rendszerek A vezérlőrendszerek közvetett vezérlőrendszerek, mivel a hibajelzés szinte mindig nem elegendő a szabályozó vezérléséhez).

Rizs. 1.3. Watt centrifugális szabályozója.

Nem véletlen, hogy a gőzgép lett a technológia és az irányításelmélet alkalmazásának első tárgya, hiszen nem volt képes önállóan stabilan működni és nem volt önszintező.

Azt is meg kell jegyezni, hogy fontos az első szoftvereszköz létrehozása a szövőszék lyukkártyával történő vezérlésére (a szőnyegek mintáinak reprodukálására), amelyet 1808-ban épített J. Jacquard.

Polzunov találmánya nem volt véletlen, hiszen a 18. század végén az orosz kohászati ​​ipar vezető pozíciót foglalt el a világon. Ezt követően az orosz tudósok és mérnökök továbbra is nagy mértékben hozzájárultak az automatikus vezérlés elméletének fejlesztéséhez.

A szabályozás elméletéről szóló első munka 1823-ban jelent meg, és Csizsov, a szentpétervári egyetem professzora írta.

BAN BEN 1854 K. I. Konstantinov javasolta az általa kifejlesztett „elektromágneses fordulatszám-szabályozó” használatát a gőzgépekben a kúpos inga helyett. Centrifugális mechanizmus helyett elektromágnest használ a gőz áramlásának szabályozására a gépbe. A Konstantinov által javasolt szabályozó nagyobb érzékenységű volt, mint a kúpos ingának.

BAN BEN 1866 A.I. Shpakovsky kifejlesztett egy szabályozót egy gőzkazánhoz, amelyet fúvókákkal fűtöttek. A fúvókákon keresztüli tüzelőanyag-ellátás arányos volt a kazán gőznyomásának változásával. Ha a nyomás csökkent, az üzemanyag-áramlás a befecskendezőkön keresztül megnőtt, ami a hőmérséklet emelkedéséhez és ennek következtében a nyomás növekedéséhez vezetett.

BAN BEN 1856-ban Moszkvában a koronázáskor Alexandra III Hat erős elektromos ívlámpát szereltek fel automatikus Shpakovsky szabályozóval. Ez volt az első gyakorlati tapasztalat az elektromechanikus szabályozók sorozatának telepítése és hosszú távú üzemeltetése terén.

1869-1883 között V. N. Chikolev számos elektromechanikus szabályozót fejlesztett ki, köztük egy differenciálszabályzót ívlámpákhoz, amelyek fontos szerepet játszottak a szabályozástechnika történetében.

Az automatikus vezérlés (ATC) elméletének születési dátumát általában 1868-nak nevezik, amikor megjelent J. Maxwell „On Regulators” című munkája, amelyben a differenciálegyenletet használták a vezérlő modelljeként.

A TAU fejlesztéséhez nagy mértékben hozzájárult az orosz matematikus és mérnök, I. A. Vyshnegradsky. A „Körülbelül általános elmélet szabályozók”, 1876-ban megjelent, a gőzgépet és a centrifugális szabályozót egyetlen dinamikus rendszernek tekintette. Vyshnegradsky levonta a gyakorlatban a legfontosabb következtetéseket a rendszerek stabil mozgásáról. Először vezette be a differenciálegyenletek linearizálásának fogalmát, jelentősen leegyszerűsítve ezzel a kutatás matematikai apparátusát.