Вроде описали все что надо, даже больше чем нужно (в рамках этой статьи). Теперь отнаследуем от него класс корабля Ship , который должен уметь двигаться и поворачивать:

SpaceShip.cs

using UnityEngine; using System.Collections; using System.Collections.Generic; namespace Assets.Scripts.SpaceShooter.Bodies { public class Ship: 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) { float result = 0f; return result; } public Vector2 ControlForce(Vector2 movement) { Vector2 result = new Vector2(); return result; } } }

Пока в нем нет ничего интересно, на текущий момент это просто класс-заглушка.

Также опишем базовый(абстрактный) класс для всех контроллеров ввода BaseInputController:

BaseInputController.cs

using UnityEngine; using Assets.Scripts.SpaceShooter.Bodies; namespace Assets.Scripts.SpaceShooter.InputController { public enum eSpriteRotation { Rigth = 0, Up = -90, Left = -180, Down = -270 } public abstract class BaseInputController: MonoBehaviour { public GameObject _agentObject; public Ship _agentBody; // Ссылка на компонент логики корабля public eSpriteRotation _spriteOrientation = eSpriteRotation.Up; //Это связано с нестандартной // ориентации спрайта "вверх" вместо "вправо" public abstract void ControlRotate(float dt); public abstract void ControlForce(float dt); public virtual 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 } } }

И наконец, класс контроллера игрока PlayerFigtherInput :

PlayerInput.cs

using UnityEngine; using Assets.Scripts.SpaceShooter.Bodies; namespace Assets.Scripts.SpaceShooter.InputController { public class PlayerFigtherInput: BaseInputController { public override void ControlRotate(float dt) { // Определяем позицию мыши относительно игрока Vector3 worldPos = Input.mousePosition; worldPos = Camera.main.ScreenToWorldPoint(worldPos); // Сохраняем координаты указателя мыши float dx = -this.transform.position.x + worldPos.x; float dy = -this.transform.position.y + worldPos.y; //Передаем направление Vector2 target = new Vector2(dx, dy); _agentBody._target = target; //Вычисляем поворот в соответствии с нажатием клавиш float targetAngle = Mathf.Atan2(dy, dx) * Mathf.Rad2Deg; _agentBody._targetAngle = targetAngle + (float)_spriteOrientation; } public override void ControlForce(float dt) { //Передаем movement _agentBody._movement = Input.GetAxis("Vertical") * Vector2.up + Input.GetAxis("Horizontal") * Vector2.right; } } }

Вроде бы закончили, теперь наконец можно перейти к тому, ради чего все это затевалось, т.е. ПИД-регуляторам (не забыли надеюсь?). Его реализация кажется простой до безобразия:

Значения коэффициентов по умолчанию возьмем с потолка: это будет тривиальный единичный коэффициент пропорционального закона управления Kp = 1, небольшое значение коэффициента для дифференциального закона управления Kd = 0.2, который должен устранить ожидаемые колебания и нулевое значение для Ki, которое выбрано потому, что в нашей программной модели нет никаких статичных ошибок (но вы всегда можете их внести, а потом героически побороться с помощью интегратора).

Теперь вернемся к нашему классу SpaceShip и попробуем заюзать наше творение в качестве регулятора поворота космического корабля в методе ControlRotate:

ПИД-регулятор будет осуществлять точное угловое позиционировая космического корабля только за счет крутящего момента . Все честно, физика и САУ, почти как в реальной жизни.

И без этих ваших Quaternion.Lerp

if (!_rb2d.freezeRotation) rb2d.freezeRotation = true; float deltaAngle = Mathf.DeltaAngle(_myTransform.eulerAngles.z, targetAngle); float T = dt * Mathf.Abs(_rotationSpeed / deltaAngle); // Трансформируем угол в вектор Quaternion rot = Quaternion.Lerp(_myTransform.rotation, Quaternion.Euler(new Vector3(0, 0, targetAngle)), T); // Изменяем поворот объекта _myTransform.rotation = rot;

Получившейся исходный код Ship.cs под спойлером

using UnityEngine; using Assets.Scripts.Regulator; namespace Assets.Scripts.SpaceShooter.Bodies { public class Ship: 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.AddRelativeForce(force); } public float ControlRotate(float rotate) { float MV = 0f; float dt = Time.fixedDeltaTime; _angle = _myTransform.eulerAngles.z; //Вычисляем ошибку float angleError = Mathf.DeltaAngle(_angle, rotate); //Получаем корректирующее ускорение MV = _angleController.Update(angleError, dt); 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; return MV; } } }

Все? Расходимся по домам?

WTF! Что происходит? Почему корабль поворачивается как-то странно? И почему он так резко отскакивает от других объектов? Неужели этот глупый ПИД-регулятор не работает?

Без паники! Давайте попробуем разобраться что происходит.

В момент получения нового значения SP, происходит резкий (ступенчатый) скачок рассогласования ошибки, которая, как мы помним, вычисляется вот так: соответственно происходит резкий скачок производной ошибки , которую мы вычисляем в этой строчке кода:

Можно, конечно, попробовать другие схемы дифференцирования , например, трехточечную, или пятиточечную, или… но все равно это не поможет. Ну вот не любят производные резких скачков - в таких точках функция не является дифференцируемой . Однако поэкспериментировать с разными схемами дифференцирования и интегрирования стоит, но потом и не в этой статье.

Думаю что настал момент построить графики переходного процесса : ступенчатое воздействие от S(t) = 0 в SP(t) = 90 градусов для тела массой в 1 кг, длинной плеча силы в 1 метр и шагом сетки дифференцирования 0.02 с - прям как в нашем примере на Unity3D (на самом деле не совсем, при построении этих графиков не учитывалось, что момент инерции зависит от геометрии твердого тела, поэтому переходный процесс будет немножко другой, но все же достаточно похожий для демонстрации). Все величены на грифике приведены в абсолютных значениях:


Хм, что здесь происходит? Куда улетел отклик ПИД-регулятора?

Поздравляю, мы только что столкнулись с таким явлением как "удар" (kick). Очевидно, что в момент времени, когда процесс еще PV = 0, а уставка уже SP = 90, то при численном дифференцировании получим значение производной порядка 4500, которое умножится на Kd=0.2 и сложится с пропорциональным теромом, так что на выходе мы получим значение углового ускорения 990, а это уже форменное надругательство над физической моделью Unity3D (угловые скорости будут достигать 18000 град/с… я думаю это предельное значение угловой скорости для RigidBody2D).

• Может стоит подобрать коэффициенты ручками, так чтобы скачок был не таким сильным?
• Нет! Самое лучше чего мы таким образом сможем добиться - небольшая амплитуда скачка производной, однако сам скачок как был так и останется, при этом можно докрутиться до полной неэффективности дифференциальной составляющей.

Впрочем можете поэкспериментировать.

Попытка номер два. Сатурация

Логично, что привод (в нашем случае виртуальные маневровые двигатели SpaceShip), не может отрабатывать сколько угодно большие значения которые может выдать наш безумный регулятор. Так что первое что мы сделаем - сатурируем выход регулятора:

А очередной раз переписанный класс Ship полностью выглядит так

namespace Assets.Scripts.SpaceShooter.Bodies { public class Ship: 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); _rb2d.AddTorque(_torque); _rb2d.AddRelativeForce(_force); } public float ControlRotate(float targetAngle, float thrust) { float CO = 0f; float MV = 0f; float dt = Time.fixedDeltaTime; //Вычисляем ошибку float angleError = Mathf.DeltaAngle(_myTransform.eulerAngles.z, targetAngle); //Получаем корректирующее ускорение CO = _angleController.Update(angleError, dt); //Сатурируем MV = CO; if (MV > thrust) MV = thrust; 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() { } } }

Итоговая схема нашего САУ тогда станет уже вот такой

При этом уже становится понятно, что выход контроллера CO(t) немного не одно и тоже, что управляемая величина процесса MV(t) .

Собственно с этого места можно уже добавлять новую игровую сущность - привод , через которую и будет осуществляться управление процессом, логика работы которой может быть более сложной, чем просто Mathf.Clamp(), например, можно ввести дискретизацию значений (дабы не перегружать игровую физику величинами идущими шестыми после запятой), мертвую зону (опять таки не имеет смысл перегружать физику сверхмалыми реакциями), ввести задержку в упраление и нелинейность (например, сигмоиду) привода, после чего посмотреть, что из этого получится.

Запустив игру, мы обнаружим, что космический корабль стал наконец управляемым:

Если построить графики, то можно увидеть, что реакция контроллера стала уже вот такой:


Здесь уже используются нормированные величены, углы поделены на значение SP, а выход контроллера отнормирован относительно максимального значения на котором уже происходит сатурация.

Ниже приведена известна таблица влияния увеличения параметров ПИД-регулятора (как уменьшить шрифт, а то таблица безе переносов не лезет? ):

А общий алгоритм ручной настройки ПИД-регулятора следующий:

1. Подбираем пропорциональный коэффициенты при отключенных дифференциальных и интегральных звеньях до тех пор пока не начнутся автоколебания.
2. Постепенно увеличивая дифференциальную составляющую избавляемся от автоколебаний
3. Если наблюдается остаточная ошибка регулирования (смещение), то устраняем её за счет интегральной составляющей.

Каких-то общих значений параметров ПИД-регулятора нет: конкретные значения зависят исключительно от параметров процесса (его передаточной характеристики): ПИД-регулятор отлично работающий с одним объектом управления окажется неработоспособным с другим. Более того, коэффициенты при пропорциональной, интегральной и дифференциальной составляющих еще и взаимозависимы.

Попытка номер три. Еще раз производные

Приделав костыль в виде ограничения значений выхода контроллера мы так и не решили самую главную проблему нашего регулятора - дифференциальная составляющая плохо себя чувствует при ступенчатом изменении ошибки на входе регуляторе. На самом деле есть множество других костылей, например, в момент скачкообразного изменения SP "отключать" дифференциальную составляющую или же поставить фильтры нижних частот между SP(t) и операцией за счет которого будет происходить плавное нарастание ошибки, а можно совсем развернуться и впендюрить самый настоящий фильтр Калмана для сглаживания входных данных. В общем костылей много, и добавить наблюдателя конечно хотелось бы, но не в этот раз.

Поэтому снова вернемся к производной ошибки рассогласования и внимательно на неё посмотрим:

Ничего не заметили? Если хорошенько присмотреться, то можно обнаружить, что вообще-то SP(t), не меняется во времени (за исключением моментов ступенчатого изменения, когда регулятор получает новую команду), т.е. её производная равна нулю:

Иными словами, вместо производной ошибки, которая дифференцируема не везде мы можем использовать производную от процесса, который в мире классической механики как правило непрерывен и дифференцируем везде, а схема нашей САУ уже приобретет следующий вид:

Модифицируем код регулятора:

И немного изменим метод ControlRotate:

И-и-и-и… если запустить игру, то обнаружиться, что на самом деле ничего ничего не изменилось с последней попытки, что и требовалось доказать. Однако, если убрать сатурацию, то график реакции регулятора будет выглядеть вот так:


Скачок CO(t) по прежнему присутствует, однако он уже не такой большой как был в самом начале, а самое главное - он стал предсказуемым, т.к. обеспечивается исключительно пропорциональной составляющей, и ограничен максимально возможной ошибкой рассогласования и пропорциональным коэффициентом ПИД-регулятора (а это уже намекает на то, что Kp имеет смысл выбрать все же меньше единицы, например, 1/90f), но не зависит от шага сетки дифференцирования (т.е. dt ). В общем, я настоятельно рекомендую использовать именно производную процесса, а не ошибки.

Думаю теперь никого не удивит, но таким же макаром можно заменить на , однако останавливаться на этом мы не будем, можете сами поэкспериментировать и рассказать в комментариях, что из этого получилось (самому интересно)

Попытка номер четыре. Альтернативные реализации ПИД-регулятор

Помимо описанного выше идеального представления ПИД-регулятора, на практике часто применяется стандартная форма, без коэффициентов Ki и Kd , вместо которых используются временные постоянные.

Такой подход связан с тем, что ряд методик настройки ПИД-регулятора основан на частотных характеристиках ПИД-регулятора и процесса. Собственно вся ТАУ и крутится вокруг частотных характеристик процессов, поэтому для желающих углубиться, и, внезапно, столкнувшихся с альтернативной номенклатурой, приведу пример т.н. стандартной формы ПИД-регулятора:

где, - постоянная дифференцирования, влияющая на прогнозирование состояния системы регулятором,
- постоянная интегрирования, влияющая на интервал усреднения ошибки интегральным звеном.

Основные принципы настройки ПИД-регулятора в стандартной форме аналогичны идеализированному ПИД-регулятору:

• увеличение пропорционального коэффициента увеличивает быстродействие и снижает запас устойчивости;
• с уменьшением интегральной составляющей ошибка регулирования с течением времени уменьшается быстрее;
• уменьшение постоянной интегрирования уменьшает запас устойчивости;
• увеличение дифференциальной составляющей увеличивает запас устойчивости и быстродействие

Исходный код стандартной формы, вы можете найти под спойлером

namespace Assets.Scripts.Regulator { public class 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; bias = 0f; } public StandartPID(float Kp, float Ti, float Td) { this.Kp = Kp; this.Ti = Ti; this.Td = Td; } public float Update(float error, float PV, float dt) { this.error = error; P = error; I += (1 / Ti) * error * dt; D = -Td * (PV - lastPV) / dt; CO = Kp * (P + I + D); lastPV = PV; return CO; } } }

В качестве значений по умолчанию, выбраны Kp = 0.01, Ti = 10000, Td = 0.5 - при таких значениях корабль поворачивается достаточно быстро и обладает некоторым запасом устойчивости.

Помимо такой формы ПИД-регулятора, часто используется т.н. реккурентная форма :

Не будем на ней останавливаться, т.к. она актуальна прежде всего для хардверных программистов, работающих с FPGA и микроконтроллерами, где такая реализация значительно удобнее и эффективнее. В нашем же случае - давайте что-нибудь сваям на Unity3D - это просто еще одна реализация ПИД-контроллера, которая ни чем не лучше других и даже менее понятная, так что еще раз дружно порадуемся как хорошо программировать в уютненьком C#, а не в жутком и страшном VHDL, например.

Вместо заключения. Куда бы еще присобачить ПИД-регулятор

Теперь попробуем немного усложнить управление корабля используя двухконтурное управление: один ПИД-регулятор, уже знакомый нам _angleController, отвечает по прежнему за угловое позиционирование, а вот второй - новый, _angularVelocityController - контролирует скорость поворота:

Назначение второго регулятора - гашение избыточных угловых скоростей, за счет изменения крутящего момента - это сродни наличию углового трения, которое мы отключили еще при создании игрового объекта. Такая схема управления [возможно] позволит получить более стабильное поведение корабля, и даже обойтись только пропорциональными коэффициентами управления - второй регулятор будет гасить все колебания, выполняя функцию, аналогичную дифференциальной составляющей первого регулятора.

Помимо этого, добавим новый класс ввода игрока - PlayerInputCorvette, в котором повороты буду осуществляться уже за счет нажатия клавиш "вправо-влево", а целеуказание с помощью мыши мы оставим для чего-нибудь более полезного, например, для управления турелью. Заодно у нас теперь появился такой параметр как _turnRate - отвечающий за скорость/отзывчивость поворота (не понятно только куда его поместить лучше в InputCOntroller или все же Ship).

Также для наглядности накидаем на коленках скрипт для отображения отладочной информации

namespace Assets.Scripts.SpaceShooter.UI { public class Debugger: MonoBehaviour { Ship _ship; BaseInputController _controller; List _pids = new List(); List _names = new List(); Vector2 _orientation = new Vector2(); // Use this for initialization void Start() { _ship = GetComponent(); _controller = GetComponent(); _pids.Add(_ship._angleController); _names.Add("Angle controller"); _pids.Add(_ship._angularVelocityController); _names.Add("Angular velocity controller"); } // Update is called once per frame void Update() { DrawDebug(); } Vector3 GetDiretion(eSpriteRotation spriteRotation) { switch (_controller._spriteOrientation) { case eSpriteRotation.Rigth: return transform.right; case eSpriteRotation.Up: return transform.up; case eSpriteRotation.Left: return -transform.right; case eSpriteRotation.Down: return -transform.up; } return Vector3.zero; } void DrawDebug() { //Направление поворота Vector3 vectorToTarget = transform.position + 5f * new Vector3(-Mathf.Sin(_ship._targetAngle * Mathf.Deg2Rad), Mathf.Cos(_ship._targetAngle * Mathf.Deg2Rad), 0f); // Текущее направление Vector3 heading = transform.position + 4f * GetDiretion(_controller._spriteOrientation); //Угловое ускорение Vector3 torque = heading - transform.right * _ship._Torque; Debug.DrawLine(transform.position, vectorToTarget, Color.white); Debug.DrawLine(transform.position, heading, Color.green); Debug.DrawLine(heading, torque, 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 in _pids) { 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(); 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 = new 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(), style2); GUI.TextField(new Rect(235 + x0, 35 + y0, 60, 10), pid.Kd.ToString(), style2); GUI.Label(new Rect(0 + x0, -8 + y0, 200, 10), _names, style2); } } } }

Класс Ship также претерпел необратимые мутации и теперь должен выглядеть вот так:

namespace Assets.Scripts.SpaceShooter.Bodies { public class Ship: 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 SimplePID _angularVelocityController = new SimplePID(0f,0f,0f); private float _torque = 0f; public float _Torque { get { return _torque; } } private Vector2 _force = new Vector2(); public Vector2 _Force { get { return _force; } } public void FixedUpdate() { _torque = ControlRotate(_targetAngle, _thrust); _force = ControlForce(_movement, _thrust); _rb2d.AddTorque(_torque); _rb2d.AddRelativeForce(_force); } public float ControlRotate(float targetAngle, float thrust) { float CO = 0f; float MV = 0f; float dt = Time.fixedDeltaTime; _angle = _myTransform.eulerAngles.z; //Контроллер угла поворота float angleError = Mathf.DeltaAngle(_angle, targetAngle); float torqueCorrectionForAngle = _angleController.Update(angleError, _angle, dt); //Контроллер стабилизации скорости float angularVelocityError = -_rb2d.angularVelocity; float torqueCorrectionForAngularVelocity = _angularVelocityController.Update(angularVelocityError, -angularVelocityError, dt); //Суммарный выход контроллера CO = torqueCorrectionForAngle + torqueCorrectionForAngularVelocity; //Дискретизируем с шагом 100 CO = Mathf.Round(100f * CO) / 100f; //Сатурируем MV = CO; if (CO > thrust) MV = thrust; 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() { } } }

Еще немного ссылок на другие примеры

ПИД (или английская аббревиатура — PID) – это регулятор, осуществляющий пропорциональное, интегрирующее и дифференциальное управление. ПИД регуляторы находят широкое применение в современных системах точного контроля, таких как управление термосистемами и системами позиционирования. Использование ПИД регуляторов помогает уменьшить энергетические потери на настройку системы и обеспечивают более быстрый выход на требуемые параметры.

В общем случае ПИД регулятор получает значение определяющего параметра от объекта (Рис. 1) и воздействует на управление, состояние которого влияет на исходный параметр. Классическим примером применения ПИД регулятора являются управление термосистемой, будь это нагреватель или холодильная установка. Данный пример интересен тем, что нагрев или охлаждение процессы достаточно инертные и зачастую снижение температуры получается естественным путем из-за потерь

ПИД регуляторы применяются в системах, математическое описание которых трудоемко, или не может быть получено из-за случайного характера воздействия внешней среды или помех. Для термосистемы информация о состоянии объекта представляет собой значение температуры с датчика, а объект управления – нагреватель системы. Размерности графиков приведены условно, так как точная модель регулятора зависит от конкретных особенностей термосистемы.

Пропорциональное управление рассчитывается как произведение постоянного коэффициента К p на текущую ошибку отклонения. Если включить в обратную связь нагревателя термосистемы только пропорциональное управление, требуемую температуру вообще невозможно достичь (Рис. 2). Это связано с инерционностью системы, так как управление нагревателем должно осуществляется с учетом динамики повышения температуры объекта.

Интегральное регулирование реализуется умножениясуммы ошибок температурдо текущего момента временина интегральный коэффициент K I . Для термосистем интегрирующее управление вполне может поддерживать заданную температуру(Рис. 3). Такое управление компенсирует запаздывание нагревание объекта и позволяет приблизиться к требуемому значению с большей или меньшей точностью. Для систем с меньшей инерционностью применения только интегрального управления неприменимо, так как запаздывание процесса накопления ошибки приведет к «вылетанию» регулируемого параметра и появлению колебаний.

С применением дифференциального управления система получает возможность компенсировать возможную будущую ошибку параметра. Расчет дифференциальной составляющей численно выглядит как разность между текущим и предыдущим значением параметра, умноженную на коэффициент регулирования K D . Так как используется измерения, выполненные в небольшом интервале времени, ошибки и внешнее воздействие сильно влияет на процесс регулирования. Дифференциальное управление в чистом виде трудно реализуется для большинства систем из-за указанных факторов.

В сумме, три компоненты ПИД регулятора обеспечивает получение эффективного результата в коротком промежутке времени (Рис. 4).

На практике лучшие результаты достигаются подбором констант для каждого компонента регулирования. Также находят применения саморегулирующие ПИД контроллеры, для которых коэффициенты рассчитываются программным путем внутри системы.

Регулятор - устройство, которое следит за работой объекта управления и вырабатывает для него управляющие(регулирующие) сигналы.

Регуляторы могут быть выполнены в виде отдельного устройства или в виде прикладного пакета в основной программе управляющего устройства.

Аппаратные регуляторыможно разделить:

1.по использованию для работы внешней энергии:

регуляторы прямого действия, не используют внешнюю энергию. Работают за счёт энергии развиваемой датчиком, просты по конструкции, не дороги, но имеют не высокую точность. Используют в простейших системах регулирования.

регуляторы не прямого действия,используют внешнюю энергию для своей работы-это основной вид регуляторов.

2.по виду используемой внешней энергии:

• электрические;
• пневматические;
• гидравлические;
• комбинированные.

3.по виду регулируемого параметра: регуляторы температуры, давления, уровня, расхода и т. д.

4.по закону регулирования, т.е. по изменению регулирующего воздействия во времени при изменении регулируемого параметра(по виду переходной характеристике регулятора). Эти регуляторы могут быть аппаратного типа(аналоговые) и дигитальные, в виде программного пакета.

Различают следующие виды регулирований:

• P (П ) - означает « пропорциональный »
• I (И ) – « интегральный »
• D (Д ) – « дифференциальный »
• PI (ПИ ) – « пропорциональный и интегральный »
• PD (ПД ) – « пропорциональный и дифференциальный »
• PID (ПИД ) – « пропорциональный, интегральный и дифференциальный »

Свойства и типы регуляторов

1. P-регулятор , пропорциональный регулятор.

Передаточная функция P-регулятора: Gp(s) = Kp. Pегулятор вырабатывает управляющее воздействие на объект пропорционально величине ошибки (чем больше ошибка e, тем больше управляющее воздействие Y= Kp*e).

2. I-регулятор , интегрирующий регулятор.

Передаточная функция I-регулятора: Gi(s) = 1/Ti*s. Управляющее воздействие пропорционально интегралу от ошибки е:

3. D -регулятор , дифференцирующий регулятор.
Передаточная функция D -регулятора: G d ( s ) = T d * s . D регулятор создаёт управляющее воздействие только при изменении регулируемой величины: Y = T d * de / dt .

У P -регулятора , его называют также статическим,изменение положения РО пропорционально отклонению регулируемого параметра «е » от его заданного значения X 0 .

Преимущества Р-регулятора – его быстродействие (небольшое время регулирования tp ) и высокая устойчивость процесса регулирования.

Недостаток – наличие статической ошибки δ Х,т.е. после окончания процесса регулирования(за время регулирования t p) параметр не возвращается точно к заданному значению, а отличается от заданного на δ Х,что снижает точность регулирования. С увеличением коэффициента усиления Кр, величина δ Хуменьшается, но АСР может потерять устойчивость. При Кр = Кр кр в системе возникают не затухающие колебания с постоянной амплитудой, а при ещё большем Кр, с возрастающей амплитудой. Рис. 93

1 – регулируемый процесс с P регулятором при K p < K p .кр
2 – Регулируемый процесс при K p = K р.кр

T кр – период не затухающих колебаний при K p = K р.кр

t р – время регулирования для устойчивого процесса

X 0 – начальное значение регулируемого параметра

δ Х – статическая ошибка

У I -регулятора , его называют также a статическим,изменение положения РО пропорционально интегралу от отклонения «е » регулируемого параметра от его заданного значения X 0 . Регулирующий орган будет перемещаться до тех пор, пока параметр не достигнет точно заданного значения, т.е. у него нет статической ошибки δ Х=0. Это его достоинство, но недостатком является его плохая устойчивость, большое время регулирования. Его можно применять на инерционных объектах с самовыравниванием.

У D –регулятора , регулирующее воздействие пропорционально скорости отклонения параметра от задания т.е. производной от отклонения «е ». На рисунке 94 при ступенчатом изменении U(t ), возникает сигнал ошибки е , которыйбудет уменьшаться в процессе регулирования t , до тех пор, пока параметр не достигнет нового значения U(t).t 0 - начало отклонения параметра, t 1- момент срабатывания регулятора без сигнала по производной, «Δ» - зона нечувствитвльности регулятора.

Скорость отклонения в начальный момент большая и поэтому сигнал по скорости будет большим , регулятор сразу начнёт действовать в момент t1 ,ещё до заметного«Δ» отклонения параметра и параметр будет быстрее установлен к заданию U(t) .

Таким образом, этот регулятор имеет повышенное быстродействие – это его достоинство. Недостаток – не стабилен в работе, поэтом отдельно не используется. Но этот принцип используют для повышения качества регулирования PD и PID регуляторов.

Комбинируя простейшие P , I , D , регуляторы, получают PI , PD , PID регуляторы. На практике в основном применяют Р , PI , PID регуляторы

PI - регулятор, комбинация Р и I регуляторов. Имеет достоинства обоих. От Р – хорошая устойчивость, от I δ Х=0.

PD - регулятор, комбинация Р и D регуляторов. Имеет достоинства обоих. От Р – хорошая устойчивостьи, от D – повышенное быстродействие, но сохраняется статическая ошибка δ Х, как у Р регулятора.

PID - регулятор, комбинация Р, I и D регуляторов. Имеет достоинства троих.От Р – хорошая устойчивостьи, от I – отсутствие статической ошибки δ Х=0, от D – повышенное быстродействие.

PID - регулятор по своим возможностям наиболее универсален. В настоящее время в основном применяются электронные и цифровые PID –регуляторы, на основе которого можно осуществлять различные законы регулирования.

Структурная схема PID регулятора

На Рис.95показана структурная схема PID регулятора

Рис. 95 Структурная схема PID регулятора

K p – коэффициент усиления регулятора

T i – постоянная интегрирования

T d – постоянная дифференцирования

Это настроечные параметры регуляторов

Переходные характеристики регуляторов показаны на Рис.96. Для P, I и D регуляторов они аналогичны характеристикам соответствующих типовых звеньев. Для остальных регуляторов, характеристики получают сложением характеристик P, I, и D регуляторов.

Переходные характеристики показывают как изменяется регулирующее воздействие регулятора Y во времени при отклонении регулируемого параметра X от задания т.е. при появлении сигнала ошибки «е».

При отклонении, уменьшении температуры в объекте (X) ,у Р регулятора , регулирующий клапан приоткроется (Y) пропорционально отклонению температуры и остановится. Подача тепла увеличится и температура , быстро восстановится, но не точно, возникнет статическая ошибка δ Х.

У PID регулятора, за счёт Р и D составляющих, клапан сначала сильно откроется, обеспечивая быструю подачу тепла, но затем, чтобы не возникло перегрева, начнёт прикрываться, обеспечивая подачу нужного тепла в объект. Затем вступает в действие I составляющая, которая приоткрывает клапан до тех пор, пока не будетустранена статическая ошибка δ Х. Таким образом D составляющая увеличивает быстродействие регулятора, а I составляющая убирает статическую ошибку δ Х.

Контрольные вопросы

1.Если у Р регулятора Кр увеличить, то как изменится δ Х?

2.Что даёт I составляющая у регулятора?

3.На какое свойство и как влияет D составляющая у регулятора?

4.Какой регулятор по качеству самый худший и самый лучший.?

Электрические схемы регуляторов

На Рис. 97 показаны возможные варианты реализации регуляторов на операционных усилителях. Р регулятор реализован на DA1 .

Коэффициент усиления Р составляющей Кр = Rp/ R1 . В схеме ,PID регулятора на DA1 выполнен повторитель Р составляющей т.к. К = R/R=1 , а функции усилителя выполняет DA 4, котораяодновременно являетсясравнивающим устройством , котор oe сравнивает сигнал от задатчика +U с сигналом от датчика - Ux. Их разность е= U - Ux подаётся на вход DA . Знак е зависит от направления измененияпараметра. Настроечные параметры для I части Т i = Ri С i , и для D части Td=RdCd. На DA5 Выполнен сумматор, который суммирует все составляющие и на выходе получаем сигнал, изменяющийся по PID закону.

P регулятор

I регулятор

D регулятор

PID регулятор

Рис. 97Электрические схемы P, I, D, и PID регуляторов

Закон регулирования электронного Т i, Т d.

1 – без регулятора

2 – I регулятор

3 – P регулятор

4 – PI регулятор

5 – PD регулятор

6 – PID регулятор

X 0 - начальное значение регулируемого параметра

δ X – статическая ошибка

Значительно улучшить точность регулирования можно применением ПИД-закона (Пропорционально-Интегрально-Дифференциальный закон регулирования).
Для реализации ПИД-закона используются три основные переменные:
P – зона пропорциональности, %;
I – время интегрирования, с;
D – время дифференцирования, с.
Ручная настройка ПИД-регулятора (определение значений параметров Р, I, D), обеспечивающая требуемое качество регулирования, достаточно сложна и на практике редко используется. ПИД-регуляторы серии UT/UP обеспечивают автоматическую настройку ПИД-параметров под конкретный процесс регулирования, сохраняя при этом возможность их ручной корректировки.

Пропорциональная составляющая
В зоне пропорциональности, определяемой коэффициентом Р, сигнал управления будет изменяться пропорционально разнице между уставкой и действительным значением параметра (рассогласованию):

сигнал управления = 100/P E,

где E – рассогласование.
Коэффициент пропорциональности (усиления) К является величиной обратнопропорциональной Р:

Зона пропорциональности определяется относительно заданной уставки регулирования, и внутри этой зоны сигнал регулирования изменяется от 0 до 100%, т. е. при равенстве действительного значения и уставки выходной сигнал будет иметь значение 50%.

где Р – зона пропорциональности;
ST – уставка регулирования.
Например:
диапазон измерения 0…1000 °С;
уставка регулирования ST = 500 °С;
зона пропорциональности P = 5%, что составляет 50 °С (5% от 1000 °С);
при значении температуры 475 °С и ниже управляющий сигнал будет иметь величину 100%; при 525 °С и выше – 0%. В диапазоне 475…525 °С (в зоне пропорциональности) управляющий сигнал будет изменяться пропорционально величине рассогласования с коэффициентом усиления К = 100/Р = 20.
Уменьшение значения зоны пропорциональности Р увеличивает реакцию регулятора на рассогласование, т. е. малому рассогласованию будет соответствовать большее значение управляющего сигнала. Но при этом, из-за большого усиления, процесс принимает колебательный характер около значения уставки, и точного регулирования добиться не удастся. При излишнем увеличении зоны пропорциональности регулятор будет слишком медленно реагировать на образующееся рассогла­сование и не сможет успевать отслеживать динамику процесса. Для того, чтобы компенсировать эти недостатки пропорционального регулирования, вводится дополнительная временная характеристика – интегральная составляющая.

Интегральная составляющая
Определяется постоянной времени интегрирования I, является функцией времени и обеспечивает изменение коэффициента усиления (сдвиг зоны пропорциональности) на заданном промежутке времени.

сигнал управления = 100/P E + 1/I ∫ E dt.

Как видно из рисунка, если пропорциональная составляющая закона регулирования не обеспечивает уменьшение рассогласования, то интегральная составляющая начинает на периоде времени I плавно увеличивать коэффициент усиления. Через период времени I процесс этот повторяется. Если же рассогласование мало (или быстро уменьшается), то коэффициент усиления не увеличивается и, в случае равенства значения параметра заданной уставке, принимает какое-то минимальное значение. В этом плане об интегральной составляющей говорят как о функции автоматического выключения регулирования. В случае регулирования по ПИД-закону переходная характеристика процесса будет представлять собой колебания, постепенно затухающие к значению уставки.

Дифференциальная составляющая
Многие объекты регулирования достаточно инерционны, т. е. имеют задержку реакции на приложенное воздействие (мертвое время) и продолжают реагировать после снятия управляющего воздействия (время задержки). ПИД-регуляторы на таких обьектах будут всегда запаздывать с включением/выключением управляющего сигнала. Для устранения этого эффекта вводится дифференциальная составляющая, определяемая постоянной времени дифференцирования D, и обеспечивается полная реализация ПИД-закона управления. Дифференциальная составляющая есть производная во времени от рассогласования, т. е. является функцией скорости изменения параметра регулирования. В случае, когда рассогласование становится постоянной величиной, дифференциальная составляющая перестает оказывать воздействие на сигнал управления.

сигнал управ. = 100/P E + 1/I ∫ E dt + D d/dt E.

С введением дифференциальной составляющей регулятор начинает учитывать мертвое время и время задержки, заранее изменяя сигнал управления. Это позволяет значительно уменьшить колебания процесса около значения уставки и добиться более быстрого завершения переходного процесса.
Таким образом, ПИД-регуляторы, генерируя управляющий сигнал, учитывают характеристики самого объекта управления, т.е. проводят анализ рассогласования на величину, на продолжительность и скорость изменения. Иными словами, ПИД-регулятор "предвидит" реакцию объекта регулирования на сигнал управления и начинает изменять управляющее воздействие не при достижении значения уставки, а заранее.

5. Передаточная функция какого звена представлена: К(р) = К/Тр

Можно утверждать, что наибольшее быстродействие обеспечивает П-закон , - исходя из соотношения tp / T d .

Однако, если коэффициент усиления П-регулятора Кр мал (чаще всего это наблюдается в с запаздыванием), то такой не обеспечивает высокой точности регулирования, т.к. в этом случае велика величина .

Если Кр > 10, то П-регулятор приемлем, а если Если Кр < 10, то требуется введение в закон управления составляющей.

ПИ-закон регулирования

Наиболее распространенным на практике является ПИ-регулятор, который обладает следующими достоинствами:

1. Обеспечивает нулевую регулирования.
2. Достаточно прост в настройке, т.к. настраиваются только два параметра, а именно коэффициент усиления Кр и постоянная времени интегрирования Ti. В таком регуляторе имеется возможность оптимизации величины отношения Кр/Ti-min, что обеспечивает управление с минимально возможной среднеквадратичной регулирования.
3. Малая чувствительность к шумам в измерения (в отличие от ПИД-регулятора).

ПИД-закон регулирования

Для наиболее ответственных контуров регулирования можно рекомендовать использование , обеспечивающего наиболее высокое быстродействие в системе.

Однако следует учитывать, что это выполняется только при его оптимальных настройках (настраиваются три параметра).

С увеличением запаздывания в системе резко возрастают отрицательные фазовые сдвиги, что снижает эффект действия дифференциальной составляющей регулятора. Поэтому качество ПИД-регулятора для систем с большим запаздыванием становится сравнимо с качеством работы ПИ-регулятора.

Кроме этого, наличие шумов в канале измерения в системе с ПИД-регулятором приводит к значительным случайным колебаниям управляющего сигнала регулятора, что увеличивает дисперсию ошибки регулирования и износ механизма.

Таким образом, ПИД-регулятор следует выбирать для систем регулирования, с относительно малым уровнем шумов и величиной запаздывания в управления. Примерами таких систем является системы регулирования температуры.