Основы · 11 мин чтения

PID-регулятор на Arduino: настройка Kp, Ki, Kd с примерами кода

Что такое PID-регулятор и как он работает? Пропорциональная, интегральная и дифференциальная составляющие, библиотека PID для Arduino, настройка Kp/Ki/Kd, код для регулирования температуры и робота, следующего по линии.

PID-регулирование — это метод с обратной связью, который удерживает систему на нужном тебе значении: он непрерывно вычисляет разницу между измеренным значением и целью (ошибку) и подстраивает выход под эту ошибку. В проектах на Arduino его используют, чтобы держать нагреватель ровно на 45 °C, вращать мотор с постоянной скоростью или вести робота точно по середине линии. Название складывается из трёх частей: пропорциональная (P) составляющая смотрит на текущую ошибку, интегральная (I) — на ошибку, накопленную в прошлом, а дифференциальная (D) — на то, как быстро ошибка меняется. Взвешенная сумма этих трёх составляющих задаёт значение ШИМ (PWM), которое идёт на мотор или нагреватель.

Формулы поначалу пугают, но логика PID очень похожа на то, что ты и так делаешь не задумываясь, когда ведёшь машину. В этой статье сначала станет понятно, почему простое двухпозиционное регулирование раскачивает систему, а затем три составляющие раскроются на интуитивных примерах. Потом ты соберёшь регулятор температуры с библиотекой PID для Arduino на NTC-термисторе и MOSFET, научишься пошагово настраивать Kp, Ki и Kd и запустишь робота, следующего по линии, с PID, написанным без библиотеки. Напоследок запустим тот же алгоритм на ESP32 и на Raspberry Pi Pico с MicroPython.

Почему двухпозиционного регулирования недостаточно?

Самый простой способ управления — двухпозиционное регулирование (вкл/выкл): если температура ниже цели, включаем нагреватель на полную мощность, если выше — выключаем. Термостат домашнего котла и аквариумный нагреватель в основном так и работают. Проблема в том, что после выключения нагревателя накопленное в нём тепло продолжает уходить в окружающую среду, поэтому температура проскакивает цель на несколько градусов. Когда начинается остывание, нагреватель снова включается, но пока он прогревается, температура опускается ниже цели. В итоге получается «пила», которая постоянно поднимается и опускается вокруг цели. Чтобы сгладить это, между двумя порогами оставляют зазор (гистерезис): реле щёлкает реже, зато амплитуда колебаний растёт. Для стола 3D-принтера, инкубатора или мотора, который должен вращаться с постоянной скоростью, где нужно держаться в пределах ±0,5 °C, этого мало. PID же выдаёт плавный выход между полной мощностью и нулём и заранее снижает мощность по мере приближения системы к цели.

МетодКак принимает решениеПлюсыМинусыТипичное применение
Двухпозиционное (вкл/выкл)Ниже цели — полная мощность, выше — выключеноОчень просто, можно сделать даже на релеПостоянные колебания и перерегулирование, износ релеТермостат котла, аквариумный нагреватель
PВыход пропорционален ошибкеПлавная реакция, лёгкая настройкаОстаётся статическая ошибкаПростое регулирование положения и уровня
PIПропорциональная часть + накопленная ошибкаУстраняет статическую ошибкуБольше перерегулирование, насыщение интегратораРегулирование температуры, расхода и скорости мотора
PIDПропорциональная часть + накопленная ошибка + скорость измененияБыстро, малое перерегулирование, точноСложно настроить, чувствителен к шуму3D-принтер, дрон, балансирующий робот, робот, следующий по линии

Что такое PID-регулирование и как оно работает?

На каждом проходе цикла PID сначала вычисляет ошибку: ошибка = целевое значение (setpoint) − измеренное значение (input). Затем он оценивает эту ошибку тремя разными способами и складывает результаты: выход = Kp·e + Ki·∫e·dt + Kd·de/dt. Здесь Kp, Ki и Kd — коэффициенты, которые задаёшь ты; они определяют, какой вклад каждая составляющая вносит в выход. В микроконтроллере интеграл вычисляется так: на каждом отсчёте произведение ошибки на период дискретизации прибавляется к накопленной сумме, а производная — как разница двух последних измерений, делённая на период дискретизации. Поэтому для правильной работы PID важно проводить измерения через фиксированные интервалы, например каждые 10 мс или каждые 500 мс. Представь, что едешь на машине по полосе: чем дальше ты от полосы, тем сильнее поворачиваешь руль (P); если боковой ветер постоянно сносит, ты привыкаешь держать руль чуть повёрнутым (I); а когда быстро приближаешься к полосе, заранее ослабляешь поворот (D).

СоставляющаяНа что смотритИнтуитивная аналогияЕсли слишком много
P (пропорциональная)Текущая ошибкаЧем дальше ты от полосы, тем сильнее поворачиваешь рульБыстрые колебания, дрожание
I (интегральная)Ошибка, накопленная со временемПри боковом ветре привыкаешь держать руль чуть повёрнутымМедленные широкие колебания, большое перерегулирование
D (дифференциальная)Скорость изменения ошибкиБыстро приближаясь к полосе, заранее ослабляешь поворотЧрезмерная реакция на шум, дрожащий выход

Пропорциональная (P) составляющая: реакция пропорционально ошибке

Пропорциональная составляющая меняет выход прямо пропорционально величине ошибки. При Kp = 20 ошибка в 3 °C даёт 60 единиц ШИМ, а ошибка в 1 °C — 20 единиц; по мере приближения к цели мощность сама снижается. Чем больше Kp, тем быстрее реагирует система, но после определённого предела она начинает проскакивать цель и возвращаться назад, то есть колебаться. У регулирования только на P есть серьёзный недостаток — статическая ошибка (steady-state error). Допустим, чтобы держать нагреватель на 45 °C, нужна постоянная мощность 80 единиц, компенсирующая уходящее в окружающую среду тепло. Если есть только P-составляющая, эти 80 единиц получаются лишь при наличии ошибки: 80 / 20 = 4 °C. То есть система устанавливается около 41 °C и цели так и не достигает. Увеличение Kp уменьшает этот разрыв, но усиливает колебания.

Интегральная (I) составляющая: убирает статическую ошибку

Интегральная составляющая суммирует ошибку во времени. Даже маленькая ошибка, если она держится долго, увеличивает сумму, и выход медленно растёт, пока ошибка не станет нулевой. В примере выше нужные 80 единиц мощности теперь обеспечивает интегральная составляющая, P-составляющая падает до нуля, и температура устанавливается ровно на 45 °C. Чем больше Ki, тем быстрее закрывается статическая ошибка; если Ki слишком велик, система делает медленные широкие колебания. Известная ловушка интеграла — ситуация, которую называют насыщением интегратора (windup): если нагреватель уже работает на полную мощность и не может достичь цели, интеграл продолжает впустую расти, и когда цель достигнута, из-за накопленного значения температура ещё долго держится выше цели. Решение — ограничить интеграл пределами выхода; библиотека PID для Arduino делает это автоматически через SetOutputLimits.

Дифференциальная (D) составляющая: тормозит при подходе к цели

Дифференциальная составляющая смотрит, насколько быстро меняется ошибка, и даёт своего рода прогноз. Если температура быстро приближается к цели, ошибка быстро уменьшается; D-составляющая работает против этого изменения, заранее урезает мощность и уменьшает перерегулирование (overshoot). С роботом то же самое: робот, который быстро поворачивает к линии, смягчает поворот ещё до того, как её пересечёт. Слабое место D-составляющей — чувствительность к шуму. Если показания аналогового датчика на каждом измерении скачут на несколько единиц, производная воспринимает эти мелкие скачки как большие изменения, и выход дрожит. Поэтому показания датчика нужно усреднять или фильтровать; подробности — в статье о фильтрации данных датчиков. Кроме того, хорошие реализации PID берут производную не от ошибки, а от измерения; так при резкой смене цели на выходе не возникает скачка («рывок» по производной, derivative kick).

Пример 1: регулирование температуры с библиотекой PID для Arduino

В первом примере будем держать небольшой нагреватель (нагревательную пластину на 12 V или мощный резистор) на 45 °C. Температуру измерим делителем напряжения из NTC-термистора на 10 kΩ и постоянного резистора на 10 kΩ, а нагревателем будем управлять по ШИМ через N-канальный MOSFET с логическим уровнем управления (например, IRLZ44N). В Arduino IDE открой «Менеджер библиотек» (Library Manager), найди PID и установи библиотеку PID от Brett Beauregard (PID_v1). Эта библиотека сама берёт на себя такие детали, как управление периодом дискретизации, ограничение выхода, защиту от насыщения интегратора и вычисление производной по измерению. Подробности подключения MOSFET — в статье о MOSFET с Arduino.

Датчик температуры на NTC-термисторе
NTC-термистор на 10 kΩ: с ростом температуры его сопротивление уменьшается; в PID-регулировании температуры он служит измерительным элементом.
ПодключениеArduino UnoESP32Raspberry Pi Pico
Питание делителя (верхний вывод постоянного резистора 10 kΩ)5V3V33V3
Точка соединения NTC и постоянного резистораA0GPIO 34GP26 (ADC0)
Нижний вывод NTCGNDGNDGND
Затвор MOSFET (через 220 Ω, с 10 kΩ на GND)D9GPIO 25GP15
Исток MOSFETGNDGNDGND
НагревательМежду +12 V и стоком MOSFETМежду +12 V и стоком MOSFETМежду +12 V и стоком MOSFET
Никогда не питай нагреватель напрямую от пина Arduino: пин выдаёт максимум около 20–40 mA, а нагреватель потребляет амперы. Минус адаптера на 12 V должен быть общим с GND Arduino, иначе MOSFET не откроется как следует. ESP32 и Pico выдают 3,3 V, поэтому вместо IRLZ44N выбери MOSFET, который полностью открывается при 3,3 V (например, AO3400); а если нагрузка индуктивная, например вентилятор или мотор, добавь параллельно ей обратный (защитный) диод.
C++ (Arduino IDE)
1#include <PID_v1.h>
2
3const int NTC_PIN = A0;        // NTC bölücü orta noktası / NTC divider midpoint
4const int HEATER_PIN = 9;      // MOSFET gate (PWM) / MOSFET gate (PWM)
5
6const float R_FIXED = 10000.0; // sabit direnç / fixed resistor
7const float R0 = 10000.0;      // NTC'nin 25 °C direnci / NTC resistance at 25 °C
8const float T0 = 298.15;       // 25 °C kelvin cinsinden / 25 °C in kelvin
9const float BETA = 3950.0;     // NTC Beta katsayısı / NTC beta coefficient
10
11double setpoint = 45.0;        // hedef sıcaklık / target temperature
12double input = 0;              // ölçülen sıcaklık / measured temperature
13double output = 0;             // ısıtıcı gücü 0-255 / heater power 0-255
14
15double Kp = 20.0, Ki = 0.5, Kd = 10.0;   // başlangıç değerleri / starting values
16PID heaterPID(&input, &output, &setpoint, Kp, Ki, Kd, DIRECT);
17
18float readTemperature() {
19  long sum = 0;
20  for (int i = 0; i < 16; i++) {
21    sum += analogRead(NTC_PIN);            // 16 ölçüm ortalaması / average of 16 readings
22  }
23  float adc = sum / 16.0;
24  adc = constrain(adc, 1.0, 1022.0);       // sıfıra bölmeyi önle / avoid division by zero
25  float r = R_FIXED * adc / (1023.0 - adc);                // NTC direnci / NTC resistance
26  float kelvin = 1.0 / (1.0 / T0 + log(r / R0) / BETA);    // Beta denklemi / beta equation
27  return kelvin - 273.15;
28}
29
30void setup() {
31  Serial.begin(115200);
32  pinMode(HEATER_PIN, OUTPUT);
33  input = readTemperature();
34  heaterPID.SetOutputLimits(0, 255);       // analogWrite aralığı / analogWrite range
35  heaterPID.SetSampleTime(500);            // 500 ms'de bir hesapla / compute every 500 ms
36  heaterPID.SetMode(AUTOMATIC);            // PID'yi başlat / start the PID
37}
38
39void loop() {
40  input = readTemperature();
41  if (heaterPID.Compute()) {               // yeni çıkış hazırsa / if a new output is ready
42    analogWrite(HEATER_PIN, (int)output);
43    Serial.print(setpoint);                // Seri Çizici için / for the Serial Plotter
44    Serial.print(' ');
45    Serial.print(input);
46    Serial.print(' ');
47    Serial.println(output / 255.0 * 100.0); // güç yüzdesi / power percent
48  }
49}

В коде функция readTemperature() снижает шум, усредняя 16 измерений, вычисляет сопротивление NTC по формуле делителя (R = 10 kΩ · adc / (1023 − adc)) и переводит его в градусы Цельсия по уравнению с B-коэффициентом (B = 3950). SetOutputLimits(0, 255) держит выход в диапазоне analogWrite и не даёт интегралу выйти за эти пределы. SetSampleTime(500) заставляет PID считать раз в полсекунды; тепло — медленно меняющаяся величина, так что этого достаточно. Compute() возвращает true только тогда, когда пришло время отсчёта, поэтому внутри loop() не стоит использовать delay(). Если открыть три значения, которые выводятся в порт, в «Плоттере по последовательному соединению» (Serial Plotter) из меню «Инструменты», ты увидишь цель, температуру и мощность нагревателя в процентах на одном графике и сразу заметишь эффект настройки. В охлаждающей системе (например, при охлаждении вентилятором) выход должен расти вместе с температурой; в этом случае используй REVERSE вместо DIRECT.

Как настроить Kp, Ki и Kd: шаг за шагом

  1. Обнули Ki и Kd, начни с небольшого Kp (например, 2) и открой плоттер.
  2. Удваивай Kp шаг за шагом; остановись, когда система начнёт быстро подходить к цели и непрерывно колебаться вокруг неё. Примерно половину этого значения возьми в качестве Kp.
  3. Добавь Kd: начни с малого значения и увеличивай, пока не затухнут перерегулирование и колебания. Если выход начинает дрожать или мотор — жужжать, значит, Kd слишком велик или датчик шумит.
  4. Ki добавляй последним: медленно увеличивай, пока статическая ошибка не будет закрываться за разумное время. Если температура рисует вокруг цели медленные широкие волны, уменьши Ki.
  5. Проверь возмущением: измени цель на 5 °C, подуй на нагреватель или слегка толкни робота рукой; посмотри, за какое время и с каким перерегулированием система приходит в норму.
  6. При желании возьми за отправную точку метод Циглера — Никольса (Ziegler-Nichols): только с P измерь коэффициент, при котором начинаются незатухающие колебания (Ku), и период колебаний (Tu, в секундах); начни с Kp = 0,6·Ku, Ki = 1,2·Ku / Tu, Kd = 0,075·Ku·Tu и доведи настройку вручную.
При увеличении коэффициентаВремя нарастанияПеререгулирование (overshoot)Время установленияСтатическая ошибка
KpСокращаетсяРастётМеняется малоУменьшается
KiСокращаетсяРастётУвеличиваетсяУстраняется
KdМеняется малоУменьшаетсяСокращаетсяТеоретически не влияет

Пример 2: PID в роботе, следующем по линии

Инфракрасный датчик линии TCRT5000
Инфракрасный отражательный датчик TCRT5000: отличает чёрную поверхность от белой; в роботе, следующем по линии, даёт входной сигнал для PID.

В роботе, следующем по линии, цель — чтобы линия оставалась точно посередине робота. Взвешенное среднее показаний трёх аналоговых датчиков TCRT5000, установленных слева, по центру и справа, превращает положение линии в число от 0 (крайнее левое) до 2000 (крайнее правое); 1000 — ровно по центру. Ошибка — это разница между положением и 1000. Поправка, которую выдаёт PID, прибавляется к скорости левого мотора и вычитается из скорости правого, поэтому робот плавно поворачивает к линии. Роботы с простой логикой вкл/выкл (линия слева — повернуть налево, справа — направо) едут медленно и рыскают, а робот с PID проходит ту же трассу гораздо быстрее и по ровной траектории. В этом примере PID пишем с нуля, без библиотеки; моторами управляет драйвер L298N.

C++ (Arduino IDE)
1const int SENSOR_PINS[3] = {A0, A1, A2};   // sol, orta, sağ / left, center, right
2
3const int ENA = 5, IN1 = 7, IN2 = 8;       // sol motor / left motor
4const int ENB = 6, IN3 = 9, IN4 = 10;      // sağ motor / right motor
5
6const int BASE_SPEED = 150;                // düz giderken hız / cruising speed
7float Kp = 0.1, Ki = 0.0, Kd = 0.004;      // robota göre ayarla / tune for your robot
8
9float lastError = 0;
10float integral = 0;
11int lastPosition = 1000;
12unsigned long lastTime = 0;
13
14int readPosition() {
15  long sum = 0, weighted = 0;
16  int maxValue = 0;
17  for (int i = 0; i < 3; i++) {
18    int v = analogRead(SENSOR_PINS[i]);    // siyah çizgi = yüksek değer / black line = high value
19    weighted += (long)v * i * 1000L;
20    sum += v;
21    if (v > maxValue) maxValue = v;
22  }
23  if (maxValue > 500) {                    // çizgi görülüyor / line is visible
24    lastPosition = weighted / sum;         // 0 sol, 1000 orta, 2000 sağ / 0 left, 1000 center, 2000 right
25  }
26  return lastPosition;                     // çizgi kaybolursa son konum / last position if line is lost
27}
28
29void setMotor(int en, int inA, int inB, int speed) {
30  speed = constrain(speed, -255, 255);
31  if (speed >= 0) {
32    digitalWrite(inA, HIGH);               // ileri / forward
33    digitalWrite(inB, LOW);
34  } else {
35    digitalWrite(inA, LOW);                // geri / backward
36    digitalWrite(inB, HIGH);
37    speed = -speed;
38  }
39  analogWrite(en, speed);
40}
41
42void setup() {
43  int pins[] = {ENA, IN1, IN2, ENB, IN3, IN4};
44  for (int i = 0; i < 6; i++) {
45    pinMode(pins[i], OUTPUT);
46  }
47  lastTime = millis();
48}
49
50void loop() {
51  unsigned long now = millis();
52  if (now - lastTime < 10) return;         // 10 ms örnekleme / 10 ms sampling
53  float dt = (now - lastTime) / 1000.0;    // saniye cinsinden / in seconds
54  lastTime = now;
55
56  float error = readPosition() - 1000;     // negatif = çizgi solda / negative = line on the left
57  integral += error * dt;
58  integral = constrain(integral, -500.0, 500.0);   // windup sınırı / windup limit
59  float derivative = (error - lastError) / dt;
60  lastError = error;
61
62  float correction = Kp * error + Ki * integral + Kd * derivative;
63  setMotor(ENA, IN1, IN2, (int)(BASE_SPEED + correction));
64  setMotor(ENB, IN3, IN4, (int)(BASE_SPEED - correction));
65}

Датчики подключены к A0, A1 и A2, выводы ENA и ENB драйвера L298N — к ШИМ-пинам D5 и D6, а выводы IN1–IN4 — к D7, D8, D9 и D10; не забудь снять перемычки (jumper) с ENA и ENB. Цикл выполняется каждые 10 мс с помощью millis(); так dt остаётся постоянным, а коэффициенты ведут себя предсказуемо. Почему вместо delay() используется millis(), объясняется в статье о millis и delay. Если ошибка отрицательная, линия слева: поправка становится отрицательной, левый мотор замедляется, правый ускоряется, и робот поворачивает налево. Поскольку ошибка по модулю не превышает 1000, Kp = 0.1 означает поправку примерно в 100 единиц ШИМ при максимальной ошибке. Производная считается в расчёте на секунду, поэтому Kd вполне может выглядеть таким маленьким, как 0.004. В роботе, следующем по линии, Ki обычно держат нулевым или очень малым; интеграл полезен, только если робота постоянно уводит в одну сторону (например, один мотор слабее другого). Если твои датчики показывают высокое значение на белой поверхности и низкое на чёрной линии, инвертируй показание как 1023 − v.

PID на ESP32 и Raspberry Pi Pico

Библиотека PID_v1 написана на чистом C++, поэтому на ESP32 она работает без изменений; достаточно подключить NTC к GPIO 34, а затвор MOSFET — к GPIO 25. Различия — в железе: АЦП ESP32 12-битный (0–4095) и нелинеен у краёв диапазона; если держать измеряемое напряжение в пределах от 0,3 до 2,8 V, результат будет лучше. Для ШИМ вместо analogWrite используется периферийный модуль LEDC, а поскольку этот API изменился в ядре 3.x, в коде есть проверка версии. Благодаря высокой скорости и двум ядрам ESP32 может одновременно выполнять цикл PID и принимать новую целевую температуру с веб-страницы.

C++ (Arduino IDE)
1#include <PID_v1.h>
2
3const int NTC_PIN = 34;        // ADC1 girişi / ADC1 input
4const int HEATER_PIN = 25;     // MOSFET gate / MOSFET gate
5const int PWM_FREQ = 1000;     // 1 kHz PWM / 1 kHz PWM
6const int PWM_BITS = 8;        // 0-255 çözünürlük / 0-255 resolution
7
8double setpoint = 45.0, input = 0, output = 0;
9PID heaterPID(&input, &output, &setpoint, 20.0, 0.5, 10.0, DIRECT);
10
11float readTemperature() {
12  long sum = 0;
13  for (int i = 0; i < 16; i++) {
14    sum += analogRead(NTC_PIN);            // 12 bit: 0-4095 / 12-bit: 0-4095
15  }
16  double adc = constrain(sum / 16.0, 1.0, 4094.0);
17  double r = 10000.0 * adc / (4095.0 - adc);                     // NTC direnci / NTC resistance
18  return 1.0 / (1.0 / 298.15 + log(r / 10000.0) / 3950.0) - 273.15;
19}
20
21void setup() {
22  Serial.begin(115200);
23  analogReadResolution(12);
24#if ESP_ARDUINO_VERSION_MAJOR >= 3
25  ledcAttach(HEATER_PIN, PWM_FREQ, PWM_BITS);   // çekirdek 3.x / core 3.x
26#else
27  ledcSetup(0, PWM_FREQ, PWM_BITS);             // çekirdek 2.x, kanal 0 / core 2.x, channel 0
28  ledcAttachPin(HEATER_PIN, 0);
29#endif
30  input = readTemperature();
31  heaterPID.SetOutputLimits(0, 255);
32  heaterPID.SetSampleTime(500);
33  heaterPID.SetMode(AUTOMATIC);
34}
35
36void loop() {
37  input = readTemperature();
38  if (heaterPID.Compute()) {
39#if ESP_ARDUINO_VERSION_MAJOR >= 3
40    ledcWrite(HEATER_PIN, (uint32_t)output);    // pin ile yaz / write by pin
41#else
42    ledcWrite(0, (uint32_t)output);             // kanal ile yaz / write by channel
43#endif
44    Serial.printf("%.1f %.2f %.0f\n", setpoint, input, output / 255.0 * 100.0);
45  }
46}

Готового модуля PID для MicroPython на Raspberry Pi Pico нет, поэтому напишем алгоритм в виде небольшого класса. Этот класс повторяет три важные вещи, которые делает библиотека для Arduino: держит интеграл в пределах выхода (anti-windup), берёт производную от измерения и учитывает период дискретизации (dt). АЦП Pico через read_u16() возвращает значения в диапазоне 0–65535; выход PID вычисляется в диапазоне 0–255 и умножается на 257, чтобы перевести его в 16 бит для duty_u16(). Так значения Kp, Ki и Kd, подобранные на Arduino, можно без изменений использовать и на Pico. Делитель с NTC подключён к GP26, затвор MOSFET — к GP15. Если MicroPython в новинку, начни со статьи об основах MicroPython.

MicroPython
1from machine import ADC, Pin, PWM
2import math
3import time
4
5ntc = ADC(26)                     # GP26 = ADC0, NTC bölücüsü / NTC divider
6heater = PWM(Pin(15))             # MOSFET gate / MOSFET gate
7heater.freq(1000)                 # 1 kHz PWM / 1 kHz PWM
8
9R_FIXED = 10000                   # sabit direnç / fixed resistor
10R0 = 10000                        # NTC'nin 25 °C direnci / NTC resistance at 25 °C
11T0 = 298.15                       # 25 °C kelvin cinsinden / 25 °C in kelvin
12BETA = 3950                       # Beta katsayısı / beta coefficient
13SETPOINT = 45.0                   # hedef sıcaklık / target temperature
14
15def read_temp():
16    total = 0
17    for _ in range(16):
18        total += ntc.read_u16()   # 16 ölçüm ortalaması / average of 16 readings
19    adc = min(max(total / 16, 1), 65534)
20    r = R_FIXED * adc / (65535 - adc)
21    return 1 / (1 / T0 + math.log(r / R0) / BETA) - 273.15
22
23class PID:
24    def __init__(self, kp, ki, kd, out_min, out_max):
25        self.kp, self.ki, self.kd = kp, ki, kd
26        self.out_min, self.out_max = out_min, out_max
27        self.i_term = 0
28        self.last_input = None
29
30    def compute(self, setpoint, measurement, dt):
31        error = setpoint - measurement
32        self.i_term += self.ki * error * dt                               # biriken hata / accumulated error
33        self.i_term = min(max(self.i_term, self.out_min), self.out_max)  # integral sınırı / anti-windup
34        if self.last_input is None:
35            d_input = 0
36        else:
37            d_input = (measurement - self.last_input) / dt                # ölçümden türev / derivative on measurement
38        self.last_input = measurement
39        out = self.kp * error + self.i_term - self.kd * d_input
40        return min(max(out, self.out_min), self.out_max)
41
42pid = PID(20, 0.5, 10, 0, 255)    # Arduino ile aynı katsayılar / same gains as Arduino
43last = time.ticks_ms()
44
45while True:
46    now = time.ticks_ms()
47    if time.ticks_diff(now, last) >= 500:                                 # 500 ms örnekleme / 500 ms sampling
48        dt = time.ticks_diff(now, last) / 1000
49        last = now
50        temp = read_temp()
51        power = pid.compute(SETPOINT, temp, dt)
52        heater.duty_u16(int(power * 257))                                 # 0-255 -> 0-65535
53        print(SETPOINT, round(temp, 2), round(power))

Идеи проектов с PID-регулированием

  • Точный термостат: в проекте термостата на Arduino используй PID вместо вкл/выкл, чтобы держать инкубатор или шкаф для ферментации в пределах ±0,3 °C.
  • Скорость вентилятора по температуре: в проекте управления вентилятором управляй вентилятором через PID с направлением REVERSE и получи тихое и стабильное охлаждение.
  • Быстрый робот, следующий по линии: добавь в проект робота, следующего по линии, 5 датчиков и PID и выйди на соревновательную скорость.
  • Самобалансирующий робот: измеряй угол наклона с MPU-6050 и держи двухколёсного робота вертикально; это одно из самых поучительных применений PID.
  • Солнечный трекер: в проекте солнечного трекера используй разницу между двумя LDR как ошибку и плавно поворачивай панель.
  • Паяльная станция или мини-печь: измеряй высокие температуры термопарой с MAX6675 и управляй нагревателем через PID.
  • Мотор с постоянной скоростью: держи скорость DC-мотора с редуктором и энкодером на заданном значении даже при изменении нагрузки.

Частые ошибки и их решение

ПризнакВероятная причинаРешение
Система постоянно и быстро колеблется вокруг целиСлишком большой Kp или недостаточный KdУменьши Kp на 30–50% и немного увеличь Kd
Цель не достигается, температура остаётся на несколько градусов нижеKi равен нулю или слишком малМедленно увеличивай Ki; проверь, хватает ли мощности нагревателя
Большое и долгое перерегулирование в конце нагреваНасыщение интегратора (windup)Ограничь выход через SetOutputLimits, ограничь интеграл, уменьши Ki
Выход дрожит, мотор жужжитШумный датчик и большой KdУсредняй или фильтруй измерение, уменьши Kd
С ростом температуры растёт и выходНаправление регулирования перепутаноДля охлаждения используй REVERSE или поменяй знак ошибки
Одни и те же коэффициенты то работают хорошо, то плохоНерегулярная дискретизация, delay() в циклеИспользуй постоянный dt через millis(), избегай delay()
Нагреватель всё время на полной мощности, но температура не растётНедостаточное железо (мощность, теплоизоляция, MOSFET)PID не компенсирует нехватку железа; проверь мощность и подключение
При настройке менять коэффициенты, каждый раз заново загружая код, утомительно. Если добавить несколько строк, которые читают из порта команды вроде «p2.5» или «d0.8» и на лету обновляют коэффициенты через SetTunings(Kp, Ki, Kd), хорошую настройку можно найти за считаные минуты, глядя на график в плоттере. Чтобы сделать найденные значения постоянными, их можно сохранить в EEPROM.

PID-регулирование соединяет цикл «измерить — сравнить — исправить» с тремя простыми идеями, и его используют везде — от хобби-проектов до промышленных печей. Сначала посмотри на пределы двухпозиционного регулирования, потом начни с P, затормози с помощью D и закрой статическую ошибку через I; график в плоттере подскажет на каждом шаге. В приложении BlueGrays можно пошагово, со схемами подключения и кодом, посмотреть проекты с деталями из этой статьи — измерение температуры с NTC, распознавание поверхности с TCRT5000, робот-машинку на L298N и управление ШИМ потенциометром — и уже оттуда начать добавлять PID в свой проект.

Частые вопросы

Что такое PID-регулирование и для чего оно нужно?

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

Как подобрать значения Kp, Ki и Kd?

Самый практичный путь — ручная настройка: обнули Ki и Kd, увеличивай Kp, пока система не начнёт колебаться, затем уменьши его вдвое, добавь Kd, чтобы подавить перерегулирование, и последним добавь Ki, чтобы закрыть статическую ошибку. Метод Циглера — Никольса (Ziegler-Nichols) даёт хорошую отправную точку, но тонкая настройка почти всегда делается вручную. Значения зависят от конкретной системы; коэффициенты, скопированные из чужого проекта, в твоей схеме могут не заработать.

Чем PID отличается от двухпозиционного регулирования?

Двухпозиционное регулирование делает выход либо полностью включённым, либо полностью выключенным, поэтому вокруг цели возникают постоянные колебания и перерегулирование. PID же меняет выход плавно, заранее снижает мощность при подходе к цели и убирает статическую ошибку интегральной составляющей. Вкл/выкл проще и дешевле; PID точнее, но требует настройки.

Какую библиотеку PID для Arduino выбрать и как её установить?

Самая распространённая — библиотека PID от Brett Beauregard (PID_v1). В Arduino IDE найди «PID» в «Менеджере библиотек» и установи её, затем подключи в коде заголовочный файл PID_v1.h. Библиотека сама управляет периодом дискретизации, ограничением выхода и защитой от насыщения интегратора.

Что такое насыщение интегратора (integral windup) и как его предотвратить?

Насыщение интегратора (windup) — это ситуация, когда выход уже на пределе (например, нагреватель на полной мощности), а ошибка продолжает накапливаться в интеграле. Когда цель достигнута, из-за накопленного значения система ещё долго проскакивает цель. Чтобы этого избежать, интеграл нужно держать в пределах выхода; в библиотеке PID для Arduino это автоматически делает SetOutputLimits.

Можно ли сделать PID-регулирование с реле?

Да, методом широтно-временного регулирования (time proportioning): например, в окне 5 секунд при выходе PID в 40 процентов реле держат включённым 2 секунды и выключенным 3 секунды. Механические реле быстро изнашиваются от частых переключений, поэтому для такой задачи лучше подходит твердотельное реле (SSR). Для медленных систем вроде нагревателей этот метод работает не хуже ШИМ.

Все проекты
Температура и влажность с DHT11
AR-55Средний

Температура и влажность с DHT11

Насколько тепло в твоей комнате и влажный ли воздух или сухой? Датчик DHT11 измеряет температуру и влажность, а Arduino выводит значения на двухстрочный LCD-экран и обновляет их каждые пару секунд.

4.7(47)
83
Измерение расстояния HC-SR04 (вывод в порт)
AR-27Новичок

Измерение расстояния HC-SR04 (вывод в порт)

Датчик HC-SR04 работает совсем как летучая мышь, которая находит дорогу в темноте: он посылает звук, которого ты не слышишь, слушает эхо и измеряет, насколько далеко предмет перед ним.

4.6(50)
82
Измерение температуры с NTC и LCD-дисплеем 2x16
AR-44Новичок
Premium

Измерение температуры с NTC и LCD-дисплеем 2x16

Измерь температуру вокруг с помощью датчика, похожего на крошечную бусинку. Эта деталь, NTC, при нагреве легче пропускает электричество; Arduino читает это изменение, по формуле переводит его в…

4.5(33)
44
Определение чёрной и белой поверхности с TCRT5000
AR-78Средний
Premium

Определение чёрной и белой поверхности с TCRT5000

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

4.7(40)
49
Чтение отражения (приближения) с TCRT5000
AR-77Средний
Premium

Чтение отражения (приближения) с TCRT5000

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

4.6(33)
43
Робот, объезжающий препятствия
AR-81Продвинутый
Premium

Робот, объезжающий препятствия

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

5.0(38)
49
Машинка на L298N с управлением по Bluetooth
AR-80Продвинутый
Premium

Машинка на L298N с управлением по Bluetooth

Преврати телефон в пульт и управляй своей машинкой-роботом. Arduino получает команды из приложения-пульта на телефоне через Bluetooth-модуль и вращает колёса через драйвер моторов; машинка едет…

5.0(39)
66
Регулировка яркости светодиода потенциометром на ESP32 (аналог → PWM)
ES-13Средний
Premium

Регулировка яркости светодиода потенциометром на ESP32 (аналог → PWM)

В этом проекте яркость светодиода плавно регулируется потенциометром. Пин АЦП ESP32 читает напряжение 0–3,3V с потенциометра, затем это значение превращается в сигнал PWM (широтно-импульсная модуляция) и подаётся на светодиод. В результате при повороте потенциометра светодиод постепенно становится ярче или тусклее. В Arduino Core 3.0+ можно сразу использовать analogWrite(); на ESP32-S2/S3 разрешение АЦП фиксировано — 12 бит.

4.5(19)
32